umwd-components 0.1.757 → 0.1.758

package/dist/esm/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as isObjectLike } from '../../../../../_virtual/isObjectLike.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function isObjectLike(value) {
+	    return typeof value === 'object' && value !== null;
+	}
+
+	exports.isObjectLike = isObjectLike; 
+} (isObjectLike));

package/dist/esm/node_modules/es-toolkit/dist/compat/predicate/isPlainObject.js

@@ -0,0 +1,42 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as isPlainObject } from '../../../../../_virtual/isPlainObject.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function isPlainObject(object) {
+	    if (typeof object !== 'object') {
+	        return false;
+	    }
+	    if (object == null) {
+	        return false;
+	    }
+	    if (Object.getPrototypeOf(object) === null) {
+	        return true;
+	    }
+	    if (Object.prototype.toString.call(object) !== '[object Object]') {
+	        const tag = object[Symbol.toStringTag];
+	        if (tag == null) {
+	            return false;
+	        }
+	        const isTagReadonly = !Object.getOwnPropertyDescriptor(object, Symbol.toStringTag)?.writable;
+	        if (isTagReadonly) {
+	            return false;
+	        }
+	        return object.toString() === `[object ${tag}]`;
+	    }
+	    let proto = object;
+	    while (Object.getPrototypeOf(proto) !== null) {
+	        proto = Object.getPrototypeOf(proto);
+	    }
+	    return Object.getPrototypeOf(object) === proto;
+	}
+
+	exports.isPlainObject = isPlainObject; 
+} (isPlainObject));

package/dist/esm/node_modules/es-toolkit/dist/compat/predicate/isSymbol.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as isSymbol } from '../../../../../_virtual/isSymbol.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function isSymbol(value) {
+	    return typeof value === 'symbol' || value instanceof Symbol;
+	}
+
+	exports.isSymbol = isSymbol; 
+} (isSymbol));

package/dist/esm/node_modules/es-toolkit/dist/compat/predicate/matches.js

@@ -0,0 +1,27 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as matches } from '../../../../../_virtual/matches.js';
+import { __require as requireIsMatch } from './isMatch.js';
+import '../../object/cloneDeep.js';
+import { __exports as cloneDeep } from '../../../../../_virtual/cloneDeep2.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const isMatch = requireIsMatch();
+	const cloneDeep$1 = cloneDeep;
+
+	function matches(source) {
+	    source = cloneDeep$1.cloneDeep(source);
+	    return (target) => {
+	        return isMatch.isMatch(target, source);
+	    };
+	}
+
+	exports.matches = matches; 
+} (matches));

package/dist/esm/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.js

@@ -0,0 +1,55 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as matchesProperty } from '../../../../../_virtual/matchesProperty.js';
+import { __require as requireIsMatch } from './isMatch.js';
+import '../_internal/toKey.js';
+import '../object/cloneDeep.js';
+import '../object/get.js';
+import '../object/has.js';
+import { __exports as toKey } from '../../../../../_virtual/toKey.js';
+import { __exports as cloneDeep } from '../../../../../_virtual/cloneDeep.js';
+import { __exports as get } from '../../../../../_virtual/get.js';
+import { __exports as has } from '../../../../../_virtual/has.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const isMatch = requireIsMatch();
+	const toKey$1 = toKey;
+	const cloneDeep$1 = cloneDeep;
+	const get$1 = get;
+	const has$1 = has;
+
+	function matchesProperty(property, source) {
+	    switch (typeof property) {
+	        case 'object': {
+	            if (Object.is(property?.valueOf(), -0)) {
+	                property = '-0';
+	            }
+	            break;
+	        }
+	        case 'number': {
+	            property = toKey$1.toKey(property);
+	            break;
+	        }
+	    }
+	    source = cloneDeep$1.cloneDeep(source);
+	    return function (target) {
+	        const result = get$1.get(target, property);
+	        if (result === undefined) {
+	            return has$1.has(target, property);
+	        }
+	        if (source === undefined) {
+	            return result === undefined;
+	        }
+	        return isMatch.isMatch(result, source);
+	    };
+	}
+
+	exports.matchesProperty = matchesProperty; 
+} (matchesProperty));

package/dist/esm/node_modules/es-toolkit/dist/compat/util/eq.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as eq } from '../../../../../_virtual/eq.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function eq(value, other) {
+	    return value === other || (Number.isNaN(value) && Number.isNaN(other));
+	}
+
+	exports.eq = eq; 
+} (eq));

