@lumx/vue 4.17.1-alpha.2 → 4.17.1-alpha.3

package/_internal/node_modules/lodash/castArray.js

@@ -0,0 +1,48 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_isArray } from "./isArray.js";
+//#region ../../node_modules/lodash/castArray.js
+var require_castArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isArray = require_isArray();
+	/**
+	* Casts `value` as an array if it's not one.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.4.0
+	* @category Lang
+	* @param {*} value The value to inspect.
+	* @returns {Array} Returns the cast array.
+	* @example
+	*
+	* _.castArray(1);
+	* // => [1]
+	*
+	* _.castArray({ 'a': 1 });
+	* // => [{ 'a': 1 }]
+	*
+	* _.castArray('abc');
+	* // => ['abc']
+	*
+	* _.castArray(null);
+	* // => [null]
+	*
+	* _.castArray(undefined);
+	* // => [undefined]
+	*
+	* _.castArray();
+	* // => []
+	*
+	* var array = [1, 2, 3];
+	* console.log(_.castArray(array) === array);
+	* // => true
+	*/
+	function castArray() {
+		if (!arguments.length) return [];
+		var value = arguments[0];
+		return isArray(value) ? value : [value];
+	}
+	module.exports = castArray;
+}));
+//#endregion
+export default require_castArray();
+export { require_castArray };

package/_internal/node_modules/lodash/constant.js

@@ -0,0 +1,32 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/constant.js
+var require_constant = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Creates a function that returns `value`.
+	*
+	* @static
+	* @memberOf _
+	* @since 2.4.0
+	* @category Util
+	* @param {*} value The value to return from the new function.
+	* @returns {Function} Returns the new constant function.
+	* @example
+	*
+	* var objects = _.times(2, _.constant({ 'a': 1 }));
+	*
+	* console.log(objects);
+	* // => [{ 'a': 1 }, { 'a': 1 }]
+	*
+	* console.log(objects[0] === objects[1]);
+	* // => true
+	*/
+	function constant(value) {
+		return function() {
+			return value;
+		};
+	}
+	module.exports = constant;
+}));
+//#endregion
+export default require_constant();
+export { require_constant };

package/_internal/node_modules/lodash/eq.js

@@ -0,0 +1,43 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/eq.js
+var require_eq = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Performs a
+	* [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+	* comparison between two values to determine if they are equivalent.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to compare.
+	* @param {*} other The other value to compare.
+	* @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	* var other = { 'a': 1 };
+	*
+	* _.eq(object, object);
+	* // => true
+	*
+	* _.eq(object, other);
+	* // => false
+	*
+	* _.eq('a', 'a');
+	* // => true
+	*
+	* _.eq('a', Object('a'));
+	* // => false
+	*
+	* _.eq(NaN, NaN);
+	* // => true
+	*/
+	function eq(value, other) {
+		return value === other || value !== value && other !== other;
+	}
+	module.exports = eq;
+}));
+//#endregion
+export default require_eq();
+export { require_eq };

package/_internal/node_modules/lodash/flatten.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseFlatten } from "./_baseFlatten.js";
+//#region ../../node_modules/lodash/flatten.js
+var require_flatten = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseFlatten = require__baseFlatten();
+	/**
+	* Flattens `array` a single level deep.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Array
+	* @param {Array} array The array to flatten.
+	* @returns {Array} Returns the new flattened array.
+	* @example
+	*
+	* _.flatten([1, [2, [3, [4]], 5]]);
+	* // => [1, 2, [3, [4]], 5]
+	*/
+	function flatten(array) {
+		return (array == null ? 0 : array.length) ? baseFlatten(array, 1) : [];
+	}
+	module.exports = flatten;
+}));
+//#endregion
+export default require_flatten();
+export { require_flatten };

