umwd-components 0.1.759 → 0.1.760

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

@@ -1,208 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as isEqualWith } from '../../../../_virtual/isEqualWith.js';
-import './isPlainObject.js';
-import '../compat/_internal/getSymbols.js';
-import '../compat/_internal/getTag.js';
-import '../compat/_internal/tags.js';
-import '../compat/util/eq.js';
-import { __exports as getTag } from '../../../../_virtual/getTag.js';
-import { __exports as tags } from '../../../../_virtual/tags.js';
-import { __exports as eq } from '../../../../_virtual/eq.js';
-import { __exports as isPlainObject } from '../../../../_virtual/isPlainObject2.js';
-import { __exports as getSymbols } from '../../../../_virtual/getSymbols.js';
-
-(function (exports) {
-
-	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-	const isPlainObject$1 = isPlainObject;
-	const getSymbols$1 = getSymbols;
-	const getTag$1 = getTag;
-	const tags$1 = tags;
-	const eq$1 = eq;
-
-	function isEqualWith(a, b, areValuesEqual) {
-	    return isEqualWithImpl(a, b, undefined, undefined, undefined, undefined, areValuesEqual);
-	}
-	function isEqualWithImpl(a, b, property, aParent, bParent, stack, areValuesEqual) {
-	    const result = areValuesEqual(a, b, property, aParent, bParent, stack);
-	    if (result !== undefined) {
-	        return result;
-	    }
-	    if (typeof a === typeof b) {
-	        switch (typeof a) {
-	            case 'bigint':
-	            case 'string':
-	            case 'boolean':
-	            case 'symbol':
-	            case 'undefined': {
-	                return a === b;
-	            }
-	            case 'number': {
-	                return a === b || Object.is(a, b);
-	            }
-	            case 'function': {
-	                return a === b;
-	            }
-	            case 'object': {
-	                return areObjectsEqual(a, b, stack, areValuesEqual);
-	            }
-	        }
-	    }
-	    return areObjectsEqual(a, b, stack, areValuesEqual);
-	}
-	function areObjectsEqual(a, b, stack, areValuesEqual) {
-	    if (Object.is(a, b)) {
-	        return true;
-	    }
-	    let aTag = getTag$1.getTag(a);
-	    let bTag = getTag$1.getTag(b);
-	    if (aTag === tags$1.argumentsTag) {
-	        aTag = tags$1.objectTag;
-	    }
-	    if (bTag === tags$1.argumentsTag) {
-	        bTag = tags$1.objectTag;
-	    }
-	    if (aTag !== bTag) {
-	        return false;
-	    }
-	    switch (aTag) {
-	        case tags$1.stringTag:
-	            return a.toString() === b.toString();
-	        case tags$1.numberTag: {
-	            const x = a.valueOf();
-	            const y = b.valueOf();
-	            return eq$1.eq(x, y);
-	        }
-	        case tags$1.booleanTag:
-	        case tags$1.dateTag:
-	        case tags$1.symbolTag:
-	            return Object.is(a.valueOf(), b.valueOf());
-	        case tags$1.regexpTag: {
-	            return a.source === b.source && a.flags === b.flags;
-	        }
-	        case tags$1.functionTag: {
-	            return a === b;
-	        }
-	    }
-	    stack = stack ?? new Map();
-	    const aStack = stack.get(a);
-	    const bStack = stack.get(b);
-	    if (aStack != null && bStack != null) {
-	        return aStack === b;
-	    }
-	    stack.set(a, b);
-	    stack.set(b, a);
-	    try {
-	        switch (aTag) {
-	            case tags$1.mapTag: {
-	                if (a.size !== b.size) {
-	                    return false;
-	                }
-	                for (const [key, value] of a.entries()) {
-	                    if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) {
-	                        return false;
-	                    }
-	                }
-	                return true;
-	            }
-	            case tags$1.setTag: {
-	                if (a.size !== b.size) {
-	                    return false;
-	                }
-	                const aValues = Array.from(a.values());
-	                const bValues = Array.from(b.values());
-	                for (let i = 0; i < aValues.length; i++) {
-	                    const aValue = aValues[i];
-	                    const index = bValues.findIndex(bValue => {
-	                        return isEqualWithImpl(aValue, bValue, undefined, a, b, stack, areValuesEqual);
-	                    });
-	                    if (index === -1) {
-	                        return false;
-	                    }
-	                    bValues.splice(index, 1);
-	                }
-	                return true;
-	            }
-	            case tags$1.arrayTag:
-	            case tags$1.uint8ArrayTag:
-	            case tags$1.uint8ClampedArrayTag:
-	            case tags$1.uint16ArrayTag:
-	            case tags$1.uint32ArrayTag:
-	            case tags$1.bigUint64ArrayTag:
-	            case tags$1.int8ArrayTag:
-	            case tags$1.int16ArrayTag:
-	            case tags$1.int32ArrayTag:
-	            case tags$1.bigInt64ArrayTag:
-	            case tags$1.float32ArrayTag:
-	            case tags$1.float64ArrayTag: {
-	                if (typeof Buffer !== 'undefined' && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
-	                    return false;
-	                }
-	                if (a.length !== b.length) {
-	                    return false;
-	                }
-	                for (let i = 0; i < a.length; i++) {
-	                    if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) {
-	                        return false;
-	                    }
-	                }
-	                return true;
-	            }
-	            case tags$1.arrayBufferTag: {
-	                if (a.byteLength !== b.byteLength) {
-	                    return false;
-	                }
-	                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-	            }
-	            case tags$1.dataViewTag: {
-	                if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
-	                    return false;
-	                }
-	                return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
-	            }
-	            case tags$1.errorTag: {
-	                return a.name === b.name && a.message === b.message;
-	            }
-	            case tags$1.objectTag: {
-	                const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) ||
-	                    (isPlainObject$1.isPlainObject(a) && isPlainObject$1.isPlainObject(b));
-	                if (!areEqualInstances) {
-	                    return false;
-	                }
-	                const aKeys = [...Object.keys(a), ...getSymbols$1.getSymbols(a)];
-	                const bKeys = [...Object.keys(b), ...getSymbols$1.getSymbols(b)];
-	                if (aKeys.length !== bKeys.length) {
-	                    return false;
-	                }
-	                for (let i = 0; i < aKeys.length; i++) {
-	                    const propKey = aKeys[i];
-	                    const aProp = a[propKey];
-	                    if (!Object.hasOwn(b, propKey)) {
-	                        return false;
-	                    }
-	                    const bProp = b[propKey];
-	                    if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) {
-	                        return false;
-	                    }
-	                }
-	                return true;
-	            }
-	            default: {
-	                return false;
-	            }
-	        }
-	    }
-	    finally {
-	        stack.delete(a);
-	        stack.delete(b);
-	    }
-	}
-
-	exports.isEqualWith = isEqualWith; 
-} (isEqualWith));

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

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

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

@@ -1,28 +0,0 @@
-/*
- * UMWD-Components
- * @copyright Jelle Paulus
- * @license MIT
- */
-  
-import { __exports as isPlainObject } from '../../../../_virtual/isPlainObject2.js';
-
-(function (exports) {
-
-	Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-	function isPlainObject(value) {
-	    if (!value || typeof value !== 'object') {
-	        return false;
-	    }
-	    const proto = Object.getPrototypeOf(value);
-	    const hasObjectPrototype = proto === null ||
-	        proto === Object.prototype ||
-	        Object.getPrototypeOf(proto) === null;
-	    if (!hasObjectPrototype) {
-	        return false;
-	    }
-	    return Object.prototype.toString.call(value) === '[object Object]';
-	}
-
-	exports.isPlainObject = isPlainObject; 
-} (isPlainObject));

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

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

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

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