package/dist/esm/node_modules/es-toolkit/dist/compat/util/iteratee.js

@@ -0,0 +1,49 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as iteratee } from '../../../../../_virtual/iteratee.js';
+import '../../function/identity.js';
+import '../object/property.js';
+import '../predicate/matches.js';
+import '../predicate/matchesProperty.js';
+import { __exports as identity } from '../../../../../_virtual/identity.js';
+import { __exports as property } from '../../../../../_virtual/property.js';
+import { __exports as matchesProperty } from '../../../../../_virtual/matchesProperty.js';
+import { __exports as matches } from '../../../../../_virtual/matches.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const identity$1 = identity;
+	const property$1 = property;
+	const matches$1 = matches;
+	const matchesProperty$1 = matchesProperty;
+
+	function iteratee(value) {
+	    if (value == null) {
+	        return identity$1.identity;
+	    }
+	    switch (typeof value) {
+	        case 'function': {
+	            return value;
+	        }
+	        case 'object': {
+	            if (Array.isArray(value) && value.length === 2) {
+	                return matchesProperty$1.matchesProperty(value[0], value[1]);
+	            }
+	            return matches$1.matches(value);
+	        }
+	        case 'string':
+	        case 'symbol':
+	        case 'number': {
+	            return property$1.property(value);
+	        }
+	    }
+	}
+
+	exports.iteratee = iteratee; 
+} (iteratee));

package/dist/esm/node_modules/es-toolkit/dist/compat/util/toFinite.js

@@ -0,0 +1,30 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as toFinite } from '../../../../../_virtual/toFinite.js';
+import './toNumber.js';
+import { __exports as toNumber } from '../../../../../_virtual/toNumber.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const toNumber$1 = toNumber;
+
+	function toFinite(value) {
+	    if (!value) {
+	        return value === 0 ? value : 0;
+	    }
+	    value = toNumber$1.toNumber(value);
+	    if (value === Infinity || value === -Infinity) {
+	        const sign = value < 0 ? -1 : 1;
+	        return sign * Number.MAX_VALUE;
+	    }
+	    return value === value ? value : 0;
+	}
+
+	exports.toFinite = toFinite; 
+} (toFinite));

package/dist/esm/node_modules/es-toolkit/dist/compat/util/toNumber.js

@@ -0,0 +1,25 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as toNumber } from '../../../../../_virtual/toNumber.js';
+import '../predicate/isSymbol.js';
+import { __exports as isSymbol } from '../../../../../_virtual/isSymbol.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const isSymbol$1 = isSymbol;
+
+	function toNumber(value) {
+	    if (isSymbol$1.isSymbol(value)) {
+	        return NaN;
+	    }
+	    return Number(value);
+	}
+
+	exports.toNumber = toNumber; 
+} (toNumber));

package/dist/esm/node_modules/es-toolkit/dist/compat/util/toPath.js

@@ -0,0 +1,81 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as toPath } from '../../../../../_virtual/toPath.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function toPath(deepKey) {
+	    const result = [];
+	    const length = deepKey.length;
+	    if (length === 0) {
+	        return result;
+	    }
+	    let index = 0;
+	    let key = '';
+	    let quoteChar = '';
+	    let bracket = false;
+	    if (deepKey.charCodeAt(0) === 46) {
+	        result.push('');
+	        index++;
+	    }
+	    while (index < length) {
+	        const char = deepKey[index];
+	        if (quoteChar) {
+	            if (char === '\\' && index + 1 < length) {
+	                index++;
+	                key += deepKey[index];
+	            }
+	            else if (char === quoteChar) {
+	                quoteChar = '';
+	            }
+	            else {
+	                key += char;
+	            }
+	        }
+	        else if (bracket) {
+	            if (char === '"' || char === "'") {
+	                quoteChar = char;
+	            }
+	            else if (char === ']') {
+	                bracket = false;
+	                result.push(key);
+	                key = '';
+	            }
+	            else {
+	                key += char;
+	            }
+	        }
+	        else {
+	            if (char === '[') {
+	                bracket = true;
+	                if (key) {
+	                    result.push(key);
+	                    key = '';
+	                }
+	            }
+	            else if (char === '.') {
+	                if (key) {
+	                    result.push(key);
+	                    key = '';
+	                }
+	            }
+	            else {
+	                key += char;
+	            }
+	        }
+	        index++;
+	    }
+	    if (key) {
+	        result.push(key);
+	    }
+	    return result;
+	}
+
+	exports.toPath = toPath; 
+} (toPath));