package/_internal/node_modules/lodash/hasIn.js

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseHasIn } from "./_baseHasIn.js";
+import { require__hasPath } from "./_hasPath.js";
+//#region ../../node_modules/lodash/hasIn.js
+var require_hasIn = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseHasIn = require__baseHasIn(), hasPath = require__hasPath();
+	/**
+	* Checks if `path` is a direct or inherited property of `object`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Object
+	* @param {Object} object The object to query.
+	* @param {Array|string} path The path to check.
+	* @returns {boolean} Returns `true` if `path` exists, else `false`.
+	* @example
+	*
+	* var object = _.create({ 'a': _.create({ 'b': 2 }) });
+	*
+	* _.hasIn(object, 'a');
+	* // => true
+	*
+	* _.hasIn(object, 'a.b');
+	* // => true
+	*
+	* _.hasIn(object, ['a', 'b']);
+	* // => true
+	*
+	* _.hasIn(object, 'b');
+	* // => false
+	*/
+	function hasIn(object, path) {
+		return object != null && hasPath(object, path, baseHasIn);
+	}
+	module.exports = hasIn;
+}));
+//#endregion
+export default require_hasIn();
+export { require_hasIn };

package/_internal/node_modules/lodash/identity.js

@@ -0,0 +1,27 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/identity.js
+var require_identity = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* This method returns the first argument it receives.
+	*
+	* @static
+	* @since 0.1.0
+	* @memberOf _
+	* @category Util
+	* @param {*} value Any value.
+	* @returns {*} Returns `value`.
+	* @example
+	*
+	* var object = { 'a': 1 };
+	*
+	* console.log(_.identity(object) === object);
+	* // => true
+	*/
+	function identity(value) {
+		return value;
+	}
+	module.exports = identity;
+}));
+//#endregion
+export default require_identity();
+export { require_identity };

package/_internal/node_modules/lodash/isArguments.js

@@ -0,0 +1,21 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_isObjectLike } from "./isObjectLike.js";
+import { require__baseIsArguments } from "./_baseIsArguments.js";
+//#region ../../node_modules/lodash/isArguments.js
+var require_isArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsArguments = require__baseIsArguments(), isObjectLike = require_isObjectLike();
+	/** Used for built-in method references. */
+	var objectProto = Object.prototype;
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = objectProto.hasOwnProperty;
+	/** Built-in value references. */
+	var propertyIsEnumerable = objectProto.propertyIsEnumerable;
+	module.exports = baseIsArguments(function() {
+		return arguments;
+	}()) ? baseIsArguments : function(value) {
+		return isObjectLike(value) && hasOwnProperty.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+	};
+}));
+//#endregion
+export default require_isArguments();
+export { require_isArguments };

package/_internal/node_modules/lodash/isArray.js

@@ -0,0 +1,8 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/isArray.js
+var require_isArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = Array.isArray;
+}));
+//#endregion
+export default require_isArray();
+export { require_isArray };

package/_internal/node_modules/lodash/isArrayLike.js

@@ -0,0 +1,39 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_isFunction } from "./isFunction.js";
+import { require_isLength } from "./isLength.js";
+//#region ../../node_modules/lodash/isArrayLike.js
+var require_isArrayLike = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isFunction = require_isFunction(), isLength = require_isLength();
+	/**
+	* Checks if `value` is array-like. A value is considered array-like if it's
+	* not a function and has a `value.length` that's an integer greater than or
+	* equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+	* @example
+	*
+	* _.isArrayLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isArrayLike(document.body.children);
+	* // => true
+	*
+	* _.isArrayLike('abc');
+	* // => true
+	*
+	* _.isArrayLike(_.noop);
+	* // => false
+	*/
+	function isArrayLike(value) {
+		return value != null && isLength(value.length) && !isFunction(value);
+	}
+	module.exports = isArrayLike;
+}));
+//#endregion
+export default require_isArrayLike();
+export { require_isArrayLike };

package/_internal/node_modules/lodash/isBuffer.js

