@mailstep/design-system 0.8.25 → 0.8.26-beta.0

package/ui/index396.es.js

@@ -0,0 +1,395 @@
+import { __commonJSMin as e } from "./index2.es.js";
+//#region node_modules/lodash/fp/_mapping.js
+var t = /* @__PURE__ */ e(((e) => {
+	e.aliasToReal = {
+		each: "forEach",
+		eachRight: "forEachRight",
+		entries: "toPairs",
+		entriesIn: "toPairsIn",
+		extend: "assignIn",
+		extendAll: "assignInAll",
+		extendAllWith: "assignInAllWith",
+		extendWith: "assignInWith",
+		first: "head",
+		conforms: "conformsTo",
+		matches: "isMatch",
+		property: "get",
+		__: "placeholder",
+		F: "stubFalse",
+		T: "stubTrue",
+		all: "every",
+		allPass: "overEvery",
+		always: "constant",
+		any: "some",
+		anyPass: "overSome",
+		apply: "spread",
+		assoc: "set",
+		assocPath: "set",
+		complement: "negate",
+		compose: "flowRight",
+		contains: "includes",
+		dissoc: "unset",
+		dissocPath: "unset",
+		dropLast: "dropRight",
+		dropLastWhile: "dropRightWhile",
+		equals: "isEqual",
+		identical: "eq",
+		indexBy: "keyBy",
+		init: "initial",
+		invertObj: "invert",
+		juxt: "over",
+		omitAll: "omit",
+		nAry: "ary",
+		path: "get",
+		pathEq: "matchesProperty",
+		pathOr: "getOr",
+		paths: "at",
+		pickAll: "pick",
+		pipe: "flow",
+		pluck: "map",
+		prop: "get",
+		propEq: "matchesProperty",
+		propOr: "getOr",
+		props: "at",
+		symmetricDifference: "xor",
+		symmetricDifferenceBy: "xorBy",
+		symmetricDifferenceWith: "xorWith",
+		takeLast: "takeRight",
+		takeLastWhile: "takeRightWhile",
+		unapply: "rest",
+		unnest: "flatten",
+		useWith: "overArgs",
+		where: "conformsTo",
+		whereEq: "isMatch",
+		zipObj: "zipObject"
+	}, e.aryMethod = {
+		1: /* @__PURE__ */ "assignAll.assignInAll.attempt.castArray.ceil.create.curry.curryRight.defaultsAll.defaultsDeepAll.floor.flow.flowRight.fromPairs.invert.iteratee.memoize.method.mergeAll.methodOf.mixin.nthArg.over.overEvery.overSome.rest.reverse.round.runInContext.spread.template.trim.trimEnd.trimStart.uniqueId.words.zipAll".split("."),
+		2: /* @__PURE__ */ "add.after.ary.assign.assignAllWith.assignIn.assignInAllWith.at.before.bind.bindAll.bindKey.chunk.cloneDeepWith.cloneWith.concat.conformsTo.countBy.curryN.curryRightN.debounce.defaults.defaultsDeep.defaultTo.delay.difference.divide.drop.dropRight.dropRightWhile.dropWhile.endsWith.eq.every.filter.find.findIndex.findKey.findLast.findLastIndex.findLastKey.flatMap.flatMapDeep.flattenDepth.forEach.forEachRight.forIn.forInRight.forOwn.forOwnRight.get.groupBy.gt.gte.has.hasIn.includes.indexOf.intersection.invertBy.invoke.invokeMap.isEqual.isMatch.join.keyBy.lastIndexOf.lt.lte.map.mapKeys.mapValues.matchesProperty.maxBy.meanBy.merge.mergeAllWith.minBy.multiply.nth.omit.omitBy.overArgs.pad.padEnd.padStart.parseInt.partial.partialRight.partition.pick.pickBy.propertyOf.pull.pullAll.pullAt.random.range.rangeRight.rearg.reject.remove.repeat.restFrom.result.sampleSize.some.sortBy.sortedIndex.sortedIndexOf.sortedLastIndex.sortedLastIndexOf.sortedUniqBy.split.spreadFrom.startsWith.subtract.sumBy.take.takeRight.takeRightWhile.takeWhile.tap.throttle.thru.times.trimChars.trimCharsEnd.trimCharsStart.truncate.union.uniqBy.uniqWith.unset.unzipWith.without.wrap.xor.zip.zipObject.zipObjectDeep".split("."),
+		3: /* @__PURE__ */ "assignInWith.assignWith.clamp.differenceBy.differenceWith.findFrom.findIndexFrom.findLastFrom.findLastIndexFrom.getOr.includesFrom.indexOfFrom.inRange.intersectionBy.intersectionWith.invokeArgs.invokeArgsMap.isEqualWith.isMatchWith.flatMapDepth.lastIndexOfFrom.mergeWith.orderBy.padChars.padCharsEnd.padCharsStart.pullAllBy.pullAllWith.rangeStep.rangeStepRight.reduce.reduceRight.replace.set.slice.sortedIndexBy.sortedLastIndexBy.transform.unionBy.unionWith.update.xorBy.xorWith.zipWith".split("."),
+		4: [
+			"fill",
+			"setWith",
+			"updateWith"
+		]
+	}, e.aryRearg = {
+		2: [1, 0],
+		3: [
+			2,
+			0,
+			1
+		],
+		4: [
+			3,
+			2,
+			0,
+			1
+		]
+	}, e.iterateeAry = {
+		dropRightWhile: 1,
+		dropWhile: 1,
+		every: 1,
+		filter: 1,
+		find: 1,
+		findFrom: 1,
+		findIndex: 1,
+		findIndexFrom: 1,
+		findKey: 1,
+		findLast: 1,
+		findLastFrom: 1,
+		findLastIndex: 1,
+		findLastIndexFrom: 1,
+		findLastKey: 1,
+		flatMap: 1,
+		flatMapDeep: 1,
+		flatMapDepth: 1,
+		forEach: 1,
+		forEachRight: 1,
+		forIn: 1,
+		forInRight: 1,
+		forOwn: 1,
+		forOwnRight: 1,
+		map: 1,
+		mapKeys: 1,
+		mapValues: 1,
+		partition: 1,
+		reduce: 2,
+		reduceRight: 2,
+		reject: 1,
+		remove: 1,
+		some: 1,
+		takeRightWhile: 1,
+		takeWhile: 1,
+		times: 1,
+		transform: 2
+	}, e.iterateeRearg = {
+		mapKeys: [1],
+		reduceRight: [1, 0]
+	}, e.methodRearg = {
+		assignInAllWith: [1, 0],
+		assignInWith: [
+			1,
+			2,
+			0
+		],
+		assignAllWith: [1, 0],
+		assignWith: [
+			1,
+			2,
+			0
+		],
+		differenceBy: [
+			1,
+			2,
+			0
+		],
+		differenceWith: [
+			1,
+			2,
+			0
+		],
+		getOr: [
+			2,
+			1,
+			0
+		],
+		intersectionBy: [
+			1,
+			2,
+			0
+		],
+		intersectionWith: [
+			1,
+			2,
+			0
+		],
+		isEqualWith: [
+			1,
+			2,
+			0
+		],
+		isMatchWith: [
+			2,
+			1,
+			0
+		],
+		mergeAllWith: [1, 0],
+		mergeWith: [
+			1,
+			2,
+			0
+		],
+		padChars: [
+			2,
+			1,
+			0
+		],
+		padCharsEnd: [
+			2,
+			1,
+			0
+		],
+		padCharsStart: [
+			2,
+			1,
+			0
+		],
+		pullAllBy: [
+			2,
+			1,
+			0
+		],
+		pullAllWith: [
+			2,
+			1,
+			0
+		],
+		rangeStep: [
+			1,
+			2,
+			0
+		],
+		rangeStepRight: [
+			1,
+			2,
+			0
+		],
+		setWith: [
+			3,
+			1,
+			2,
+			0
+		],
+		sortedIndexBy: [
+			2,
+			1,
+			0
+		],
+		sortedLastIndexBy: [
+			2,
+			1,
+			0
+		],
+		unionBy: [
+			1,
+			2,
+			0
+		],
+		unionWith: [
+			1,
+			2,
+			0
+		],
+		updateWith: [
+			3,
+			1,
+			2,
+			0
+		],
+		xorBy: [
+			1,
+			2,
+			0
+		],
+		xorWith: [
+			1,
+			2,
+			0
+		],
+		zipWith: [
+			1,
+			2,
+			0
+		]
+	}, e.methodSpread = {
+		assignAll: { start: 0 },
+		assignAllWith: { start: 0 },
+		assignInAll: { start: 0 },
+		assignInAllWith: { start: 0 },
+		defaultsAll: { start: 0 },
+		defaultsDeepAll: { start: 0 },
+		invokeArgs: { start: 2 },
+		invokeArgsMap: { start: 2 },
+		mergeAll: { start: 0 },
+		mergeAllWith: { start: 0 },
+		partial: { start: 1 },
+		partialRight: { start: 1 },
+		without: { start: 1 },
+		zipAll: { start: 0 }
+	}, e.mutate = {
+		array: {
+			fill: !0,
+			pull: !0,
+			pullAll: !0,
+			pullAllBy: !0,
+			pullAllWith: !0,
+			pullAt: !0,
+			remove: !0,
+			reverse: !0
+		},
+		object: {
+			assign: !0,
+			assignAll: !0,
+			assignAllWith: !0,
+			assignIn: !0,
+			assignInAll: !0,
+			assignInAllWith: !0,
+			assignInWith: !0,
+			assignWith: !0,
+			defaults: !0,
+			defaultsAll: !0,
+			defaultsDeep: !0,
+			defaultsDeepAll: !0,
+			merge: !0,
+			mergeAll: !0,
+			mergeAllWith: !0,
+			mergeWith: !0
+		},
+		set: {
+			set: !0,
+			setWith: !0,
+			unset: !0,
+			update: !0,
+			updateWith: !0
+		}
+	}, e.realToAlias = function() {
+		var t = Object.prototype.hasOwnProperty, n = e.aliasToReal, r = {};
+		for (var i in n) {
+			var a = n[i];
+			t.call(r, a) ? r[a].push(i) : r[a] = [i];
+		}
+		return r;
+	}(), e.remap = {
+		assignAll: "assign",
+		assignAllWith: "assignWith",
+		assignInAll: "assignIn",
+		assignInAllWith: "assignInWith",
+		curryN: "curry",
+		curryRightN: "curryRight",
+		defaultsAll: "defaults",
+		defaultsDeepAll: "defaultsDeep",
+		findFrom: "find",
+		findIndexFrom: "findIndex",
+		findLastFrom: "findLast",
+		findLastIndexFrom: "findLastIndex",
+		getOr: "get",
+		includesFrom: "includes",
+		indexOfFrom: "indexOf",
+		invokeArgs: "invoke",
+		invokeArgsMap: "invokeMap",
+		lastIndexOfFrom: "lastIndexOf",
+		mergeAll: "merge",
+		mergeAllWith: "mergeWith",
+		padChars: "pad",
+		padCharsEnd: "padEnd",
+		padCharsStart: "padStart",
+		propertyOf: "get",
+		rangeStep: "range",
+		rangeStepRight: "rangeRight",
+		restFrom: "rest",
+		spreadFrom: "spread",
+		trimChars: "trim",
+		trimCharsEnd: "trimEnd",
+		trimCharsStart: "trimStart",
+		zipAll: "zip"
+	}, e.skipFixed = {
+		castArray: !0,
+		flow: !0,
+		flowRight: !0,
+		iteratee: !0,
+		mixin: !0,
+		rearg: !0,
+		runInContext: !0
+	}, e.skipRearg = {
+		add: !0,
+		assign: !0,
+		assignIn: !0,
+		bind: !0,
+		bindKey: !0,
+		concat: !0,
+		difference: !0,
+		divide: !0,
+		eq: !0,
+		gt: !0,
+		gte: !0,
+		isEqual: !0,
+		lt: !0,
+		lte: !0,
+		matchesProperty: !0,
+		merge: !0,
+		multiply: !0,
+		overArgs: !0,
+		partial: !0,
+		partialRight: !0,
+		propertyOf: !0,
+		random: !0,
+		range: !0,
+		rangeRight: !0,
+		subtract: !0,
+		zip: !0,
+		zipObject: !0,
+		zipObjectDeep: !0
+	};
+}));
+//#endregion
+export default t();
+export { t as require__mapping };