package/dist/esm/node_modules/es-toolkit/dist/function/identity.js

@@ -0,0 +1,18 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as identity } from '../../../../_virtual/identity.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function identity(x) {
+	    return x;
+	}
+
+	exports.identity = identity; 
+} (identity));

package/dist/esm/node_modules/es-toolkit/dist/function/noop.js

@@ -0,0 +1,16 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as noop } from '../../../../_virtual/noop.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	function noop() { }
+
+	exports.noop = noop; 
+} (noop));

package/dist/esm/node_modules/es-toolkit/dist/object/cloneDeep.js

@@ -0,0 +1,22 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as cloneDeep } from '../../../../_virtual/cloneDeep2.js';
+import './cloneDeepWith.js';
+import { __exports as cloneDeepWith } from '../../../../_virtual/cloneDeepWith.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const cloneDeepWith$1 = cloneDeepWith;
+
+	function cloneDeep(obj) {
+	    return cloneDeepWith$1.cloneDeepWithImpl(obj, undefined, obj, new Map(), undefined);
+	}
+
+	exports.cloneDeep = cloneDeep; 
+} (cloneDeep));

package/dist/esm/node_modules/es-toolkit/dist/object/cloneDeepWith.js

@@ -0,0 +1,179 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as cloneDeepWith } from '../../../../_virtual/cloneDeepWith.js';
+import '../compat/_internal/getSymbols.js';
+import '../compat/_internal/getTag.js';
+import '../compat/_internal/tags.js';
+import '../predicate/isPrimitive.js';
+import '../predicate/isTypedArray.js';
+import { __exports as isPrimitive } from '../../../../_virtual/isPrimitive.js';
+import { __exports as isTypedArray } from '../../../../_virtual/isTypedArray.js';
+import { __exports as getSymbols } from '../../../../_virtual/getSymbols.js';
+import { __exports as getTag } from '../../../../_virtual/getTag.js';
+import { __exports as tags } from '../../../../_virtual/tags.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const getSymbols$1 = getSymbols;
+	const getTag$1 = getTag;
+	const tags$1 = tags;
+	const isPrimitive$1 = isPrimitive;
+	const isTypedArray$1 = isTypedArray;
+
+	function cloneDeepWith(obj, cloneValue) {
+	    return cloneDeepWithImpl(obj, undefined, obj, new Map(), cloneValue);
+	}
+	function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = new Map(), cloneValue = undefined) {
+	    const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+	    if (cloned != null) {
+	        return cloned;
+	    }
+	    if (isPrimitive$1.isPrimitive(valueToClone)) {
+	        return valueToClone;
+	    }
+	    if (stack.has(valueToClone)) {
+	        return stack.get(valueToClone);
+	    }
+	    if (Array.isArray(valueToClone)) {
+	        const result = new Array(valueToClone.length);
+	        stack.set(valueToClone, result);
+	        for (let i = 0; i < valueToClone.length; i++) {
+	            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+	        }
+	        if (Object.hasOwn(valueToClone, 'index')) {
+	            result.index = valueToClone.index;
+	        }
+	        if (Object.hasOwn(valueToClone, 'input')) {
+	            result.input = valueToClone.input;
+	        }
+	        return result;
+	    }
+	    if (valueToClone instanceof Date) {
+	        return new Date(valueToClone.getTime());
+	    }
+	    if (valueToClone instanceof RegExp) {
+	        const result = new RegExp(valueToClone.source, valueToClone.flags);
+	        result.lastIndex = valueToClone.lastIndex;
+	        return result;
+	    }
+	    if (valueToClone instanceof Map) {
+	        const result = new Map();
+	        stack.set(valueToClone, result);
+	        for (const [key, value] of valueToClone) {
+	            result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+	        }
+	        return result;
+	    }
+	    if (valueToClone instanceof Set) {
+	        const result = new Set();
+	        stack.set(valueToClone, result);
+	        for (const value of valueToClone) {
+	            result.add(cloneDeepWithImpl(value, undefined, objectToClone, stack, cloneValue));
+	        }
+	        return result;
+	    }
+	    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(valueToClone)) {
+	        return valueToClone.subarray();
+	    }
+	    if (isTypedArray$1.isTypedArray(valueToClone)) {
+	        const result = new (Object.getPrototypeOf(valueToClone).constructor)(valueToClone.length);
+	        stack.set(valueToClone, result);
+	        for (let i = 0; i < valueToClone.length; i++) {
+	            result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+	        }
+	        return result;
+	    }
+	    if (valueToClone instanceof ArrayBuffer ||
+	        (typeof SharedArrayBuffer !== 'undefined' && valueToClone instanceof SharedArrayBuffer)) {
+	        return valueToClone.slice(0);
+	    }
+	    if (valueToClone instanceof DataView) {
+	        const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+	        stack.set(valueToClone, result);
+	        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+	        return result;
+	    }
+	    if (typeof File !== 'undefined' && valueToClone instanceof File) {
+	        const result = new File([valueToClone], valueToClone.name, {
+	            type: valueToClone.type,
+	        });
+	        stack.set(valueToClone, result);
+	        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+	        return result;
+	    }
+	    if (valueToClone instanceof Blob) {
+	        const result = new Blob([valueToClone], { type: valueToClone.type });
+	        stack.set(valueToClone, result);
+	        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+	        return result;
+	    }
+	    if (valueToClone instanceof Error) {
+	        const result = new valueToClone.constructor();
+	        stack.set(valueToClone, result);
+	        result.message = valueToClone.message;
+	        result.name = valueToClone.name;
+	        result.stack = valueToClone.stack;
+	        result.cause = valueToClone.cause;
+	        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+	        return result;
+	    }
+	    if (typeof valueToClone === 'object' && isCloneableObject(valueToClone)) {
+	        const result = Object.create(Object.getPrototypeOf(valueToClone));
+	        stack.set(valueToClone, result);
+	        copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+	        return result;
+	    }
+	    return valueToClone;
+	}
+	function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+	    const keys = [...Object.keys(source), ...getSymbols$1.getSymbols(source)];
+	    for (let i = 0; i < keys.length; i++) {
+	        const key = keys[i];
+	        const descriptor = Object.getOwnPropertyDescriptor(target, key);
+	        if (descriptor == null || descriptor.writable) {
+	            target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+	        }
+	    }
+	}
+	function isCloneableObject(object) {
+	    switch (getTag$1.getTag(object)) {
+	        case tags$1.argumentsTag:
+	        case tags$1.arrayTag:
+	        case tags$1.arrayBufferTag:
+	        case tags$1.dataViewTag:
+	        case tags$1.booleanTag:
+	        case tags$1.dateTag:
+	        case tags$1.float32ArrayTag:
+	        case tags$1.float64ArrayTag:
+	        case tags$1.int8ArrayTag:
+	        case tags$1.int16ArrayTag:
+	        case tags$1.int32ArrayTag:
+	        case tags$1.mapTag:
+	        case tags$1.numberTag:
+	        case tags$1.objectTag:
+	        case tags$1.regexpTag:
+	        case tags$1.setTag:
+	        case tags$1.stringTag:
+	        case tags$1.symbolTag:
+	        case tags$1.uint8ArrayTag:
+	        case tags$1.uint8ClampedArrayTag:
+	        case tags$1.uint16ArrayTag:
+	        case tags$1.uint32ArrayTag: {
+	            return true;
+	        }
+	        default: {
+	            return false;
+	        }
+	    }
+	}
+
+	exports.cloneDeepWith = cloneDeepWith;
+	exports.cloneDeepWithImpl = cloneDeepWithImpl;
+	exports.copyProperties = copyProperties; 
+} (cloneDeepWith));

package/dist/esm/node_modules/es-toolkit/dist/predicate/isEqual.js

@@ -0,0 +1,25 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { __exports as isEqual } from '../../../../_virtual/isEqual.js';
+import './isEqualWith.js';
+import '../function/noop.js';
+import { __exports as isEqualWith } from '../../../../_virtual/isEqualWith.js';
+import { __exports as noop } from '../../../../_virtual/noop.js';
+
+(function (exports) {
+
+	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+	const isEqualWith$1 = isEqualWith;
+	const noop$1 = noop;
+
+	function isEqual(a, b) {
+	    return isEqualWith$1.isEqualWith(a, b, noop$1.noop);
+	}
+
+	exports.isEqual = isEqual; 
+} (isEqual));