@@ -0,0 +1,17 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__root } from "./_root.js";
+import { require_stubFalse } from "./stubFalse.js";
+//#region ../../node_modules/lodash/isBuffer.js
+var require_isBuffer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var root = require__root(), stubFalse = require_stubFalse();
+	/** Detect free variable `exports`. */
+	var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+	/** Detect free variable `module`. */
+	var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+	/** Built-in value references. */
+	var Buffer = freeModule && freeModule.exports === freeExports ? root.Buffer : void 0;
+	module.exports = (Buffer ? Buffer.isBuffer : void 0) || stubFalse;
+}));
+//#endregion
+export default require_isBuffer();
+export { require_isBuffer };

package/_internal/node_modules/lodash/isEmpty.js

@@ -0,0 +1,63 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__isPrototype } from "./_isPrototype.js";
+import { require__baseKeys } from "./_baseKeys.js";
+import { require__getTag } from "./_getTag.js";
+import { require_isArguments } from "./isArguments.js";
+import { require_isArray } from "./isArray.js";
+import { require_isArrayLike } from "./isArrayLike.js";
+import { require_isBuffer } from "./isBuffer.js";
+import { require_isTypedArray } from "./isTypedArray.js";
+//#region ../../node_modules/lodash/isEmpty.js
+var require_isEmpty = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseKeys = require__baseKeys(), getTag = require__getTag(), isArguments = require_isArguments(), isArray = require_isArray(), isArrayLike = require_isArrayLike(), isBuffer = require_isBuffer(), isPrototype = require__isPrototype(), isTypedArray = require_isTypedArray();
+	/** `Object#toString` result references. */
+	var mapTag = "[object Map]", setTag = "[object Set]";
+	/** Used to check objects for own properties. */
+	var hasOwnProperty = Object.prototype.hasOwnProperty;
+	/**
+	* Checks if `value` is an empty object, collection, map, or set.
+	*
+	* Objects are considered empty if they have no own enumerable string keyed
+	* properties.
+	*
+	* Array-like values such as `arguments` objects, arrays, buffers, strings, or
+	* jQuery-like collections are considered empty if they have a `length` of `0`.
+	* Similarly, maps and sets are considered empty if they have a `size` of `0`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is empty, else `false`.
+	* @example
+	*
+	* _.isEmpty(null);
+	* // => true
+	*
+	* _.isEmpty(true);
+	* // => true
+	*
+	* _.isEmpty(1);
+	* // => true
+	*
+	* _.isEmpty([1, 2, 3]);
+	* // => false
+	*
+	* _.isEmpty({ 'a': 1 });
+	* // => false
+	*/
+	function isEmpty(value) {
+		if (value == null) return true;
+		if (isArrayLike(value) && (isArray(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) return !value.length;
+		var tag = getTag(value);
+		if (tag == mapTag || tag == setTag) return !value.size;
+		if (isPrototype(value)) return !baseKeys(value).length;
+		for (var key in value) if (hasOwnProperty.call(value, key)) return false;
+		return true;
+	}
+	module.exports = isEmpty;
+}));
+//#endregion
+export default require_isEmpty();
+export { require_isEmpty };

package/_internal/node_modules/lodash/isFunction.js

@@ -0,0 +1,35 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseGetTag } from "./_baseGetTag.js";
+import { require_isObject } from "./isObject.js";
+//#region ../../node_modules/lodash/isFunction.js
+var require_isFunction = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag(), isObject = require_isObject();
+	/** `Object#toString` result references. */
+	var asyncTag = "[object AsyncFunction]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+	/**
+	* Checks if `value` is classified as a `Function` object.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a function, else `false`.
+	* @example
+	*
+	* _.isFunction(_);
+	* // => true
+	*
+	* _.isFunction(/abc/);
+	* // => false
+	*/
+	function isFunction(value) {
+		if (!isObject(value)) return false;
+		var tag = baseGetTag(value);
+		return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+	}
+	module.exports = isFunction;
+}));
+//#endregion
+export default require_isFunction();
+export { require_isFunction };

package/_internal/node_modules/lodash/isInteger.js

