ivt 0.7.2 → 0.7.4

package/dist/chunks/{bundle-mjs-Lvc-Dri9.mjs → bundle-mjs-B1dpl-bk.mjs}

@@ -1,108 +1,175 @@
+/**
+ * Concatenates two arrays faster than the array spread operator.
+ */ const concatArrays = (array1, array2)=>{
+    // Pre-allocate for better V8 optimization
+    const combinedArray = new Array(array1.length + array2.length);
+    for(let i = 0; i < array1.length; i++){
+        combinedArray[i] = array1[i];
+    }
+    for(let i = 0; i < array2.length; i++){
+        combinedArray[array1.length + i] = array2[i];
+    }
+    return combinedArray;
+};
+// Factory function ensures consistent object shapes
+const createClassValidatorObject = (classGroupId, validator)=>({
+        classGroupId,
+        validator
+    });
+// Factory ensures consistent ClassPartObject shape
+const createClassPartObject = (nextPart = new Map(), validators = null, classGroupId)=>({
+        nextPart,
+        validators,
+        classGroupId
+    });
 const CLASS_PART_SEPARATOR = '-';
+const EMPTY_CONFLICTS = [];
+// I use two dots here because one dot is used as prefix for class groups in plugins
+const ARBITRARY_PROPERTY_PREFIX = 'arbitrary..';
 const createClassGroupUtils = (config)=>{
     const classMap = createClassMap(config);
     const { conflictingClassGroups, conflictingClassGroupModifiers } = config;
     const getClassGroupId = (className)=>{
-        const classParts = className.split(CLASS_PART_SEPARATOR);
-        // Classes like `-inset-1` produce an empty string as first classPart. We assume that classes for negative values are used correctly and remove it from classParts.
-        if (classParts[0] === '' && classParts.length !== 1) {
-            classParts.shift();
+        if (className.startsWith('[') && className.endsWith(']')) {
+            return getGroupIdForArbitraryProperty(className);
         }
-        return getGroupRecursive(classParts, classMap) || getGroupIdForArbitraryProperty(className);
+        const classParts = className.split(CLASS_PART_SEPARATOR);
+        // Classes like `-inset-1` produce an empty string as first classPart. We assume that classes for negative values are used correctly and skip it.
+        const startIndex = classParts[0] === '' && classParts.length > 1 ? 1 : 0;
+        return getGroupRecursive(classParts, startIndex, classMap);
     };
     const getConflictingClassGroupIds = (classGroupId, hasPostfixModifier)=>{
-        const conflicts = conflictingClassGroups[classGroupId] || [];
-        if (hasPostfixModifier && conflictingClassGroupModifiers[classGroupId]) {
-            return [
-                ...conflicts,
-                ...conflictingClassGroupModifiers[classGroupId]
-            ];
+        if (hasPostfixModifier) {
+            const modifierConflicts = conflictingClassGroupModifiers[classGroupId];
+            const baseConflicts = conflictingClassGroups[classGroupId];
+            if (modifierConflicts) {
+                if (baseConflicts) {
+                    // Merge base conflicts with modifier conflicts
+                    return concatArrays(baseConflicts, modifierConflicts);
+                }
+                // Only modifier conflicts
+                return modifierConflicts;
+            }
+            // Fall back to without postfix if no modifier conflicts
+            return baseConflicts || EMPTY_CONFLICTS;
         }
-        return conflicts;
+        return conflictingClassGroups[classGroupId] || EMPTY_CONFLICTS;
     };
     return {
         getClassGroupId,
         getConflictingClassGroupIds
     };
 };
-const getGroupRecursive = (classParts, classPartObject)=>{
-    if (classParts.length === 0) {
+const getGroupRecursive = (classParts, startIndex, classPartObject)=>{
+    const classPathsLength = classParts.length - startIndex;
+    if (classPathsLength === 0) {
         return classPartObject.classGroupId;
     }
-    const currentClassPart = classParts[0];
+    const currentClassPart = classParts[startIndex];
     const nextClassPartObject = classPartObject.nextPart.get(currentClassPart);
-    const classGroupFromNextClassPart = nextClassPartObject ? getGroupRecursive(classParts.slice(1), nextClassPartObject) : undefined;
-    if (classGroupFromNextClassPart) {
-        return classGroupFromNextClassPart;
+    if (nextClassPartObject) {
+        const result = getGroupRecursive(classParts, startIndex + 1, nextClassPartObject);
+        if (result) return result;
     }
-    if (classPartObject.validators.length === 0) {
+    const validators = classPartObject.validators;
+    if (validators === null) {
         return undefined;
     }
-    const classRest = classParts.join(CLASS_PART_SEPARATOR);
-    return classPartObject.validators.find(({ validator })=>validator(classRest))?.classGroupId;
-};
-const arbitraryPropertyRegex = /^\[(.+)\]$/;
-const getGroupIdForArbitraryProperty = (className)=>{
-    if (arbitraryPropertyRegex.test(className)) {
-        const arbitraryPropertyClassName = arbitraryPropertyRegex.exec(className)[1];
-        const property = arbitraryPropertyClassName?.substring(0, arbitraryPropertyClassName.indexOf(':'));
-        if (property) {
-            // I use two dots here because one dot is used as prefix for class groups in plugins
-            return 'arbitrary..' + property;
+    // Build classRest string efficiently by joining from startIndex onwards
+    const classRest = startIndex === 0 ? classParts.join(CLASS_PART_SEPARATOR) : classParts.slice(startIndex).join(CLASS_PART_SEPARATOR);
+    const validatorsLength = validators.length;
+    for(let i = 0; i < validatorsLength; i++){
+        const validatorObj = validators[i];
+        if (validatorObj.validator(classRest)) {
+            return validatorObj.classGroupId;
         }
     }
+    return undefined;
 };
+/**
+ * Get the class group ID for an arbitrary property.
+ *
+ * @param className - The class name to get the group ID for. Is expected to be string starting with `[` and ending with `]`.
+ */ const getGroupIdForArbitraryProperty = (className)=>className.slice(1, -1).indexOf(':') === -1 ? undefined : (()=>{
+        const content = className.slice(1, -1);
+        const colonIndex = content.indexOf(':');
+        const property = content.slice(0, colonIndex);
+        return property ? ARBITRARY_PROPERTY_PREFIX + property : undefined;
+    })();
 /**
  * Exported for testing only
  */ const createClassMap = (config)=>{
     const { theme, classGroups } = config;
-    const classMap = {
-        nextPart: new Map(),
-        validators: []
-    };
+    return processClassGroups(classGroups, theme);
+};
+// Split into separate functions to maintain monomorphic call sites
+const processClassGroups = (classGroups, theme)=>{
+    const classMap = createClassPartObject();
     for(const classGroupId in classGroups){
-        processClassesRecursively(classGroups[classGroupId], classMap, classGroupId, theme);
+        const group = classGroups[classGroupId];
+        processClassesRecursively(group, classMap, classGroupId, theme);
     }
     return classMap;
 };
 const processClassesRecursively = (classGroup, classPartObject, classGroupId, theme)=>{
-    classGroup.forEach((classDefinition)=>{
-        if (typeof classDefinition === 'string') {
-            const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
-            classPartObjectToEdit.classGroupId = classGroupId;
-            return;
-        }
-        if (typeof classDefinition === 'function') {
-            if (isThemeGetter(classDefinition)) {
-                processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
-                return;
-            }
-            classPartObject.validators.push({
-                validator: classDefinition,
-                classGroupId
-            });
-            return;
-        }
-        Object.entries(classDefinition).forEach(([key, classGroup])=>{
-            processClassesRecursively(classGroup, getPart(classPartObject, key), classGroupId, theme);
-        });
-    });
+    const len = classGroup.length;
+    for(let i = 0; i < len; i++){
+        const classDefinition = classGroup[i];
+        processClassDefinition(classDefinition, classPartObject, classGroupId, theme);
+    }
+};
+// Split into separate functions for each type to maintain monomorphic call sites
+const processClassDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{
+    if (typeof classDefinition === 'string') {
+        processStringDefinition(classDefinition, classPartObject, classGroupId);
+        return;
+    }
+    if (typeof classDefinition === 'function') {
+        processFunctionDefinition(classDefinition, classPartObject, classGroupId, theme);
+        return;
+    }
+    processObjectDefinition(classDefinition, classPartObject, classGroupId, theme);
+};
+const processStringDefinition = (classDefinition, classPartObject, classGroupId)=>{
+    const classPartObjectToEdit = classDefinition === '' ? classPartObject : getPart(classPartObject, classDefinition);
+    classPartObjectToEdit.classGroupId = classGroupId;
+};
+const processFunctionDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{
+    if (isThemeGetter(classDefinition)) {
+        processClassesRecursively(classDefinition(theme), classPartObject, classGroupId, theme);
+        return;
+    }
+    if (classPartObject.validators === null) {
+        classPartObject.validators = [];
+    }
+    classPartObject.validators.push(createClassValidatorObject(classGroupId, classDefinition));
+};
+const processObjectDefinition = (classDefinition, classPartObject, classGroupId, theme)=>{
+    const entries = Object.entries(classDefinition);
+    const len = entries.length;
+    for(let i = 0; i < len; i++){
+        const [key, value] = entries[i];
+        processClassesRecursively(value, getPart(classPartObject, key), classGroupId, theme);
+    }
 };
 const getPart = (classPartObject, path)=>{
-    let currentClassPartObject = classPartObject;
-    path.split(CLASS_PART_SEPARATOR).forEach((pathPart)=>{
-        if (!currentClassPartObject.nextPart.has(pathPart)) {
-            currentClassPartObject.nextPart.set(pathPart, {
-                nextPart: new Map(),
-                validators: []
-            });
+    let current = classPartObject;
+    const parts = path.split(CLASS_PART_SEPARATOR);
+    const len = parts.length;
+    for(let i = 0; i < len; i++){
+        const part = parts[i];
+        let next = current.nextPart.get(part);
+        if (!next) {
+            next = createClassPartObject();
+            current.nextPart.set(part, next);
         }
-        currentClassPartObject = currentClassPartObject.nextPart.get(pathPart);
-    });
-    return currentClassPartObject;
+        current = next;
+    }
+    return current;
 };
-const isThemeGetter = (func)=>func.isThemeGetter;
-// LRU cache inspired from hashlru (https://github.com/dominictarr/hashlru/blob/v1.0.4/index.js) but object replaced with Map to improve performance
+// Type guard maintains monomorphic check
+const isThemeGetter = (func)=>'isThemeGetter' in func && func.isThemeGetter === true;
+// LRU cache implementation using plain objects for simplicity
 const createLruCache = (maxCacheSize)=>{
     if (maxCacheSize < 1) {
         return {
@@ -111,31 +178,31 @@ const createLruCache = (maxCacheSize)=>{
         };
     }
     let cacheSize = 0;
-    let cache = new Map();
-    let previousCache = new Map();
+    let cache = Object.create(null);
+    let previousCache = Object.create(null);
     const update = (key, value)=>{
-        cache.set(key, value);
+        cache[key] = value;
         cacheSize++;
         if (cacheSize > maxCacheSize) {
             cacheSize = 0;
             previousCache = cache;
-            cache = new Map();
+            cache = Object.create(null);
         }
     };
     return {
         get (key) {
-            let value = cache.get(key);
+            let value = cache[key];
             if (value !== undefined) {
                 return value;
             }
-            if ((value = previousCache.get(key)) !== undefined) {
+            if ((value = previousCache[key]) !== undefined) {
                 update(key, value);
                 return value;
             }
         },
         set (key, value) {
-            if (cache.has(key)) {
-                cache.set(key, value);
+            if (key in cache) {
+                cache[key] = value;
             } else {
                 update(key, value);
             }
@@ -144,7 +211,15 @@ const createLruCache = (maxCacheSize)=>{
 };
 const IMPORTANT_MODIFIER = '!';
 const MODIFIER_SEPARATOR = ':';
-const MODIFIER_SEPARATOR_LENGTH = MODIFIER_SEPARATOR.length;
+const EMPTY_MODIFIERS = [];
+// Pre-allocated result object shape for consistency
+const createResultObject = (modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition, isExternal)=>({
+        modifiers,
+        hasImportantModifier,
+        baseClassName,
+        maybePostfixModifierPosition,
+        isExternal
+    });
 const createParseClassName = (config)=>{
     const { prefix, experimentalParseClassName } = config;
     /**
@@ -153,17 +228,19 @@ const createParseClassName = (config)=>{
    * Inspired by `splitAtTopLevelOnly` used in Tailwind CSS
    * @see https://github.com/tailwindlabs/tailwindcss/blob/v3.2.2/src/util/splitAtTopLevelOnly.js
    */ let parseClassName = (className)=>{
+        // Use simple array with push for better performance
         const modifiers = [];
         let bracketDepth = 0;
         let parenDepth = 0;
         let modifierStart = 0;
         let postfixModifierPosition;
-        for(let index = 0; index < className.length; index++){
-            let currentCharacter = className[index];
+        const len = className.length;
+        for(let index = 0; index < len; index++){
+            const currentCharacter = className[index];
             if (bracketDepth === 0 && parenDepth === 0) {
                 if (currentCharacter === MODIFIER_SEPARATOR) {
                     modifiers.push(className.slice(modifierStart, index));
-                    modifierStart = index + MODIFIER_SEPARATOR_LENGTH;
+                    modifierStart = index + 1;
                     continue;
                 }
                 if (currentCharacter === '/') {
@@ -171,37 +248,32 @@ const createParseClassName = (config)=>{
                     continue;
                 }
             }
-            if (currentCharacter === '[') {
-                bracketDepth++;
-            } else if (currentCharacter === ']') {
-                bracketDepth--;
-            } else if (currentCharacter === '(') {
-                parenDepth++;
-            } else if (currentCharacter === ')') {
-                parenDepth--;
-            }
+            if (currentCharacter === '[') bracketDepth++;
+            else if (currentCharacter === ']') bracketDepth--;
+            else if (currentCharacter === '(') parenDepth++;
+            else if (currentCharacter === ')') parenDepth--;
+        }
+        const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.slice(modifierStart);
+        // Inline important modifier check
+        let baseClassName = baseClassNameWithImportantModifier;
+        let hasImportantModifier = false;
+        if (baseClassNameWithImportantModifier.endsWith(IMPORTANT_MODIFIER)) {
+            baseClassName = baseClassNameWithImportantModifier.slice(0, -1);
+            hasImportantModifier = true;
+        } else if (/**
+     * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons.
+     * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864
+     */ baseClassNameWithImportantModifier.startsWith(IMPORTANT_MODIFIER)) {
+            baseClassName = baseClassNameWithImportantModifier.slice(1);
+            hasImportantModifier = true;
         }
-        const baseClassNameWithImportantModifier = modifiers.length === 0 ? className : className.substring(modifierStart);
-        const baseClassName = stripImportantModifier(baseClassNameWithImportantModifier);
-        const hasImportantModifier = baseClassName !== baseClassNameWithImportantModifier;
         const maybePostfixModifierPosition = postfixModifierPosition && postfixModifierPosition > modifierStart ? postfixModifierPosition - modifierStart : undefined;
-        return {
-            modifiers,
-            hasImportantModifier,
-            baseClassName,
-            maybePostfixModifierPosition
-        };
+        return createResultObject(modifiers, hasImportantModifier, baseClassName, maybePostfixModifierPosition);
     };
     if (prefix) {
         const fullPrefix = prefix + MODIFIER_SEPARATOR;
         const parseClassNameOriginal = parseClassName;
-        parseClassName = (className)=>className.startsWith(fullPrefix) ? parseClassNameOriginal(className.substring(fullPrefix.length)) : {
-                isExternal: true,
-                modifiers: [],
-                hasImportantModifier: false,
-                baseClassName: className,
-                maybePostfixModifierPosition: undefined
-            };
+        parseClassName = (className)=>className.startsWith(fullPrefix) ? parseClassNameOriginal(className.slice(fullPrefix.length)) : createResultObject(EMPTY_MODIFIERS, false, className, undefined, true);
     }
     if (experimentalParseClassName) {
         const parseClassNameOriginal = parseClassName;
@@ -212,46 +284,46 @@ const createParseClassName = (config)=>{
     }
     return parseClassName;
 };
-const stripImportantModifier = (baseClassName)=>{
-    if (baseClassName.endsWith(IMPORTANT_MODIFIER)) {
-        return baseClassName.substring(0, baseClassName.length - 1);
-    }
-    /**
-   * In Tailwind CSS v3 the important modifier was at the start of the base class name. This is still supported for legacy reasons.
-   * @see https://github.com/dcastil/tailwind-merge/issues/513#issuecomment-2614029864
-   */ if (baseClassName.startsWith(IMPORTANT_MODIFIER)) {
-        return baseClassName.substring(1);
-    }
-    return baseClassName;
-};
 /**
  * Sorts modifiers according to following schema:
  * - Predefined modifiers are sorted alphabetically
  * - When an arbitrary variant appears, it must be preserved which modifiers are before and after it
  */ const createSortModifiers = (config)=>{
-    const orderSensitiveModifiers = Object.fromEntries(config.orderSensitiveModifiers.map((modifier)=>[
-            modifier,
-            true
-        ]));
-    const sortModifiers = (modifiers)=>{
-        if (modifiers.length <= 1) {
-            return modifiers;
-        }
-        const sortedModifiers = [];
-        let unsortedModifiers = [];
-        modifiers.forEach((modifier)=>{
-            const isPositionSensitive = modifier[0] === '[' || orderSensitiveModifiers[modifier];
-            if (isPositionSensitive) {
-                sortedModifiers.push(...unsortedModifiers.sort(), modifier);
-                unsortedModifiers = [];
+    // Pre-compute weights for all known modifiers for O(1) comparison
+    const modifierWeights = new Map();
+    // Assign weights to sensitive modifiers (highest priority, but preserve order)
+    config.orderSensitiveModifiers.forEach((mod, index)=>{
+        modifierWeights.set(mod, 1000000 + index); // High weights for sensitive mods
+    });
+    return (modifiers)=>{
+        const result = [];
+        let currentSegment = [];
+        // Process modifiers in one pass
+        for(let i = 0; i < modifiers.length; i++){
+            const modifier = modifiers[i];
+            // Check if modifier is sensitive (starts with '[' or in orderSensitiveModifiers)
+            const isArbitrary = modifier[0] === '[';
+            const isOrderSensitive = modifierWeights.has(modifier);
+            if (isArbitrary || isOrderSensitive) {
+                // Sort and flush current segment alphabetically
+                if (currentSegment.length > 0) {
+                    currentSegment.sort();
+                    result.push(...currentSegment);
+                    currentSegment = [];
+                }
+                result.push(modifier);
             } else {
-                unsortedModifiers.push(modifier);
+                // Regular modifier - add to current segment for batch sorting
+                currentSegment.push(modifier);
             }
-        });
-        sortedModifiers.push(...unsortedModifiers.sort());
-        return sortedModifiers;
+        }
+        // Sort and add any remaining segment items
+        if (currentSegment.length > 0) {
+            currentSegment.sort();
+            result.push(...currentSegment);
+        }
+        return result;
     };
-    return sortModifiers;
 };
 const createConfigUtils = (config)=>({
         cache: createLruCache(config.cacheSize),
@@ -294,10 +366,11 @@ const mergeClassList = (classList, configUtils)=>{
             }
             hasPostfixModifier = false;
         }
-        const variantModifier = sortModifiers(modifiers).join(':');
+        // Fast path: skip sorting for empty or single modifier
+        const variantModifier = modifiers.length === 0 ? '' : modifiers.length === 1 ? modifiers[0] : sortModifiers(modifiers).join(':');
         const modifierId = hasImportantModifier ? variantModifier + IMPORTANT_MODIFIER : variantModifier;
         const classId = modifierId + classGroupId;
-        if (classGroupsInConflict.includes(classId)) {
+        if (classGroupsInConflict.indexOf(classId) > -1) {
             continue;
         }
         classGroupsInConflict.push(classId);
@@ -319,13 +392,13 @@ const mergeClassList = (classList, configUtils)=>{
  * - TypeScript types from https://github.com/lukeed/clsx/blob/v1.2.1/clsx.d.ts
  *
  * Original code has MIT license: Copyright (c) Luke Edwards <luke.edwards05@gmail.com> (lukeed.com)
- */ function twJoin() {
+ */ const twJoin = (...classLists)=>{
     let index = 0;
     let argument;
     let resolvedValue;
     let string = '';
-    while(index < arguments.length){
-        if (argument = arguments[index++]) {
+    while(index < classLists.length){
+        if (argument = classLists[index++]) {
             if (resolvedValue = toValue(argument)) {
                 string && (string += ' ');
                 string += resolvedValue;
@@ -333,8 +406,9 @@ const mergeClassList = (classList, configUtils)=>{
         }
     }
     return string;
-}
+};
 const toValue = (mix)=>{
+    // Fast path for strings
     if (typeof mix === 'string') {
         return mix;
     }
@@ -350,20 +424,20 @@ const toValue = (mix)=>{
     }
     return string;
 };
-function createTailwindMerge(createConfigFirst, ...createConfigRest) {
+const createTailwindMerge = (createConfigFirst, ...createConfigRest)=>{
     let configUtils;
     let cacheGet;
     let cacheSet;
-    let functionToCall = initTailwindMerge;
-    function initTailwindMerge(classList) {
+    let functionToCall;
+    const initTailwindMerge = (classList)=>{
         const config = createConfigRest.reduce((previousConfig, createConfigCurrent)=>createConfigCurrent(previousConfig), createConfigFirst());
         configUtils = createConfigUtils(config);
         cacheGet = configUtils.cache.get;
         cacheSet = configUtils.cache.set;
         functionToCall = tailwindMerge;
         return tailwindMerge(classList);
-    }
-    function tailwindMerge(classList) {
+    };
+    const tailwindMerge = (classList)=>{
         const cachedResult = cacheGet(classList);
         if (cachedResult) {
             return cachedResult;
@@ -371,13 +445,13 @@ function createTailwindMerge(createConfigFirst, ...createConfigRest) {
         const result = mergeClassList(classList, configUtils);
         cacheSet(classList, result);
         return result;
-    }
-    return function callTailwindMerge() {
-        return functionToCall(twJoin.apply(null, arguments));
     };
-}
+    functionToCall = initTailwindMerge;
+    return (...args)=>functionToCall(twJoin(...args));
+};
+const fallbackThemeArr = [];
 const fromTheme = (key)=>{
-    const themeGetter = (theme)=>theme[key] || [];
+    const themeGetter = (theme)=>theme[key] || fallbackThemeArr;
     themeGetter.isThemeGetter = true;
     return themeGetter;
 };
@@ -4488,4 +4562,4 @@ const getDefaultConfig = ()=>{
 const twMerge = /*#__PURE__*/ createTailwindMerge(getDefaultConfig);
 
 export { twMerge as t };
-//# sourceMappingURL=bundle-mjs-Lvc-Dri9.mjs.map
+//# sourceMappingURL=bundle-mjs-B1dpl-bk.mjs.map