package/ui/index397.es.js

@@ -0,0 +1,8 @@
+import { __commonJSMin as e } from "./index2.es.js";
+//#region node_modules/lodash/fp/placeholder.js
+var t = /* @__PURE__ */ e(((e, t) => {
+	t.exports = {};
+}));
+//#endregion
+export default t();
+export { t as require_placeholder };

package/ui/index398.es.js

@@ -0,0 +1,213 @@
+import { __commonJSMin as e } from "./index2.es.js";
+import { require__mapping as t } from "./index396.es.js";
+import { require_placeholder as n } from "./index397.es.js";
+//#region node_modules/lodash/fp/_baseConvert.js
+var r = /* @__PURE__ */ e(((e, r) => {
+	var i = t(), a = n(), o = Array.prototype.push;
+	function s(e, t) {
+		return t == 2 ? function(t, n) {
+			return e.apply(void 0, arguments);
+		} : function(t) {
+			return e.apply(void 0, arguments);
+		};
+	}
+	function c(e, t) {
+		return t == 2 ? function(t, n) {
+			return e(t, n);
+		} : function(t) {
+			return e(t);
+		};
+	}
+	function l(e) {
+		for (var t = e ? e.length : 0, n = Array(t); t--;) n[t] = e[t];
+		return n;
+	}
+	function u(e) {
+		return function(t) {
+			return e({}, t);
+		};
+	}
+	function d(e, t) {
+		return function() {
+			for (var n = arguments.length, r = n - 1, i = Array(n); n--;) i[n] = arguments[n];
+			var a = i[t], s = i.slice(0, t);
+			return a && o.apply(s, a), t != r && o.apply(s, i.slice(t + 1)), e.apply(this, s);
+		};
+	}
+	function f(e, t) {
+		return function() {
+			var n = arguments.length;
+			if (n) {
+				for (var r = Array(n); n--;) r[n] = arguments[n];
+				var i = r[0] = t.apply(void 0, r);
+				return e.apply(void 0, r), i;
+			}
+		};
+	}
+	function p(e, t, n, r) {
+		var o = typeof t == "function", m = t === Object(t);
+		if (m && (r = n, n = t, t = void 0), n == null) throw TypeError();
+		r ||= {};
+		var h = {
+			cap: "cap" in r ? r.cap : !0,
+			curry: "curry" in r ? r.curry : !0,
+			fixed: "fixed" in r ? r.fixed : !0,
+			immutable: "immutable" in r ? r.immutable : !0,
+			rearg: "rearg" in r ? r.rearg : !0
+		}, g = o ? n : a, _ = "curry" in r && r.curry, v = "fixed" in r && r.fixed, y = "rearg" in r && r.rearg, b = o ? n.runInContext() : void 0, x = o ? n : {
+			ary: e.ary,
+			assign: e.assign,
+			clone: e.clone,
+			curry: e.curry,
+			forEach: e.forEach,
+			isArray: e.isArray,
+			isError: e.isError,
+			isFunction: e.isFunction,
+			isWeakMap: e.isWeakMap,
+			iteratee: e.iteratee,
+			keys: e.keys,
+			rearg: e.rearg,
+			toInteger: e.toInteger,
+			toPath: e.toPath
+		}, S = x.ary, C = x.assign, w = x.clone, T = x.curry, E = x.forEach, D = x.isArray, O = x.isError, k = x.isFunction, A = x.isWeakMap, j = x.keys, M = x.rearg, N = x.toInteger, P = x.toPath, F = j(i.aryMethod), I = {
+			castArray: function(e) {
+				return function() {
+					var t = arguments[0];
+					return D(t) ? e(l(t)) : e.apply(void 0, arguments);
+				};
+			},
+			iteratee: function(e) {
+				return function() {
+					var t = arguments[0], n = arguments[1], r = e(t, n), i = r.length;
+					return h.cap && typeof n == "number" ? (n = n > 2 ? n - 2 : 1, i && i <= n ? r : c(r, n)) : r;
+				};
+			},
+			mixin: function(e) {
+				return function(t) {
+					var n = this;
+					if (!k(n)) return e(n, Object(t));
+					var r = [];
+					return E(j(t), function(e) {
+						k(t[e]) && r.push([e, n.prototype[e]]);
+					}), e(n, Object(t)), E(r, function(e) {
+						var t = e[1];
+						k(t) ? n.prototype[e[0]] = t : delete n.prototype[e[0]];
+					}), n;
+				};
+			},
+			nthArg: function(e) {
+				return function(t) {
+					var n = t < 0 ? 1 : N(t) + 1;
+					return T(e(t), n);
+				};
+			},
+			rearg: function(e) {
+				return function(t, n) {
+					var r = n ? n.length : 0;
+					return T(e(t, n), r);
+				};
+			},
+			runInContext: function(t) {
+				return function(n) {
+					return p(e, t(n), r);
+				};
+			}
+		};
+		function L(e, t) {
+			if (h.cap) {
+				var n = i.iterateeRearg[e];
+				if (n) return G(t, n);
+				var r = !o && i.iterateeAry[e];
+				if (r) return W(t, r);
+			}
+			return t;
+		}
+		function R(e, t, n) {
+			return _ || h.curry && n > 1 ? T(t, n) : t;
+		}
+		function z(e, t, n) {
+			if (h.fixed && (v || !i.skipFixed[e])) {
+				var r = i.methodSpread[e], a = r && r.start;
+				return a === void 0 ? S(t, n) : d(t, a);
+			}
+			return t;
+		}
+		function B(e, t, n) {
+			return h.rearg && n > 1 && (y || !i.skipRearg[e]) ? M(t, i.methodRearg[e] || i.aryRearg[n]) : t;
+		}
+		function V(e, t) {
+			t = P(t);
+			for (var n = -1, r = t.length, i = r - 1, a = w(Object(e)), o = a; o != null && ++n < r;) {
+				var s = t[n], c = o[s];
+				c != null && !(k(c) || O(c) || A(c)) && (o[s] = w(n == i ? c : Object(c))), o = o[s];
+			}
+			return a;
+		}
+		function H(e) {
+			return J.runInContext.convert(e)(void 0);
+		}
+		function U(e, t) {
+			var n = i.aliasToReal[e] || e, a = i.remap[n] || n, s = r;
+			return function(e) {
+				return p(o ? b : x, n, o ? b[a] : t, C(C({}, s), e));
+			};
+		}
+		function W(e, t) {
+			return K(e, function(e) {
+				return typeof e == "function" ? c(e, t) : e;
+			});
+		}
+		function G(e, t) {
+			return K(e, function(e) {
+				var n = t.length;
+				return s(M(c(e, n), t), n);
+			});
+		}
+		function K(e, t) {
+			return function() {
+				var n = arguments.length;
+				if (!n) return e();
+				for (var r = Array(n); n--;) r[n] = arguments[n];
+				var i = h.rearg ? 0 : n - 1;
+				return r[i] = t(r[i]), e.apply(void 0, r);
+			};
+		}
+		function q(e, t, n) {
+			var r, a = i.aliasToReal[e] || e, o = t, s = I[a];
+			return s ? o = s(t) : h.immutable && (i.mutate.array[a] ? o = f(t, l) : i.mutate.object[a] ? o = f(t, u(t)) : i.mutate.set[a] && (o = f(t, V))), E(F, function(e) {
+				return E(i.aryMethod[e], function(t) {
+					if (a == t) {
+						var n = i.methodSpread[a];
+						return r = n && n.afterRearg ? z(a, B(a, o, e), e) : B(a, z(a, o, e), e), r = L(a, r), r = R(a, r, e), !1;
+					}
+				}), !r;
+			}), r ||= o, r == t && (r = _ ? T(r, 1) : function() {
+				return t.apply(this, arguments);
+			}), r.convert = U(a, t), r.placeholder = t.placeholder = n, r;
+		}
+		if (!m) return q(t, n, g);
+		var J = n, Y = [];
+		return E(F, function(e) {
+			E(i.aryMethod[e], function(e) {
+				var t = J[i.remap[e] || e];
+				t && Y.push([e, q(e, t, J)]);
+			});
+		}), E(j(J), function(e) {
+			var t = J[e];
+			if (typeof t == "function") {
+				for (var n = Y.length; n--;) if (Y[n][0] == e) return;
+				t.convert = U(e, t), Y.push([e, t]);
+			}
+		}), E(Y, function(e) {
+			J[e[0]] = e[1];
+		}), J.convert = H, J.placeholder = J, E(j(J), function(e) {
+			E(i.realToAlias[e] || [], function(t) {
+				J[t] = J[e];
+			});
+		}), J;
+	}
+	r.exports = p;
+}));
+//#endregion
+export default r();
+export { r as require__baseConvert };

package/ui/index399.es.js

@@ -0,0 +1,10 @@
+import { __commonJSMin as e } from "./index2.es.js";
+import { require__WeakMap as t } from "./index334.es.js";
+//#region node_modules/lodash/_metaMap.js
+var n = /* @__PURE__ */ e(((e, n) => {
+	var r = t();
+	n.exports = r && new r();
+}));
+//#endregion
+export default n();
+export { n as require__metaMap };