@@ -0,0 +1,39 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require_toInteger } from "./toInteger.js";
+//#region ../../node_modules/lodash/isInteger.js
+var require_isInteger = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toInteger = require_toInteger();
+	/**
+	* Checks if `value` is an integer.
+	*
+	* **Note:** This method is based on
+	* [`Number.isInteger`](https://mdn.io/Number/isInteger).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is an integer, else `false`.
+	* @example
+	*
+	* _.isInteger(3);
+	* // => true
+	*
+	* _.isInteger(Number.MIN_VALUE);
+	* // => false
+	*
+	* _.isInteger(Infinity);
+	* // => false
+	*
+	* _.isInteger('3');
+	* // => false
+	*/
+	function isInteger(value) {
+		return typeof value == "number" && value == toInteger(value);
+	}
+	module.exports = isInteger;
+}));
+//#endregion
+export default require_isInteger();
+export { require_isInteger };

package/_internal/node_modules/lodash/isLength.js

@@ -0,0 +1,39 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/isLength.js
+var require_isLength = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/** Used as references for various `Number` constants. */
+	var MAX_SAFE_INTEGER = 9007199254740991;
+	/**
+	* Checks if `value` is a valid array-like length.
+	*
+	* **Note:** This method is loosely based on
+	* [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+	* @example
+	*
+	* _.isLength(3);
+	* // => true
+	*
+	* _.isLength(Number.MIN_VALUE);
+	* // => false
+	*
+	* _.isLength(Infinity);
+	* // => false
+	*
+	* _.isLength('3');
+	* // => false
+	*/
+	function isLength(value) {
+		return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+	}
+	module.exports = isLength;
+}));
+//#endregion
+export default require_isLength();
+export { require_isLength };

package/_internal/node_modules/lodash/isObject.js

@@ -0,0 +1,37 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/isObject.js
+var require_isObject = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* 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");
+	}
+	module.exports = isObject;
+}));
+//#endregion
+export default require_isObject();
+export { require_isObject };

package/_internal/node_modules/lodash/isObjectLike.js

@@ -0,0 +1,35 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* 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";
+	}
+	module.exports = isObjectLike;
+}));
+//#endregion
+export default require_isObjectLike();
+export { require_isObjectLike };

package/_internal/node_modules/lodash/isSymbol.js

@@ -0,0 +1,33 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseGetTag } from "./_baseGetTag.js";
+import { require_isObjectLike } from "./isObjectLike.js";
+//#region ../../node_modules/lodash/isSymbol.js
+var require_isSymbol = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseGetTag = require__baseGetTag(), isObjectLike = require_isObjectLike();
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+	}
+	module.exports = isSymbol;
+}));
+//#endregion
+export default require_isSymbol();
+export { require_isSymbol };

package/_internal/node_modules/lodash/isTypedArray.js

@@ -0,0 +1,13 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+import { require__baseUnary } from "./_baseUnary.js";
+import { require__baseIsTypedArray } from "./_baseIsTypedArray.js";
+import { require__nodeUtil } from "./_nodeUtil.js";
+//#region ../../node_modules/lodash/isTypedArray.js
+var require_isTypedArray = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var baseIsTypedArray = require__baseIsTypedArray(), baseUnary = require__baseUnary(), nodeUtil = require__nodeUtil();
+	var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+	module.exports = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+}));
+//#endregion
+export default require_isTypedArray();
+export { require_isTypedArray };

package/_internal/node_modules/lodash/last.js

@@ -0,0 +1,26 @@
+import { __commonJSMin } from "../../_virtual/_rolldown/runtime.js";
+//#region ../../node_modules/lodash/last.js
+var require_last = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* Gets the last element of `array`.
+	*
+	* @static
+	* @memberOf _
+	* @since 0.1.0
+	* @category Array
+	* @param {Array} array The array to query.
+	* @returns {*} Returns the last element of `array`.
+	* @example
+	*
+	* _.last([1, 2, 3]);
+	* // => 3
+	*/
+	function last(array) {
+		var length = array == null ? 0 : array.length;
+		return length ? array[length - 1] : void 0;
+	}
+	module.exports = last;
+}));
+//#endregion
+export default require_last();
+export { require_last };