BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Carlo-Mierendorff-Schule - ECPv6.16.3//NONSGML v1.0//EN
CALSCALE:GREGORIAN
METHOD:PUBLISH
X-WR-CALNAME:Carlo-Mierendorff-Schule
X-ORIGINAL-URL:https://cms-kostheim.de
X-WR-CALDESC:Veranstaltungen für Carlo-Mierendorff-Schule
REFRESH-INTERVAL;VALUE=DURATION:PT1H
X-Robots-Tag:noindex
X-PUBLISHED-TTL:PT1H
BEGIN:VTIMEZONE
TZID:Europe/Berlin
BEGIN:DAYLIGHT
TZOFFSETFROM:+0100
TZOFFSETTO:+0200
TZNAME:CEST
DTSTART:20250330T010000
END:DAYLIGHT
BEGIN:STANDARD
TZOFFSETFROM:+0200
TZOFFSETTO:+0100
TZNAME:CET
DTSTART:20251026T010000
END:STANDARD
BEGIN:DAYLIGHT
TZOFFSETFROM:+0100
TZOFFSETTO:+0200
TZNAME:CEST
DTSTART:20260329T010000
END:DAYLIGHT
BEGIN:STANDARD
TZOFFSETFROM:+0200
TZOFFSETTO:+0100
TZNAME:CET
DTSTART:20261025T010000
END:STANDARD
BEGIN:DAYLIGHT
TZOFFSETFROM:+0100
TZOFFSETTO:+0200
TZNAME:CEST
DTSTART:20270328T010000
END:DAYLIGHT
BEGIN:STANDARD
TZOFFSETFROM:+0200
TZOFFSETTO:+0100
TZNAME:CET
DTSTART:20271031T010000
END:STANDARD
END:VTIMEZONE
BEGIN:VEVENT
DTSTART;VALUE=DATE:20260615
DTEND;VALUE=DATE:20260616
DTSTAMP:20260611T185211
CREATED:20250814T135758Z
LAST-MODIFIED:20250814T135758Z
UID:18743-1781481600-1781567999@cms-kostheim.de
SUMMARY:Abgabe Freundewünsche zur Einschulung 2026/2027
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/abgabe-freundewuensche-zur-einschulung-2026-2027/
LOCATION:CMS Herrenstraße\, Herrenstraße 70\, Mainz-Kostheim\, 55246\, Germany
CATEGORIES:Einschulung,Einschulung 2026/2027
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
BEGIN:VEVENT
DTSTART;TZID=Europe/Berlin:20260615T140000
DTEND;TZID=Europe/Berlin:20260615T153000
DTSTAMP:20260611T185211
CREATED:20250901T093057Z
LAST-MODIFIED:20250901T093057Z
UID:18879-1781532000-1781537400@cms-kostheim.de
SUMMARY:Vor-Schüler-Club Abschlussfest
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/vor-schueler-club-abschlussfest-2/
LOCATION:CMS Herrenstraße\, Herrenstraße 70\, Mainz-Kostheim\, 55246\, Germany
CATEGORIES:Feier,Vor-Schüler-Club
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
BEGIN:VEVENT
DTSTART;TZID=Europe/Berlin:20260624T080000
DTEND;TZID=Europe/Berlin:20260624T120000
DTSTAMP:20260611T185211
CREATED:20250901T093128Z
LAST-MODIFIED:20250901T093128Z
UID:18881-1782288000-1782302400@cms-kostheim.de
SUMMARY:Schulpicknick
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/schulpicknick-2/
CATEGORIES:Sonstiges
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
BEGIN:VEVENT
DTSTART;TZID=Europe/Berlin:20260626T080000
DTEND;TZID=Europe/Berlin:20260626T104000
DTSTAMP:20260611T185211
CREATED:20250901T093226Z
LAST-MODIFIED:20250901T093226Z
UID:18883-1782460800-1782470400@cms-kostheim.de
SUMMARY:Klassenlehrkraftunterricht 1.-3. Stunde und Zeugnisausgabe
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/klassenlehrkraftunterricht-1-3-stunde-und-zeugnisausgabe/
CATEGORIES:Klassenlehrkraftunterricht
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
BEGIN:VEVENT
DTSTART;VALUE=DATE:20260629
DTEND;VALUE=DATE:20260808
DTSTAMP:20260611T185211
CREATED:20250901T093306Z
LAST-MODIFIED:20250901T093306Z
UID:18885-1782691200-1786147199@cms-kostheim.de
SUMMARY:Sommerferien
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/sommerferien-2/
CATEGORIES:Ferien
END:VEVENT
BEGIN:VEVENT
DTSTART;TZID=Europe/Berlin:20260810T084500
DTEND;TZID=Europe/Berlin:20260810T123000
DTSTAMP:20260611T185211
CREATED:20250901T093350Z
LAST-MODIFIED:20250901T093350Z
UID:18887-1786351500-1786365000@cms-kostheim.de
SUMMARY:1. Schultag
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/1-schultag/
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
BEGIN:VEVENT
DTSTART;VALUE=DATE:20260812
DTEND;VALUE=DATE:20260813
DTSTAMP:20260611T185211
CREATED:20250802T095638Z
LAST-MODIFIED:20250802T095638Z
UID:18692-1786492800-1786579199@cms-kostheim.de
SUMMARY:Einschulungstag
DESCRIPTION:
URL:https://cms-kostheim.de/kalender/einschulungstag-2/
LOCATION:CMS Schulstraße\, Schulstraße 3\, Mainz-Kostheim\, 55246\, Germany
CATEGORIES:Einschulung,Einschulung 2026/2027
ORGANIZER;CN="Carlo-Mierendorff-Schule":MAILTO:carlo-mierendorff-schule@wiesbaden.de
END:VEVENT
END:VCALENDAR<!-- Optimized with BerqWP's instant cache. --->
            <script defer>
                var comment = document.createComment(' This website is optimized using the BerqWP plugin. @1781196731 ');
                document.documentElement.insertBefore(comment, document.documentElement.firstChild);

                function isMobileDevice() {
                    return /Mobi|Android|iPhone|iPad|iPod|Opera Mini|IEMobile|WPDesktop/i.test(navigator.userAgent);
                }

                function astraHeaderClass() {
                    if (isMobileDevice() && window.screen.width <= 999) {
                        if ((document.body.classList.contains('theme-astra') || document.body.classList.contains('ast-page-builder-template')) && !document.body.classList.contains('ast-header-break-point')) {
                            document.body.classList.add('ast-header-break-point');
                        }
                    }
                }

                function divimobilemenu() {
                    const divimenuele = document.querySelector('#et_mobile_nav_menu .mobile_menu_bar.mobile_menu_bar_toggle');

                    if (isMobileDevice() && divimenuele) {
                        divimenuele.innerHTML = '<div class="dipi_hamburger hamburger hamburger--spring">     <div class="hamburger-box">         <div class="hamburger-inner"></div>     </div> </div>';
                    }
                }

                divimobilemenu();
                astraHeaderClass();
                window.addEventListener('resize', function() {
                    astraHeaderClass();
                });

                window.dispatchEvent(new Event('berqwp_js_initialized'));
            </script>

        
            <script async>
            (function(){

            document.addEventListener('DOMContentLoaded', function () {
                var berq_img_lazy_options = {
                    root: null, // null means the viewport
                    rootMargin: '200px',
                    threshold: 0
                };

                var img_observer = new IntersectionObserver(function (entries, observer) {
                    entries.forEach(function (entry) {
                        if (entry.isIntersecting) {
                            let img = entry.target;
                            let imgSrc = img.getAttribute('data-berqwpsrc');
                            let imgSrcset = img.getAttribute('data-berqwp-srcset');

                            // Set the actual image source from data-berqwpsrc
                            if (imgSrc !== null) {
                                img.src = imgSrc;
                            }

                            if (imgSrcset !== null) {
                                img.srcset = imgSrcset;
                            }

                            if (img.getAttribute('data-srcset') !== null) {
                                img.srcset = img.getAttribute('data-srcset');
                            }

                            // You might want to remove the data-src attribute after loading
                            img.removeAttribute('data-berqwpsrc');
                            img.removeAttribute('data-berqwp-srcset');

                            img_observer.unobserve(img);
                        }
                    });
                }, berq_img_lazy_options);

                function berqwp_lazyload_images() {
                    let lazyImages = document.querySelectorAll('img[data-berqwpsrc]');
                    lazy_img_int = 1000;

                    lazyImages.forEach(function (img) {
                        img_observer.observe(img);
                    });
                }

                function berqwp_lazyload_source() {
                    let lazyImages = document.querySelectorAll('source[data-berqwp-srcset]');
                    lazy_img_int = 1000;

                    lazyImages.forEach(function (img) {
                        img_observer.observe(img);
                    });
                }

                berqwp_lazyload_images();
                setInterval(berqwp_lazyload_images, 1000);
                setInterval(berqwp_lazyload_source, 1000);

            });

            })()
            </script>
            
            <script async>
            (function(){
                // window.addEventListener('load', function() {
                window.addEventListener('DOMContentLoaded', function() {
                    // Function to load video and its sources
                    function loadLazyVideo(video) {
                        // Set video src from data attribute if exists
                        const videoSrc = video.getAttribute('data-berqwpsrc');
                        if (videoSrc) {
                            video.setAttribute('src', videoSrc);
                        }

                        // Find all <source> tags inside the video and apply their data-berqwpsrc as src
                        const sources = video.querySelectorAll('source');
                        sources.forEach(source => {
                            const sourceSrc = source.getAttribute('data-berqwpsrc');
                            if (sourceSrc) {
                                source.setAttribute('src', sourceSrc);
                            }
                        });

                        // Load the video once the sources have been set
                        video.load();
                    }

                    // Use IntersectionObserver to detect when the video is about to enter the viewport
                    let lazyVideos = [].slice.call(document.querySelectorAll('video.berqwp-lazy-video'));

                    if ('IntersectionObserver' in window) {
                        let lazyVideoObserver = new IntersectionObserver(function(entries, observer) {
                            entries.forEach(function(entry) {
                                if (entry.isIntersecting) {
                                    let video = entry.target;
                                    loadLazyVideo(video);
                                    // Unobserve the video once it's loaded
                                    lazyVideoObserver.unobserve(video);
                                }
                            });
                        });

                        // Observe each lazy video
                        lazyVideos.forEach(function(video) {
                            lazyVideoObserver.observe(video);
                        });
                    } else {
                        // Fallback for browsers that don't support IntersectionObserver
                        lazyVideos.forEach(function(video) {
                            loadLazyVideo(video);
                        });
                    }
                });

            })()
            </script>
            
            <script defer>
                // document.addEventListener('DOMContentLoaded', function () {

                (function(){

                    var options = {
                        root: null, // null means the viewport
                        rootMargin: '0px', // adjust as needed
                        threshold: 0.1 // adjust as needed
                    };

                    var bwp_iframe_observer = new IntersectionObserver(function (entries, observer) {
                        entries.forEach(function (entry) {
                        if (entry.isIntersecting) {
                            let item = entry.target;
                            let iframe = item.getAttribute('data-embed');

                            let wrapper = document.createElement('div');
                            wrapper.innerHTML = iframe;
                            let iframeElement = wrapper.firstChild;

                            // Insert the iframe next to the item
                            item.insertAdjacentElement('afterend', iframeElement);

                            // Remove the original item
                            item.remove();

                            bwp_iframe_observer.unobserve(item);
                        }
                    });
                }, options);

                    let yt_em = document.querySelectorAll('.berqwp-lazy-youtube');
                    yt_em.forEach(function (item) {
                        bwp_iframe_observer.observe(item);
                    });

                })()
                // });
            </script>
            
            <script id='berqwp-preloader' defer>
            class berqwpPreloader {
                jobId = 0;
                pending = new Map();

                _preloadAssets(assets, asType) {
                    const seen = new Set();
                    const unique = assets.filter(({ url }) => {
                        if (seen.has(url)) return false;
                        seen.add(url);
                        return true;
                    });

                    const id = ++this.jobId;

                    return new Promise((resolve) => {
                        if (unique.length === 0) {
                            console.log('[berqwp] empty — resolving immediately');  // Is it bailing here?
                            resolve({ status: 'done', failed: [] });
                            return;
                        }

                        this.pending.set(id, resolve);

                        let completed = 0;
                        const failed = [];

                        const onSettle = () => {
                            completed++;
                            if (completed === unique.length) {
                                this.pending.delete(id);
                                resolve({ status: 'done', failed });
                            }
                        };

                        unique.forEach(({ url, crossOrigin }) => {
                            const alreadyPreloaded = document.querySelector(`link[rel="preload"][as="${asType}"][href="${url}"]`);
                            const alreadyScript    = asType === 'script' && document.querySelector(`script[src="${url}"]:not([type="text/bwp-script"])`);
                            const alreadyStyle     = asType === 'style'  && document.querySelector(`link[rel="stylesheet"][href="${url}"]`);

                            if (alreadyPreloaded || alreadyScript || alreadyStyle) {
                                return onSettle();
                            }

                            const link = document.createElement('link');
                            link.rel  = 'preload';
                            link.as   = asType;
                            link.href = url;

                            if (crossOrigin) {
                                link.crossOrigin = crossOrigin;
                            }

                            link.onload  = () => {
                                console.log('[berqwp] preloaded:', url);  // Is onload firing?
                                onSettle();
                            };
                            link.onerror = () => {
                                console.warn('[berqwp] failed:', url);    // Or is it erroring?
                                failed.push(url);
                                onSettle();
                            };

                            document.head.appendChild(link);
                        });
                    });
                }

                preload(assets) {
                    const normalized = assets.map(a =>
                        typeof a === 'string' ? { url: a, crossOrigin: null } : a
                    );
                    return this._preloadAssets(normalized, 'script');
                }

                preloadScripts() {
                    const elements = [...document.querySelectorAll('script[type="text/bwp-script"]')];
                    const assets = elements
                        .filter(el => el.getAttribute('src'))
                        .map(el => ({
                            url: el.getAttribute('src'),
                            crossOrigin: el.getAttribute('crossorigin') || null
                        }));

                    return this._preloadAssets(assets, 'script');
                }

                preloadStyles() {
                    const elements = [...document.querySelectorAll('link[data-berqwp-style-href]')];
                    const assets = elements
                        .filter(el => el.getAttribute('data-berqwp-style-href'))
                        .map(el => ({
                            url: el.getAttribute('data-berqwp-style-href'),
                            crossOrigin: el.getAttribute('crossorigin') || null
                        }));

                    return this._preloadAssets(assets, 'style');
                }

            }

            (function() {
                window.bwpPreloader = new berqwpPreloader();
            })()
            </script>
            <script defer>
            (function(){
                // Select all inline script tags with type="text/bwp-script"
                const inlineScripts = document.querySelectorAll('script[type="text/bwp-script"]');

                inlineScripts.forEach((script) => {
                    // Get the content of the inline script
                    const scriptContent = script.innerHTML;

                    if (!scriptContent) {
                        return;
                    }

                    if (script.getAttribute('data-type') == 'module') {
                        return;
                    }

                    // Create a Blob from the script content
                    const blob = new Blob([scriptContent], { type: 'application/javascript' });

                    // Create a URL for the Blob
                    const scriptURL = URL.createObjectURL(blob);

                    // Create a new external script tag
                    const newScript = document.createElement('script');
                    newScript.src = scriptURL;
                    newScript.type = 'text/bwp-script';  // Or 'text/bwp-script', but 'application/javascript' is more typical for JS
                    newScript.setAttribute('data-type', script.getAttribute('data-type'));

                    // Copy other attributes if necessary
                    Array.from(script.attributes).forEach(function(attr) {
                        if (attr.name !== 'type' && attr.name !== 'src') {
                            newScript.setAttribute(attr.name, attr.value);
                        }
                    });

                    // Replace the original inline script with the new external script tag
                    script.parentNode.replaceChild(newScript, script);
                });

            })();

            </script>
            <script data-mode='4' defer>
            var berq_click = null;
            function berqwpLoadJs() {

                (function () {
                    'use strict';
                    const VERSION = '3.0';
                    let activated = false;
                    const pendingScripts = new Map();
                    let completedCount = 0;

                    // Custom Event System
                    const createTrackerEvent = (name, detail = {}) =>
                        new CustomEvent(`bwp:${name}`, {
                            detail: {
                                version: VERSION,
                                timestamp: performance.now(),
                                ...detail
                            }
                        });

                    // Event Polyfills
                    (function () {
                        const originalAddEventListener = EventTarget.prototype.addEventListener;
                        const readyState = document.readyState;
                        const simulatedEvents = new WeakMap();

                        function createEvent(type) {
                            const event = new Event(type, { bubbles: false, cancelable: false });
                            event.isSimulated = true;
                            return event;
                        }

                        EventTarget.prototype.addEventListener = function (type, listener, options) {

                            if (typeof listener === 'function') {
                                if (type === 'DOMContentLoaded') {
                                    if (readyState !== 'loading') {
                                        setTimeout(() => listener.call(this, createEvent(type)), 0);
                                        return;
                                    }
                                } else if ((this === window || this instanceof HTMLScriptElement) && type === 'load') {
                                    if (readyState === 'complete') {
                                        setTimeout(() => listener.call(this, createEvent(type)), 0);
                                        return;
                                    }
                                }
                            }


                            originalAddEventListener.call(this, type, listener, options);
                        };

                        ['onDOMContentLoaded', 'onload'].forEach(prop => {
                            const target = prop === 'onload' ? window : document;
                            const descriptor = Object.getOwnPropertyDescriptor(target.constructor.prototype, prop.toLowerCase()) || {};

                            Object.defineProperty(target, prop, {
                                set(fn) {
                                    if (typeof fn === 'function') {
                                        const eventType = prop.replace('on', '').toLowerCase();
                                        if ((eventType === 'domcontentloaded' && readyState !== 'loading') ||
                                            (eventType === 'load' && readyState === 'complete')) {
                                            setTimeout(() => fn.call(target, createEvent(eventType)), 0);
                                        } else {
                                            target.addEventListener(eventType, fn);
                                        }
                                    }
                                    return descriptor.set ? descriptor.set.call(this, fn) : undefined;
                                },
                                get() {
                                    return descriptor.get ? descriptor.get.call(this) : undefined;
                                },
                                configurable: true
                            });
                        });
                    })();

                    // Activation System
                    function activate() {
                        if (activated) return;
                        activated = true;
                        document.dispatchEvent(createTrackerEvent('activation'));

                        // Remove listeners
                        ['mousemove', 'click', 'scroll', 'keydown'].forEach(evt => {
                            window.removeEventListener(evt, activate, true);
                        });

                        processScripts();
                        setupObserver();
                    }

                    function processScripts() {
                        const scripts = Array.from(document.querySelectorAll('script[type="text/bwp-script"]:not([data-earlyberqwp])'));
                        scripts.forEach(convertScript);
                    }

                    function setupObserver() {
                        new MutationObserver(mutations => {
                            mutations.forEach(mutation => {
                                mutation.addedNodes.forEach(node => {
                                    if (node.tagName === 'SCRIPT' && node.type === 'text/bwp-script') {
                                        convertScript(node);
                                    }
                                });
                            });
                        }).observe(document, { childList: true, subtree: true });
                    }

                    // Script Conversion
                    function convertScript(original) {
                        if (original.dataset.processed) return;
                        original.dataset.processed = 'true';

                        const script = document.createElement('script');
                        const attrs = Array.from(original.attributes).filter(a => a.name !== 'type');
                        const id = `script-${performance.now()}-${Math.random().toString(36).slice(2)}`;

                        script.type = original.getAttribute('data-type');
                        try {
                            attrs.forEach(attr => script.setAttribute(attr.name, attr.value));
                        } catch (e) {
                        }
                        if (original.textContent) script.textContent = original.textContent;

                        pendingScripts.set(id, {
                            element: script,
                            src: script.src,
                            isExternal: !!script.src
                        });

                        document.dispatchEvent(createTrackerEvent('script-loading', {
                            scriptId: id,
                            element: script
                        }));

                        script.addEventListener('load', () => handleCompletion(id, true));
                        script.addEventListener('error', () => handleCompletion(id, false));

                        if (original.textContent) {
                            handleCompletion(id, true);
                        }

                        // script.async = false;
                        original.replaceWith(script);
                    }

                    function handleCompletion(id, success) {
                        const record = pendingScripts.get(id);
                        if (!record) return;

                        pendingScripts.delete(id);
                        completedCount++;

                        document.dispatchEvent(createTrackerEvent('script-complete', {
                            scriptId: id,
                            success,
                            duration: performance.now() - record.element.startTime
                        }));

                        if (pendingScripts.size === 0) {
                            document.dispatchEvent(createTrackerEvent('scripts-loaded', {
                                total: completedCount,
                                failed: completedCount - Array.from(pendingScripts.values())
                                    .filter(r => r.success).length
                            }));
                        }
                    }

                    document.addEventListener('bwp:scripts-loaded', (e) => {
                        console.log('scripts loaded.')
                        window.dispatchEvent(new Event('berqwp_after_delay_js_loaded'));

                    });

                    // Initialization
                    activate();

                    window.addEventListener('berqwp_after_delay_js_loaded', function() {
                        let event = new Event('DOMContentLoaded', {
                            bubbles: true,
                            cancelable: true
                        });
                        document.dispatchEvent(event);
                        document.dispatchEvent(new Event('readystatechange'));
                        window.dispatchEvent(new Event('load'));


                        // Create a new resize event
                        var resizeEvent = new Event('resize');

                        // Dispatch the resize event
                        window.dispatchEvent(resizeEvent);


                        if (berq_click) {
                            setTimeout(function() {
                                console.log(berq_click);
                                const clickEvent = new MouseEvent('click', {
                                    bubbles: true,
                                    cancelable: false,
                                    view: window
                                });
                                berq_click.dispatchEvent(clickEvent);
                                berq_click = null;
                            }, 500)
                        }

                    });
                })();
            }
            </script>
            
                <script defer>
                (function() {

                let berqwpScriptTags = document.querySelectorAll('script[type="text/bwp-script"]');
                let jsUrls = Array.from(berqwpScriptTags).map(scriptTag => scriptTag.getAttribute('src')).filter(url => url);

                function preloadJS(jsURLs) {
                    return window.bwpPreloader.preloadScripts();
                }

                let bwp_js_initialized = false;
                function bwp_js_init(jsUrls) {
                    if (bwp_js_initialized) {
                        return;
                    }
                    bwp_js_initialized = true;

                    preloadJS(jsUrls)
                    .then(() => {
                        console.log('Preloading completed, invoking berqwpLoadJs...');
                        if (typeof berqwpLoadJs === 'function') {
                            berqwpLoadJs();
                        } else {
                            console.error('berqwpLoadJs is not defined or not a function.');
                        }
                    })
                    .catch(error => {
                        console.error('bwp_js_init failed during preloadJS:', error);
                    });
                }

                function berqwp_js_handleUserInteraction(event) {

                    if (event.type === 'click' || event.type === 'touchstart') {
                        berq_click = event.target;

                        // Traverse up the DOM to find the closest <a> ancestor
                        if (berq_click.closest('a')) {
                            berq_click = berq_click.closest('a');
                        }

                        // If click is done on a link
                        if (berq_click.tagName === 'A' && berq_click.href && /^https?:\/\//.test(berq_click.href)) {
                            console.log('Skipping JavaScript execution, a link was clicked.')
                            return;
                        }

                        console.log(event.type)

                    }

                    bwp_js_init(jsUrls);


                    // After running the function, remove all event listeners to ensure it runs only once
                    for (let eventType of berqwp_js_interactionEventTypes) {
                        window.removeEventListener(eventType, berqwp_js_handleUserInteraction);
                    }
                }

                let berqwp_js_interactionEventTypes = ['click', 'mousemove', 'keydown', 'touchstart', 'scroll', 'berqwpLoadJS', 'berqwp_interaction_event'];

                for (let eventType of berqwp_js_interactionEventTypes) {
                    window.addEventListener(eventType, berqwp_js_handleUserInteraction, { passive: false });
                }

                })()
                </script>
                
            <script defer>
            function berqwp_init_css() {
                // Get all link tags containing data-berqwp-style-href
                let berqwp_linkTags = document.querySelectorAll('link[data-berqwp-style-href]');

                // Iterate through each link tag
                berqwp_linkTags.forEach(function (linkTag, index) {
                    // Set the href attribute of each link tag
                    linkTag.setAttribute('href', linkTag.getAttribute('data-berqwp-style-href'));

                });

                document
                .querySelectorAll('style[type="text/berqwp-style"]')
                .forEach(style => {
                    style.type = 'text/css';
                });


            }
            </script>
            
                <script defer>
                (function() {

                function berqwp_css_handleUserInteraction(event) {


                    berqwp_init_css();


                    // After running the function, remove all event listeners to ensure it runs only once
                    for (let eventType of berqwp_js_interactionEventTypes) {
                        window.removeEventListener(eventType, berqwp_css_handleUserInteraction);
                    }
                }

                let berqwp_js_interactionEventTypes = ['click', 'mousemove', 'keydown', 'touchstart', 'scroll', 'berqwpLoadJS', 'berqwp_interaction_event'];

                for (let eventType of berqwp_js_interactionEventTypes) {
                    window.addEventListener(eventType, berqwp_css_handleUserInteraction, { passive: false });
                }

                })()
                </script>
                
            <script id='prefetch-links' defer>

                function berq_prerender(url) {
                const s = document.createElement('script');
                s.type = 'speculationrules';
                s.textContent = JSON.stringify({
                    prerender: [{ urls: [url] }]
                });
                document.head.appendChild(s);
                }

                // Set to keep track of prefetched links
                const prefetchedLinks = new Set();

                // Get all anchor tags on the page
                const links = document.querySelectorAll('a:not([data-price-key])');

                // Loop through each anchor tag
                links.forEach(link => {
                    // Add mouseover event listener
                    link.addEventListener('mouseover', () => {
                        const excludes = ['tel:', 'mailto:', 'sms:', 'geo:'];

                        const isExcluded = excludes.some(prefix =>
                            link.href.startsWith(prefix)
                        );

                        // Check if the link has already been prefetched
                        if (!prefetchedLinks.has(link.href) && !isExcluded) {
                            berq_prerender(link.href);

                            // Add the link to the set of prefetched links
                            prefetchedLinks.add(link.href);
                        }
                    });
                });

            </script>