<section id="scheda-tecnica-" class="mb-6 max-w-screen">
    <div class="scheda_container">

        <div x-data="{ open: false }">
            <button 
                x-on:click="open = ! open" 
                class="text-slate-900 rounded-md py-2 text-base font-medium flex items-center justify-between w-full hover:text-primary"
                >
                <span class="font-semibold">Caratteristiche principali</span>
                <div class="h-3 w-3 ml-2 fill-primary" :class="open?'rotate-180':''">
                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M201.4 374.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 306.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"/></svg> 
                </div>
                
            </button>
            
            <div x-show="open" x-transition class="mb-6">
                <div class="grid grid-cols-2 gap-6">
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    
                </div>
            </div>
        </div>

        <div x-data="{ open: false }">
            <button 
                x-on:click="open = ! open" 
                class="text-slate-900 rounded-md py-2 text-base font-medium flex items-center justify-between w-full hover:text-primary"
                >
                <span class="font-semibold">Caratteristiche fotocamera</span>
                <div class="h-3 w-3 ml-2 fill-primary" :class="open?'rotate-180':''">
                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M201.4 374.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 306.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"/></svg> 
                </div>
                
            </button>
            
            <div x-show="open" x-transition class="mb-6">
                <div class="grid grid-cols-2 gap-6">
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    
                </div>
            </div>
        </div>

        <div x-data="{ open: false }">
            <button 
                x-on:click="open = ! open" 
                class="text-slate-900 rounded-md py-2 text-base font-medium flex items-center justify-between w-full hover:text-primary"
                >
                <span class="font-semibold">Altre caratteristiche</span>
                <div class="h-3 w-3 ml-2 fill-primary" :class="open?'rotate-180':''">
                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M201.4 374.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 306.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"/></svg> 
                </div>
                
            </button>
            
            <div x-show="open" x-transition class="mb-6">
                <div class="grid grid-cols-2 gap-6">
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    
                </div>
            </div>
        </div>

        <div x-data="{ open: false }">
            <button 
                x-on:click="open = ! open" 
                class="text-slate-900 rounded-md py-2 text-base font-medium flex items-center justify-between w-full hover:text-primary"
                >
                <span class="font-semibold">Caratteristiche minori</span>
                <div class="h-3 w-3 ml-2 fill-primary" :class="open?'rotate-180':''">
                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512"><path d="M201.4 374.6c12.5 12.5 32.8 12.5 45.3 0l160-160c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 306.7 86.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l160 160z"/></svg> 
                </div>
                
            </button>
            
            <div x-show="open" x-transition class="mb-6">
                <div class="grid grid-cols-2 gap-6">
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    <div class="block">
                        



<ul class="divide-y divide-slate-200 data_">

        
</ul>

<script>
(function() {
    function equalizeHeights() {
        // Trova tutti gli ul con classi che iniziano con 'data_'
        const ulElements = document.querySelectorAll('ul[class*="data_"]');
        
        if (ulElements.length === 0) return;
        
        // Nascondi temporaneamente per evitare CLS
        const containersToHide = [];
        ulElements.forEach(ul => {
            if (ul.style.visibility !== 'hidden') {
                containersToHide.push(ul);
                ul.style.visibility = 'hidden';
            }
        });
        
        // Raggruppa gli ul per classe
        const classGroups = {};
        
        ulElements.forEach(ul => {
            // Ottieni tutte le classi che iniziano con 'data_'
            const dataClasses = Array.from(ul.classList).filter(className => 
                className.startsWith('data_')
            );
            
            dataClasses.forEach(className => {
                if (!classGroups[className]) {
                    classGroups[className] = [];
                }
                classGroups[className].push(ul);
            });
        });

        // Processa ogni gruppo di classi
        Object.keys(classGroups).forEach(className => {
            processClassGroup(className, classGroups[className]);
        });
        
        // Mostra di nuovo con requestAnimationFrame per evitare CLS
        requestAnimationFrame(() => {
            containersToHide.forEach(ul => {
                ul.style.visibility = 'visible';
            });
        });
    }

    function processClassGroup(className, ulElements) {
        if (ulElements.length === 0) return;

        // Trova il numero massimo di li tra tutti gli ul di questa classe
        let maxLiCount = 0;
        ulElements.forEach(ul => {
            const liCount = ul.querySelectorAll('li').length;
            if (liCount > maxLiCount) {
                maxLiCount = liCount;
            }
        });

        // Per ogni indice di li, equalizza le altezze
        for (let index = 0; index < maxLiCount; index++) {
            equalizeLiAtIndex(ulElements, index);
        }
    }

    function equalizeLiAtIndex(ulElements, index) {
        // Raccogli tutti i li con questo indice
        const liElementsAtIndex = [];
        
        ulElements.forEach(ul => {
            const liElements = ul.querySelectorAll('li');
            if (liElements[index]) {
                liElementsAtIndex.push(liElements[index]);
            }
        });

        if (liElementsAtIndex.length === 0) return;

        // Reset delle altezze per ottenere le altezze naturali
        liElementsAtIndex.forEach(li => {
            li.style.height = 'auto';
        });

        // Trova l'altezza massima tra tutti i li con questo indice
        let maxHeight = 0;
        liElementsAtIndex.forEach(li => {
            const height = li.offsetHeight;
            if (height > maxHeight) {
                maxHeight = height;
            }
        });

        // Imposta tutti i li con questo indice all'altezza massima
        if (maxHeight > 0) {
            liElementsAtIndex.forEach(li => {
                li.style.height = maxHeight + 'px';
            });
        }
    }

    // Debounce per il resize per evitare troppe esecuzioni
    let resizeTimeout;
    function debouncedEqualize() {
        clearTimeout(resizeTimeout);
        resizeTimeout = setTimeout(equalizeHeights, 100);
    }

    // Esegui quando il DOM è pronto
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', equalizeHeights);
    } else {
        // Piccolo delay per assicurarsi che tutto sia renderizzato
        setTimeout(equalizeHeights, 10);
    }

    // Riesegui al ridimensionamento della finestra con debounce
    window.addEventListener('resize', debouncedEqualize);

    const observer = new IntersectionObserver((entries) => {
        entries.forEach(entry => {
            if (entry.isIntersecting) {
                equalizeHeights();
            }
        });
    });
})();
</script>

                    </div>
                    
                </div>
            </div>
        </div>

    </div>

</section>
