<head>
<!-- START: "Padding Comment section" -->
    <style>
        .text-center.p-2.fw-bold {
            padding: 0.15rem !important; /* Bootstrap p-1 equivalent */
            text-align: left !important;
        }
    </style>
    
    <style>
.article-list-item-caption {
    padding: 0.25rem !important; /* Equivalent to Bootstrap's p-1 */
}
</style>
<!-- END: "Padding Comment section" -->

<!-- START: "Winkelwagen" -->
<style>
.input-group {
	display: none;
	opacity: 0;
	transition: opacity 0.5s ease-in-out, transform 0.5s ease-in-out;
	transform: translateY(10px);
}
.input-group.visible {
	display: flex !important;
	opacity: 1;
	transform: translateY(0);
}
</style>

<script>
(function() {
	const CONFIG = {
		tabId: 'tabAccessoryd78ac839-5c0b-41a0-9fb1-e41b47cf3fc1',
		inputGroupSelector: '.input-group',
		visibilityDisplay: 'flex'
	};

	function isMontageTabActive() {
		const tab = document.getElementById(CONFIG.tabId);
		return tab && getComputedStyle(tab).display !== 'none' && tab.classList.contains('active');
	}

	function toggleInputGroupVisibility() {
		const inputGroup = document.querySelector(CONFIG.inputGroupSelector);
		if (!inputGroup) return;

		if (isMontageTabActive()) {
			inputGroup.classList.add('visible');
		} else {
			inputGroup.classList.remove('visible');
			inputGroup.style.display = 'none'; // fallback
		}
	}

	function observeTabChanges() {
		const tab = document.getElementById(CONFIG.tabId);
		if (!tab) return;

		new MutationObserver(toggleInputGroupVisibility).observe(tab, {
			attributes: true,
			attributeFilter: ['class', 'style']
		});
	}

	function observeInputGroupInjection() {
		const observerTarget = document.querySelector('.site-body-inner') || document.body;

		new MutationObserver(() => {
			const inputGroup = document.querySelector(CONFIG.inputGroupSelector);
			if (inputGroup) {
				toggleInputGroupVisibility();
			}
		}).observe(observerTarget, {
			childList: true,
			subtree: true
		});
	}

	document.addEventListener('DOMContentLoaded', function () {
		observeTabChanges();
		observeInputGroupInjection();
		toggleInputGroupVisibility();
	});
})();
</script>
<!-- END: "Winkelwagen" -->

<!-- START: "Overzicht-knop" -->
<style>
.btn-outline-secondary.configurator-btn-overview {
	border: 2px solid black !important;
	color: black !important;
	background-color: transparent !important;
	transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
}
.btn-outline-secondary.configurator-btn-overview .fas,
.btn-outline-secondary.configurator-btn-overview span {
	color: black !important;
	transition: color 0.3s ease;
}
.btn-outline-secondary.configurator-btn-overview:hover {
	background-color: black !important;
	color: white !important;
	border-color: black !important;
}
.btn-outline-secondary.configurator-btn-overview:hover .fas,
.btn-outline-secondary.configurator-btn-overview:hover span {
	color: white !important;
}
</style>
<!-- END: "Overzicht-knop" -->

<!-- START: "Info-knop" -->
<style>
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"] {
	border: 2px solid black !important;
	color: black !important;
	background-color: transparent !important;
	transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
}
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"] .fas,
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"] span {
	color: black !important;
	transition: color 0.3s ease;
}
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"]:hover {
	background-color: black !important;
	color: white !important;
	border-color: black !important;
}
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"]:hover .fas,
.btn-outline-secondary.d-inline[data-bs-target="#modal-help"]:hover span {
	color: white !important;
}
</style>
<!-- END: "Info-knop" -->

<!-- START: "Terug-knop" -->
<style>
.btn-outline-secondary.configurator-btn-goto {
	border: 2px solid black !important;
	color: black !important;
	background-color: transparent !important;
	transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
}
.btn-outline-secondary.configurator-btn-goto .fas,
.btn-outline-secondary.configurator-btn-goto span {
	color: black !important;
	transition: color 0.3s ease;
}
.btn-outline-secondary.configurator-btn-goto:hover {
	background-color: black !important;
	color: white !important;
	border-color: black !important;
}
.btn-outline-secondary.configurator-btn-goto:hover .fas,
.btn-outline-secondary.configurator-btn-goto:hover span {
	color: white !important;
}
</style>
<!-- END: "Terug-knop" -->

<!-- START: "Refresh-knop" -->
<style>
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"] {
	border: 2px solid black !important;
	color: black !important;
	background-color: transparent !important;
	transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
}
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"] .fas,
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"] span {
	color: black !important;
	transition: color 0.3s ease;
}
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"]:hover {
	background-color: black !important;
	color: white !important;
	border-color: black !important;
}
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"]:hover .fas,
.btn-outline-secondary[data-bs-target="#modalSwitchedSketch"]:hover span {
	color: white !important;
}
</style>
<!-- END: "Refresh-knop" -->

<!-- START: "Groepsknoppen" -->
<style>
/* Algemene outline-stijl voor .groupButton knoppen */
.groupButton.btn-outline-secondary {
	border: 2px solid black !important;
	color: black !important;
	background-color: transparent !important;
	transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
}

/* Hover-effect: zwart met witte tekst */
.groupButton.btn-outline-secondary:hover {
	background-color: black !important;
	color: white !important;
	border-color: black !important;
}

/* Zorg dat tekst binnen de knop ook kleurt (soms span-loos) */
.groupButton.btn-outline-secondary:hover * {
	color: white !important;
}

/* Als u ooit iconen zou toevoegen binnen .groupButton */
.groupButton .fas,
.groupButton span {
	transition: color 0.3s ease;
	color: black !important;
}

.groupButton:hover .fas,
.groupButton:hover span {
	color: white !important;
}

/* Optioneel: .btn-secondary (zoals de 'Wit' knop) stijl ook updaten */
.groupButton.btn-secondary {
	border: 2px solid black !important;
	background-color: black !important;
	color: white !important;
}

.groupButton.btn-secondary:hover {
	background-color: #222 !important;
	border-color: black !important;
	color: white !important;
}
</style>
<!-- END: "Groepsknoppen" -->

<!-- START: "Wachtwoord vergeten?" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const h1 = document.querySelector('h1');
  if (h1 && h1.textContent.trim() === "Passwort vergessen?") {
    h1.textContent = "Wachtwoord wijzigen";
  }
});
</script>
<!-- END: "Wachtwoord vergeten?" -->

<!-- START: "Optionele diensten en accessoires" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const header = document.querySelector('h2.hyphenate.d-inline');
    
    if (header && header.textContent.trim() === "Optionele diensten en accessoires") {
      const alreadyExists = header.nextElementSibling?.classList?.contains('subtitle-info');
      if (!alreadyExists) {
        const info = document.createElement("p");
        info.textContent = "Hier ziet u een overzicht van alle aanvullende diensten, accessoires en optionele onderdelen die u heeft geselecteerd voor uw huidige configuratie. Deze keuzes zijn aanvullend op uw basisproduct en vormen samen de complete samenstelling van uw bestelling. U kunt hier nog wijzigingen aanbrengen of aanvullende opties toevoegen en verwijderen.";
        info.className = "subtitle-info";
        info.style.marginTop = "0.25rem";
        info.style.fontSize = "0.95rem";
        info.style.color = "#666";
        header.parentNode.insertBefore(info, header.nextSibling);
      }
    }
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Optionele diensten en accessoires" -->

<!-- START: "Montage description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const allParagraphs = document.querySelectorAll('p');
    for (const p of allParagraphs) {
      if (p.textContent.trim() === "Montage") {
        // Vermijd dubbele wijziging
        if (!p.classList.contains("montage-p-replaced")) {
          p.textContent = "Selecteer of u de montage door ons wilt laten uitvoeren of deze liever zelf regelt. U kunt hierin volledig vrij kiezen, eventuele kosten worden vooraf duidelijk weergegeven.";
          p.classList.add("montage-p-replaced");
        }
      }
    }
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Montage description" -->

<!-- START: "Montage title" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const montageHeaders = document.querySelectorAll('h3');

    montageHeaders.forEach(h3 => {
      if (h3.textContent.trim() === "Montage" && !h3.classList.contains("montage-h3-replaced")) {
        h3.textContent = "Zelf monteren of laten doen?";
        h3.classList.add("montage-h3-replaced");
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Montage title" -->

<!-- START: "Productvariant description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const header = document.querySelector('h2.hyphenate.d-inline');

    if (header && header.textContent.trim() === "Productvariant") {
      const alreadyExists = header.nextElementSibling?.classList?.contains('subtitle-productvariant');
      if (!alreadyExists) {
        const info = document.createElement("p");
        info.textContent = "Selecteer hier het type raam of deur dat u wilt samenstellen. U kunt kiezen uit verschillende varianten, zoals een standaard raam, voordeur, achterdeur of schuifdeur. Deze keuze vormt de basis voor de verdere configuratie van uw product, waarbij afmetingen, functies en esthetische opties worden afgestemd op uw voorkeuren en woonsituatie.";
        info.className = "subtitle-productvariant";
        info.style.marginTop = "0.25rem";
        info.style.fontSize = "0.95rem";
        info.style.color = "#666";
        header.parentNode.insertBefore(info, header.nextSibling);
      }
    }
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Productvariant description" -->

<!-- START: "Productvariant Info-Box (HIDE)" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const header = document.querySelector('h2.hyphenate.d-inline');

    if (header && header.textContent.trim() === "Productvariant") {
      const container = header.closest('.col-auto.mb-2');
      if (container) {
        const button = container.querySelector('button[data-bs-target="#modal-help"]');
        if (button && button.getAttribute('data-bs-content') === "Product%20variant") {
          button.remove(); // VERWIJDERT de knop volledig uit de DOM
        }
      }
    }
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<style>
.mb-2 {
  margin-bottom: 0.01rem !important;
}
</style>
<!-- "END: Productvariant Info-Box (HIDE)" -->

<!-- START: "Materiaalsoort description" -->
<style>
.subtitle-materiaalsoort {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h2.hyphenate.d-inline');

    headers.forEach(header => {
      if (header.textContent.trim() === "Materiaalsoort") {
        const container = header.closest('.col-auto.mb-2');
        if (!container) return;

        const alreadyExists = container.querySelector('.subtitle-materiaalsoort');
        if (!alreadyExists) {
          // Eerste paragraaf met uitleg
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-materiaalsoort";
          paragraph.textContent = "Geef hier aan welk materiaaltype uw voorkeur heeft voor uw raam of deur. U heeft de keuze uit hoogwaardige kunststof of robuust aluminium. Kunststof staat bekend om zijn uitstekende isolatiewaarde, onderhoudsvriendelijkheid en gunstige prijs-kwaliteitverhouding. Aluminium daarentegen biedt een moderne uitstraling, slanke profielen en uitzonderlijke duurzaamheid. Beide opties hebben unieke voordelen, afhankelijk van uw esthetische voorkeuren en functionele wensen.";
          container.insertBefore(paragraph, header.nextSibling);

          // Tweede paragraaf met Informatie, in dezelfde stijl
          const info = document.createElement("p");
          info.className = "subtitle-materiaalsoort";
          info.innerHTML = "<b>Informatie:</b><br>Op dit moment is alleen kunststof beschikbaar als materiaalsoort.<br>Aluminium zal op een later moment worden toegevoegd.";
          container.insertBefore(info, paragraph.nextSibling);
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Materiaalsoort description" -->


<!-- START: "Delete info-box" -->
<style>
.subtitle-materiaalsoort {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h2.hyphenate.d-inline');

    headers.forEach(header => {
      if (header.textContent.trim() === "Materiaalsoort") {
        const container = header.closest('.col-auto.mb-2');
        if (!container) return;

        // Verwijder de knop als hij aanwezig is
        const infoButton = container.querySelector('button[data-bs-target="#modal-help"][data-bs-content="Material"]');
        if (infoButton) {
          infoButton.remove();
        }

        // Voeg uitlegparagraaf toe als die nog niet bestaat
        const alreadyExists = container.querySelector('.subtitle-materiaalsoort');
        if (!alreadyExists) {
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-materiaalsoort";
          paragraph.textContent = "Geef hier aan welk materiaaltype uw voorkeur heeft voor uw raam of deur. U heeft de keuze uit hoogwaardige kunststof of robuust aluminium. Kunststof staat bekend om zijn uitstekende isolatiewaarde, onderhoudsvriendelijkheid en gunstige prijs-kwaliteitverhouding. Aluminium daarentegen biedt een moderne uitstraling, slanke profielen en uitzonderlijke duurzaamheid. Beide opties hebben unieke voordelen, afhankelijk van uw esthetische voorkeuren en functionele wensen.";
          container.insertBefore(paragraph, header.nextSibling);
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Delete info-box" -->

<!-- START: "Systeemvariant description" -->
<style>
.subtitle-systeemvariant {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    document.querySelectorAll('h2.hyphenate.d-inline').forEach(header => {
      if (header.textContent.trim() === "Systeemvariant") {
        const container = header.closest('.col-auto.mb-2');
        if (!container) return;

        // Verwijder de infoknop
        const infoBtn = container.querySelector('button[data-bs-target="#modal-help"][data-bs-content="System%20variant"]');
        if (infoBtn) {
          infoBtn.remove();
        }

        // Voeg uitleg toe als die nog niet bestaat
        const alreadyExists = container.querySelector('.subtitle-systeemvariant');
        if (!alreadyExists) {
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-systeemvariant";
          paragraph.textContent = "Kies hier de systeemvariant die past bij uw gewenste kozijnoplossing. Afhankelijk van het gekozen materiaaltype, kunststof of aluminium bieden wij verschillende profielsystemen aan met elk hun eigen functionele en esthetische kenmerken. Uw keuze heeft invloed op de vormgeving, de technische specificaties en het comfortniveau van uw eindproduct. We adviseren u een systeem te selecteren dat zowel aansluit bij uw bouwsituatie als uw persoonlijke voorkeuren op het gebied van design, prestaties en gebruiksgemak.";
          container.insertBefore(paragraph, header.nextSibling);
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Systeemvariant description" -->

<!-- START: Profielsysteem + Standaard + HVL popups -->
<!-- Font Awesome (voor info-icoon) -->
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" integrity="sha512-ZJUFkT5yP3nU6N1mY1trnYJxXv+EjPlHtVtLD9UOZDY2LUV3Ok5CU+t8PK8PfsTx7wn3j7fUI3FG9Y8S6CKI7A==" crossorigin="anonymous" referrerpolicy="no-referrer" />

<style>
.subtitle-profielsysteem {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}

.info-with-label {
  display: inline-flex;
  align-items: center;
  gap: 6px;
  margin-top: 10px;
  margin-right: 12px;
  font-size: 14px;
  color: #333;
}

/* Vierkante info-knoppen */
.show-popup-std,
.show-popup-hvl {
  display: inline-flex;
  justify-content: center;
  align-items: center;
  width: 24px;
  height: 24px;
  background-color: #000;
  color: #fff;
  cursor: pointer;
  transition: background-color 0.3s ease;
  user-select: none;
  font-size: 14px;
  border-radius: 4px; /* licht afgerond voor moderne look */
  box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
}
.show-popup-std i,
.show-popup-hvl i {
  font-size: 12px;
}
.show-popup-std:hover,
.show-popup-hvl:hover {
  background-color: #222;
}

/* Popup-overlay */
.qw-popup-overlay {
  position: fixed;
  top: 0;
  left: 0;
  width: 100vw;
  height: 100vh;
  background-color: rgba(0,0,0,0.6);
  z-index: 9999;
  display: none;
  justify-content: center;
  align-items: center;
}

/* Popup-container */
.qw-popup {
  background-color: #fff;
  padding: 24px;
  border-radius: 8px;
  max-width: 600px;
  width: 90%;
  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
  text-align: center;
  position: relative;
}
.qw-popup img {
  max-width: 100%;
  height: auto;
  border-radius: 6px;
  margin-bottom: 16px;
}
.qw-popup-close {
  position: absolute;
  top: 10px;
  right: 14px;
  background: #000;
  color: #fff;
  border: none;
  font-size: 18px;
  width: 30px;
  height: 30px;
  border-radius: 4px;
  cursor: pointer;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  // Voeg popups toe
  if (!document.getElementById("qw-popup-std")) {
    const popupsHTML = `
      <div class="qw-popup-overlay" id="qw-popup-std">
        <div class="qw-popup">
          <button class="qw-popup-close">&times;</button>
          <img src="https://www.qwindoors.com/web/image/25032-6d979b4b/STD.webp" alt="Standaard verbinding">
          <h5>Standaard verbinding</h5>
          <p>Bij een 45° verstek hoekverbinding worden de profieluiteinden in een hoek van 45 graden met elkaar verbonden. Dit resulteert in een symmetrische en strakke afwerking, waarbij de hoeken netjes in elkaar overlopen.</p>
        </div>
      </div>

      <div class="qw-popup-overlay" id="qw-popup-hvl">
        <div class="qw-popup">
          <button class="qw-popup-close">&times;</button>
          <img src="https://www.qwindoors.com/web/image/25031-3ccfe439/HVL.webp" alt="HVL verbinding">
          <h5>HVL verbinding</h5>
          <p>Houtlookverbinding (HVL): aan de buitenzijde van het kozijnprofiel wordt een rechte verbinding toegepast, waardoor het uiterlijk sterk doet denken aan een traditionele houten kozijnverbinding. De binnenzijde van het profiel wordt standaard verbonden met een hoek van 45 graden.</p>
        </div>
      </div>
    `;
    document.body.insertAdjacentHTML('beforeend', popupsHTML);
  }

  // Popup openen
  function openPopup(id) {
    document.querySelectorAll('.qw-popup-overlay').forEach(p => p.style.display = 'none');
    const popup = document.getElementById(id);
    if (popup) popup.style.display = 'flex';
  }

  // Popup sluiten bij klik buiten de box of op sluitknop
  document.addEventListener('click', function (e) {
    document.querySelectorAll('.qw-popup-overlay').forEach(popup => {
      if (popup.style.display === 'flex') {
        const popupBox = popup.querySelector('.qw-popup');
        const closeBtn = popup.querySelector('.qw-popup-close');
        if (
          !popupBox.contains(e.target) || e.target === closeBtn
        ) {
          popup.style.display = 'none';
        }
      }
    });
  });

  // Observer injectie bij "Profielsysteem"
  const observer = new MutationObserver(() => {
    document.querySelectorAll('h2.hyphenate.d-inline').forEach(header => {
      if (header.textContent.trim() === "Profielsysteem") {
        const container = header.closest('.col-auto.mb-2');
        if (!container) return;

        const infoBtn = container.querySelector('button[data-bs-target="#modal-help"][data-bs-content="Profile%20system"]');
        if (infoBtn) infoBtn.remove();

        const alreadyExists = container.querySelector('.subtitle-profielsysteem');
        if (!alreadyExists) {
          const paragraph = document.createElement("div");
          paragraph.className = "subtitle-profielsysteem";
          paragraph.innerHTML = `
            <p>Kies hier het gewenste profielsysteem voor uw raam of deur. Het profielsysteem bepaalt de opbouw, uitstraling en afwerking van het kozijn, en vormt de basis voor verdere keuzes in kleur, isolatie en vormgeving.</p>
            <p><strong>Met adapter (Uitsluitend voor achterdeuren):</strong> wanneer er naast of boven de deur een raamvlak is.</p>
            <div style="display: flex; gap: 20px; margin-top: 8px;">
              <div class="info-with-label">
                <span class="show-popup-std"><i class="fas fa-info"></i></span>
                <span>Standaard verbinding</span>
              </div>
              <div class="info-with-label">
                <span class="show-popup-hvl"><i class="fas fa-info"></i></span>
                <span>HVL verbinding</span>
              </div>
            </div>
          `;
          container.insertBefore(paragraph, header.nextSibling);

          // Eventlisteners koppelen
          paragraph.querySelector('.show-popup-std')?.addEventListener('click', () => openPopup('qw-popup-std'));
          paragraph.querySelector('.show-popup-hvl')?.addEventListener('click', () => openPopup('qw-popup-hvl'));

          paragraph.querySelector('.show-popup-std')?.addEventListener('mouseover', () => openPopup('qw-popup-std'));
          paragraph.querySelector('.show-popup-hvl')?.addEventListener('mouseover', () => openPopup('qw-popup-hvl'));
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: Profielsysteem + Standaard + HVL popups -->

<!-- START: "Type description" -->
<style>
  .subtitle-type {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666666;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      const header = document.querySelector('h2.hyphenate.d-inline');
      if (!header || header.textContent.trim() !== "Type") return;

      // Verwijder de info-knop
      const button = header.parentElement.querySelector('button[data-bs-target="#modal-help"][data-bs-content="Type"]');
      if (button) {
        button.remove();
      }

      // Voeg de ondertitel toe als die nog niet bestaat
      const existingSubtitle = header.parentElement.querySelector('.subtitle-type');
      if (!existingSubtitle) {
        const p = document.createElement('p');
        p.className = 'subtitle-type';
        p.innerText = 'Bepaal hier de verdeling van uw kozijn door het aantal vakken (raam- of deursegmenten) te selecteren. U kunt kiezen uit verschillende indelingen, zoals 1-vak (één groot segment), 2-vakken, 3-vakken of 4-vakken, afhankelijk van uw gewenste uitstraling, lichtinval en functionele eisen. Na het selecteren van een verdeling kunt u per vak bepalen welk type element daarin komt: bijvoorbeeld een vast raam, draaikiepraam of valraam. Deze stap vormt de basis van uw indeling en bepaalt mede de vormgeving, doorkijk en ventilatiemogelijkheden van het geheel. Kies de opbouw die het beste aansluit bij uw woning en gebruiksdoel.';
        header.insertAdjacentElement('afterend', p);
      }
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Type description" -->

<!-- START: "Afmetingen description" -->
<style>
  .subtitle-afmetingen {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666666;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      const headers = document.querySelectorAll('h2.hyphenate.d-inline');
      headers.forEach(header => {
        if (header.textContent.trim() === "Afmetingen") {
          // Verwijder infoknop
          const infoBtn = header.parentElement.querySelector('button[data-bs-content="Dimensions"]');
          if (infoBtn) infoBtn.remove();

          // Voeg omschrijving toe indien nog niet aanwezig
          if (!header.parentElement.querySelector('.subtitle-afmetingen')) {
            const p = document.createElement('p');
            p.className = 'subtitle-afmetingen';
            p.innerText =
              "Geef hier de gewenste breedte en hoogte van uw raam of deur op. Let erop dat u binnen de toegestane minimale en maximale maten blijft zoals aangegeven op deze pagina. De opgegeven afmetingen vormen de basis voor de productie van uw kozijn en zijn essentieel voor een juiste passing in uw project.";
            header.insertAdjacentElement('afterend', p);
          }
        }
      });
    });

    observer.observe(document.body, { childList: true, subtree: true });
  });
</script>
<!-- END: "Afmetingen description" -->

<!-- START: "Kleur description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
	const targetText = "Kleur";
	const descriptionText = "Kies hier de gewenste kleurstelling van uw kozijn. U kunt afzonderlijk de kleur van de binnenzijde, buitenzijde of beide zijden bepalen. Maak een keuze uit een breed scala aan RAL-kleuren en foliedecors, variërend van strak wit tot houtnerfstructuren of moderne antraciettinten. Uw kleurkeuze bepaalt in grote mate de uitstraling van uw woning, dus kies een combinatie die past bij zowel uw interieur als exterieur. De kleuren zijn duurzaam, onderhoudsvriendelijk en afgestemd op langdurig gebruik onder verschillende weersomstandigheden.";

	const observer = new MutationObserver(() => {
		document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
			if (h2.textContent.trim() === targetText && !h2.closest(".col-auto").querySelector(".subtitle-kleur")) {
				const p = document.createElement("p");
				p.className = "subtitle-kleur";
				p.textContent = descriptionText;
				p.style.marginTop = "0.25rem";
				p.style.fontSize = "0.95rem";
				p.style.color = "#666";

				h2.insertAdjacentElement("afterend", p);

				// Verwijder optionele infoknop als aanwezig
				const infoButton = h2.parentElement.querySelector('button[data-bs-target="#modal-help"]');
				if (infoButton) infoButton.remove();
			}
		});
	});

	observer.observe(document.body, {
		childList: true,
		subtree: true
	});
});
</script>
<!-- END: "Kleur description" -->

<!-- START: "Glas/Paneel description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
	const targetText = "Glas / Paneel";
	const descriptionText = "Selecteer hier uw gewenste glas- of paneelvulling voor de gekozen velden. U heeft keuze uit verschillende soorten glas zoals dubbelglas, HR++ glas, triple glas of decoratief glas, en diverse panelen afhankelijk van het gebruik. Uw keuze beïnvloedt zowel de isolatiewaarde als de uitstraling van het eindproduct.";

	const observer = new MutationObserver(() => {
		document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
			if (h2.textContent.trim() === targetText && !h2.closest(".col-auto").querySelector(".subtitle-glas-paneel")) {
				const p = document.createElement("p");
				p.className = "subtitle-glas-paneel";
				p.textContent = descriptionText;
				p.style.marginTop = "0.25rem";
				p.style.fontSize = "0.95rem";
				p.style.color = "#666";

				h2.insertAdjacentElement("afterend", p);

				// Optioneel: verwijder de info-knop
				const infoButton = h2.parentElement.querySelector('button[data-bs-target="#modal-help"]');
				if (infoButton) infoButton.remove();
			}
		});
	});

	observer.observe(document.body, {
		childList: true,
		subtree: true
	});
});
</script>
<!-- END: "Glas/Paneel description" -->

<!-- START: "Draarichting description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
	const targetText = "Draairichting";
	const descriptionText = "Geef hier aan naar welke zijde uw raam of deur moet openen. Afhankelijk van de situering van uw kozijn en uw persoonlijke voorkeuren kiest u voor een links- of rechtsdraaiende variant. Dit is van belang voor de functionaliteit en het gebruiksgemak in uw ruimte.";

	const observer = new MutationObserver(() => {
		document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
			if (h2.textContent.trim() === targetText && !h2.closest(".col-auto").querySelector(".subtitle-draairichting")) {
				const p = document.createElement("p");
				p.className = "subtitle-draairichting";
				p.textContent = descriptionText;
				p.style.marginTop = "0.25rem";
				p.style.fontSize = "0.95rem";
				p.style.color = "#666";

				h2.insertAdjacentElement("afterend", p);
			}
		});
	});

	observer.observe(document.body, {
		childList: true,
		subtree: true
	});
});
</script>
<!-- END: "Draarichting description" -->

<!-- START: "Ventilatierooster description" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
	const targetText = "Ventilatierooster";
	const descriptionText = "Geef hier aan of u een ventilatierooster wenst op veld 1 of veld 2 van het kozijn. U kunt per veld afzonderlijk bepalen of u ventilatie wilt en daarbij ook de gewenste kleur selecteren. Dit draagt bij aan een gezond binnenklimaat zonder concessies te doen aan het design.";

	const observer = new MutationObserver(() => {
		document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
			if (h2.textContent.trim() === targetText) {
				// Voeg de omschrijving toe indien die nog niet bestaat
				if (!h2.closest(".col-auto").querySelector(".subtitle-ventilatierooster")) {
					const p = document.createElement("p");
					p.className = "subtitle-ventilatierooster";
					p.textContent = descriptionText;
					p.style.marginTop = "0.25rem";
					p.style.fontSize = "0.95rem";
					p.style.color = "#666";
					h2.insertAdjacentElement("afterend", p);
				}
			}
		});

		// Verberg info-knop bij ventilatierooster
		document.querySelectorAll('button[data-bs-toggle="modal"][data-bs-target="#modal-help"]').forEach(button => {
			if (button.getAttribute("data-bs-content") === "Sash%20filler") {
				button.style.display = "none";
			}
		});
	});

	observer.observe(document.body, {
		childList: true,
		subtree: true
	});
});
</script>
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const buttons = document.querySelectorAll('button[data-bs-toggle="modal"][data-bs-target="#modal-help"]');

    buttons.forEach(button => {
      const content = button.getAttribute("data-bs-content");
      if (content === "Sash%20filler") {
        button.remove(); // Verwijder de knop compleet uit de DOM
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: "Ventilatierooster description" -->

<!-- START: "Ventilatierooster <br>" -->
<style>
/* Zorgt voor een witruimte onder de ventilatierooster-tegelrij */
.sashFillersSwitcher .carousel-inner {
    margin-bottom: 1rem; /* simuleert een <br> */
}
</style>
<!-- END: "Ventilatierooster <br>" -->

<!-- START: "Ventilatierooster (HIDE LEFT/RIGHT/BOTTOM)" -->
<style>
/* Verberg de radioknoppen 'Onder', 'Links' en 'Rechts' volledig */
label.form-check-label input#sashFillers_side_below,
label.form-check-label input#sashFillers_side_left,
label.form-check-label input#sashFillers_side_right {
    display: none !important;
}

label.form-check-label input#sashFillers_side_below + *,
label.form-check-label input#sashFillers_side_left + *,
label.form-check-label input#sashFillers_side_right + * {
    display: none !important;
}

/* Als er geen andere styling is, dan volstaat dit ook: */
label.form-check-label:has(#sashFillers_side_below),
label.form-check-label:has(#sashFillers_side_left),
label.form-check-label:has(#sashFillers_side_right) {
    display: none !important;
}
</style>
<!-- END: "Ventilatierooster (HIDE LEFT/RIGHT/BOTTOM)" -->

<!-- START: "Roedenvelden description" -->
<style>
  .subtitle-roedenvelden {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Roedenvelden") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // verwijder de info-knop
          const infoBtn = container.querySelector('button[data-bs-content="Window%20bar%20image"]');
          if (infoBtn) {
            infoBtn.remove();
          }

          // voeg beschrijving toe indien nog niet aanwezig
          if (!container.querySelector(".subtitle-roedenvelden")) {
            const p = document.createElement("p");
            p.className = "subtitle-roedenvelden";
            p.textContent = "Selecteer hier het gewenste roedenpatroon voor uw raam of deur. Roedenvelden voegen een klassiek of juist modern accent toe aan uw kozijn. U kunt kiezen uit horizontale, verticale of kruisverdelingen met verschillende rastervormen. Uw keuze heeft invloed op het esthetisch beeld, zichtlijnen en lichtinval.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Roedenvelden description" -->

<!-- START: "Roedensoort description" -->
<style>
  .subtitle-roedensoort {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Roedensoort") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // Verwijder de info-knop
          const infoBtn = container.querySelector('button[data-bs-content="Window%20bar%20variant"]');
          if (infoBtn) infoBtn.remove();

          // Voeg beschrijving toe indien nog niet aanwezig
          if (!container.querySelector(".subtitle-roedensoort")) {
            const p = document.createElement("p");
            p.className = "subtitle-roedensoort";
            p.textContent = "Kies hier het type roedensoort dat u wilt toepassen. U heeft onder andere de keuze uit roedes in het glas of constructieve tussenstijlen zoals brievenbusprofielen. De gekozen variant bepaalt zowel het uiterlijk als de functionaliteit van uw kozijn.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Roedensoort description" -->

<!-- START: "Verdeling van het raamwerk description" -->
<style>
  .subtitle-raamverdeling {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Verdeling van het raamwerk") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // Voeg beschrijving toe indien nog niet aanwezig
          if (!container.querySelector(".subtitle-raamverdeling")) {
            const p = document.createElement("p");
            p.className = "subtitle-raamverdeling";
            p.textContent = "Stel hier de verdeling van het raamwerk in. U kunt aangeven of u een horizontale of verticale verdeling wenst, en op welke hoogte of positie deze moet komen. Dit heeft invloed op het aanzicht en de praktische toepassing van het kozijn, zoals voor ventilatie- of glasindelingen.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Verdeling van het raamwerk description" -->

<!-- START: "Lekdorpel description" -->
<style>
  .subtitle-lekdorpel {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Lekdorpel") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // Omschrijving alleen toevoegen als deze nog niet bestaat
          if (!container.querySelector(".subtitle-lekdorpel")) {
            const p = document.createElement("p");
            p.className = "subtitle-lekdorpel";
            p.textContent =
              "Kies hier het type lekdorpel dat onder uw kozijn geplaatst wordt. Een lekdorpel zorgt voor gecontroleerde waterafvoer en voorkomt inwatering in de gevel. U kunt kiezen uit aluminium of natuursteen, afhankelijk van de gewenste uitstraling, duurzaamheid en budget. Een goede lekdorpel draagt bij aan de levensduur van uw gevel en kozijn.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Lekdorpel description" -->

<!-- START: "Vensterbank description" -->
<style>
  .subtitle-vensterbank {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Vensterbank") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // ✅ Verwijder info-knop indien aanwezig
          const infoButton = container.querySelector('button[data-bs-target="#modal-help"]');
          if (infoButton) {
            infoButton.remove();
          }

          // ✅ Voeg omschrijving toe indien niet aanwezig
          if (!container.querySelector(".subtitle-vensterbank")) {
            const p = document.createElement("p");
            p.className = "subtitle-vensterbank";
            p.textContent = "Selecteer hier de gewenste diepte van uw vensterbank. U kunt kiezen tussen 250 mm en 300 mm. De vensterbanken zijn beschikbaar in verschillende kleuren: Wit, Crème, Antraciet en Zwart. Vergeet niet uw gewenste kleur(en) in te vullen in het veld onder de prijs bij 'Eventuele specifieke voorkeuren'. Zo kunnen wij uw keuze correct verwerken in de offerte.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Vensterbank description" -->

<!-- START: "Optionele componenten description" -->
<style>
  .subtitle-opties {
    margin-top: 0.25rem;
    font-size: 0.95rem;
    color: #666;
    max-width: 720px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      document.querySelectorAll("h2.hyphenate.d-inline").forEach(h2 => {
        if (h2.textContent.trim() === "Optionele componenten") {
          const container = h2.closest(".col-auto.mb-2");
          if (!container) return;

          // Info-knop verwijderen
          const infoButton = container.querySelector('button[data-bs-target="#modal-help"]');
          if (infoButton && infoButton.getAttribute('data-bs-content') === "Options") {
            infoButton.remove();
          }

          // Omschrijving toevoegen (indien nog niet aanwezig)
          if (!container.querySelector(".subtitle-opties")) {
            const p = document.createElement("p");
            p.className = "subtitle-opties";
            p.textContent = "Op deze pagina kunt u extra opties toevoegen aan uw raam of deur. Denk aan kleur, glas, ventilatierooster of roedeverdelingen. U kunt componenten toevoegen door op het plus-icoon te klikken of bestaande keuzes bewerken met het potloodpictogram.";
            h2.insertAdjacentElement("afterend", p);
          }
        }
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Optionele componenten description" -->

<!-- START: "Warenkorb to Winkelwagen" -->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      const h1 = document.querySelector("h1");
      if (h1 && h1.textContent.trim() === "Warenkorb") {
        h1.textContent = "Winkelwagen";
      }
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Warenkorb to Winkelwagen" -->

<!-- START: "Adresse bearbeiten to Adres bewerken" -->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      const h1 = document.querySelector("h1");
      if (h1 && h1.textContent.trim() === "Adresse bearbeiten") {
        h1.textContent = "Adres bewerken";
      }
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Adresse bearbeiten to Adres bewerken" -->

<!-- START: "Now only" en "You save" vertalen naar NL -->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const replacements = {
      "Now only": "Actieprijs",
      "You save": "U bespaart"
    };

    const observer = new MutationObserver(() => {
      const allTextNodes = [];
      const treeWalker = document.createTreeWalker(
        document.body,
        NodeFilter.SHOW_TEXT,
        null,
        false
      );

      while (treeWalker.nextNode()) {
        allTextNodes.push(treeWalker.currentNode);
      }

      allTextNodes.forEach(node => {
        Object.entries(replacements).forEach(([english, dutch]) => {
          if (node.nodeValue.includes(english)) {
            node.nodeValue = node.nodeValue.replace(english, dutch);
          }
        });
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: "Now only" en "You save" vertalen naar NL -->

<!-- START "Verberg extra prijsopgave bij winkelwagen"-->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const target = document.querySelector('.col-6.col-md-4 .cart-item-unitPrice');
    if (target) {
      target.style.display = 'none';
    }
  });
</script>
<style>
  .col-6.col-md-4 .cart-item-unitPrice {
    display: none !important;
  }
</style>
<!-- END "Verberg extra prijsopgave op winkelwagen"-->

<!-- START "Your price today veranderen naar actieprijs"-->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const elements = document.querySelectorAll("*");

    elements.forEach(function (el) {
      if (el.childNodes.length) {
        el.childNodes.forEach(function (node) {
          if (node.nodeType === 3 && node.nodeValue.includes("Your price today")) {
            node.nodeValue = node.nodeValue.replace("Your price today", "Actieprijs");
          }
        });
      }
    });
  });
</script>
<!-- END "Your price today veranderen naar actieprijs"-->

<!-- START: "Winkelwagen, Leveringsadres, Betaalmethoden, etc" -->
<script>
  function replaceText(node) {
    const replacements = {
      "Adresse": "Leveringsadres",
      "Bestell- bzw. Zahlungsarten": "Betaalmethoden",
      "Lieferarten": "Verzendmethoden",
      "Bestellübersicht": "Besteloverzicht"
    };

    if (node.nodeType === 3) {
      let text = node.nodeValue;
      Object.keys(replacements).forEach((key) => {
        if (text.includes(key)) {
          text = text.replace(key, replacements[key]);
        }
      });
      node.nodeValue = text;
    } else if (node.nodeType === 1 && node.childNodes) {
      node.childNodes.forEach(replaceText);
    }
  }

  document.addEventListener("DOMContentLoaded", () => {
    replaceText(document.body);

    const observer = new MutationObserver((mutations) => {
      mutations.forEach((mutation) => {
        mutation.addedNodes.forEach(replaceText);
      });
    });

    observer.observe(document.body, { childList: true, subtree: true });
  });
</script>
<!-- END: "Winkelwagen, Leveringsadres, Betaalmethoden, etc" -->

<!-- START: "Dubbele prijsopgave winkelwagen" -->
<style>
  .col-md-6 .cart-item-unitPrice {
    display: none !important;
  }
</style>
<!-- END: "Dubbele prijsopgave winkelwagen" -->

<!-- START: "Footer" -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const footer = document.querySelector("footer.site-footer .container");

  if (footer) {
    const copyrightDiv = document.createElement("div");
    copyrightDiv.style.textAlign = "center";
    copyrightDiv.style.fontSize = "0.85rem";
    copyrightDiv.style.color = "#888";
    copyrightDiv.style.paddingTop = "10px";
    copyrightDiv.innerHTML = `© ${new Date().getFullYear()} QWindoors B.V. | De inhoud van deze website is auteursrechtelijk beschermd en eigendom van QWindoors B.V. Alle rechten zijn voorbehouden.<br>Ontworpen door 
      <a href="https://www.exosian.com" target="_blank" style="color: #888; text-decoration: none;">EXOSIAN</a>.`;

    footer.appendChild(copyrightDiv);
  }
});
</script>
<!-- END: "Footer" -->

<!-- START: Product omschrijving "Aluminium & Natuursteen lekdorpel) -->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const productOmschrijvingen = {
      "Lekdorpel (Aluminium)": "Deze aluminium lekdorpel zorgt voor een duurzame en efficiënte afwatering aan de onderzijde van uw kozijn. Het beschermt tegen inwateren en verlengt de levensduur van uw gevel en kozijnconstructie. Een functionele én esthetische toevoeging voor een nette afwerking.",
      "Lekdorpel (Natuursteen)": "De natuurstenen lekdorpel biedt een robuuste en stijlvolle oplossing voor een gecontroleerde waterafvoer. Dankzij zijn natuurlijke uitstraling en hoge duurzaamheid is dit een ideale keuze voor zowel moderne als klassieke gevels. Het voorkomt inwatering en draagt bij aan een lange levensduur van uw kozijn en gevelbekleding."
    };

    function pasOmschrijvingenAan() {
      const rows = document.querySelectorAll(".row.option-item");

      rows.forEach(function (row) {
        const h3 = row.querySelector("h3");
        const p = row.querySelector("p");

        if (h3 && p) {
          const title = h3.textContent.trim();
          const huidigeTekst = p.textContent.trim();
          const nieuweTekst = productOmschrijvingen[title];

          if (nieuweTekst && huidigeTekst !== nieuweTekst) {
            p.textContent = nieuweTekst;
          }
        }
      });
    }

    // Initieel uitvoeren
    pasOmschrijvingenAan();

    // Blijven observeren voor veranderingen
    const observer = new MutationObserver(() => {
      pasOmschrijvingenAan();
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: Product omschrijving "Aluminium & Natuursteen lekdorpel) -->

<!-- START: Product omschrijving "Vensterbanken" -->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const productOmschrijvingen = {
      "Vensterbank (0762) 250 mm - Kleuren: Wit, Crème, Antraciet, Zwart": 
        "Deze 250 mm diepe vensterbank is vervaardigd uit hoogwaardig materiaal en beschikbaar in vier stijlvolle kleuren: Wit, Crème, Antraciet en Zwart. Ideaal voor zowel renovatie als nieuwbouw en perfect afgestemd op elk interieur.",
      
      "Vensterbank (0763) 300 mm - Kleuren: Wit, Crème, Antraciet, Zwart": 
        "Deze 300 mm diepe vensterbank biedt extra ruimte en uitstraling. Dankzij de brede maatvoering en de keuze uit vier kleuren is deze vensterbank een elegante oplossing voor grotere ramen of vensteropeningen."
    };

    function pasOmschrijvingenAan() {
      const rows = document.querySelectorAll(".row.option-item");

      rows.forEach(function (row) {
        const h3 = row.querySelector("h3");
        const p = row.querySelector("p");

        if (h3 && p) {
          const title = h3.textContent.trim();
          const huidigeTekst = p.textContent.trim();
          const nieuweTekst = productOmschrijvingen[title];

          if (nieuweTekst && huidigeTekst !== nieuweTekst) {
            p.textContent = nieuweTekst;
          }
        }
      });
    }

    pasOmschrijvingenAan();

    const observer = new MutationObserver(() => {
      pasOmschrijvingenAan();
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: Product omschrijving "Vensterbanken" -->

<!-- START: Zwarte knopstijl voor resetknop (persistent) -->
<style>
  .btn-zwart {
    background-color: #000 !important;
    color: #fff !important;
    padding: 0.6rem 1.2rem !important;
    border: none !important;
    border-radius: 0px !important;
    font-weight: 500 !important;
    font-size: 1rem !important;
    cursor: pointer !important;
    transition: background-color 0.2s ease, color 0.2s ease !important;
    display: inline-flex !important;
    align-items: center;
    gap: 0.4rem;
    text-decoration: none !important;
  }

  .btn-zwart:hover {
    background-color: #1a1a1a !important;
    color: #fff !important;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    function vervangResetKnop() {
      const resetKnop = document.querySelector("form#resetForm button[type='submit']");

      if (resetKnop && !resetKnop.classList.contains("btn-zwart")) {
        resetKnop.className = "btn-zwart";
      }
    }

    // Initieel uitvoeren
    vervangResetKnop();

    // Blijvend observeren
    const observer = new MutationObserver(() => {
      vervangResetKnop();
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!-- END: Zwarte knopstijl voor resetknop -->

<!-- START: Zwarte knopstijl voor ventilatierooster verwijderen -->
<style>
button.btn-outline-secondary.remove-all-sashFillers {
  background-color: #000 !important;
  color: #fff !important;
  border-color: #000 !important;
  padding: 0.5rem 1.2rem;
  font-size: 1rem;
  border-radius: 0.0rem;
  transition: background-color 0.3s ease, box-shadow 0.3s ease;
}

button.btn-outline-secondary.remove-all-sashFillers:hover {
  background-color: #1a1a1a !important;
  color: #fff !important;
  border-color: #1a1a1a !important;
  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.3);
  cursor: pointer;
}
</style>
<!-- END: Zwarte knopstijl voor ventilatierooster verwijderen -->

<!-- START: Product omschrijving voor Brievenbus -->
<style>
.subtitle-productomschrijving {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h3');

    headers.forEach(header => {
      if (header.textContent.trim() === "ECO Brievenbus - 60 minuten brand- en rookwerend - Efectis Certificering") {
        const container = header.closest('.col-sm-8');
        const alreadyExists = container.querySelector('.subtitle-productomschrijving');

        // Verwijder dubbele <p> met zelfde inhoud als <h3>
        const nextP = header.nextElementSibling;
        if (nextP && nextP.tagName === "P" && nextP.textContent.trim() === header.textContent.trim()) {
          nextP.remove();
        }

        // Voeg ondertitel toe als die nog niet bestaat
        if (!alreadyExists) {
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-productomschrijving";
          paragraph.innerHTML = "<b>Omschrijving:</b><br>Deze ECO brievenbus is 60 minuten brand- en rookwerend getest en gecertificeerd volgens de Efectis-normen. Ideaal voor brandveilige toepassingen in woningen of appartementen.";
          header.insertAdjacentElement("afterend", paragraph);
        }
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!-- END: Product omschrijving voor Brievenbus -->

<!-- START: Product omschrijving voor Cilinders -->
<style>
.subtitle-cilinderslot {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
.subtitle-cilinderslot b {
  font-weight: bold;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    document.querySelectorAll('h3').forEach(header => {
      const container = header.parentElement;
      const titleText = header.textContent.trim();
      const duplicateP = container.querySelector('p');

      // Verwijder dubbele <p> indien deze exact gelijk is aan de <h3>
      if (duplicateP && duplicateP.textContent.trim() === titleText) {
        duplicateP.remove();
      }

      // Voeg beschrijving toe indien nog niet aanwezig
      if (!container.querySelector('.subtitle-cilinderslot')) {
        let infoText = '';

        if (titleText === "Cilinderslot (Doorgaand) - GreenteQ Cilinder 2500 SKG** 40/60") {
          infoText = "<b>Omschrijving:</b><br>Voor situaties waarin het cilinderslot volledig door het profiel heen moet worden geplaatst. Inclusief SKG** certificering voor optimale inbraakveiligheid.";
        } else if (titleText === "Cilinderslot (Gelijksluitend) - GreenteQ Cilinder 2500 SKG** 40/60") {
          infoText = "<b>Omschrijving:</b><br>Deze gelijksluitende cilinder biedt gemak doordat meerdere sloten met één sleutel te openen zijn. Uitgerust met SKG** keurmerk.";
        }

        if (infoText !== '') {
          const para = document.createElement("p");
          para.className = "subtitle-cilinderslot";
          para.innerHTML = infoText;
          container.insertBefore(para, container.querySelector("div"));
        }
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>

<style>
/* Product omschrijving stijl */
.product-omschrijving {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
.product-omschrijving strong {
  display: block;
  font-weight: bold;
  margin-bottom: 0.25rem;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const titles = document.querySelectorAll('h3');

    titles.forEach(title => {
      const text = title.textContent.trim();

      let omschrijving = "";
      switch (text) {
        case "Cilinder (Doorgaand) - K55/S55":
          omschrijving = "Standaard cilinder voor doorgaand gebruik met SKG** keurmerk. Geschikt voor dagelijks gebruik.";
          break;
        case "Cilinderslot (Knopcilinder) - 4500 SKG** K55/S55":
          omschrijving = "Cilinderslot voorzien van draaiknop voor eenzijdige bediening. SKG** beveiligingsniveau.";
          break;
        case "Cilinderslot (Halve knop) - K0/S55":
          omschrijving = "Compacte cilinder met draaiknop aan één zijde. Ideaal voor bergingen of technische ruimtes.";
          break;
        case "Cilinderslot (Halve cilinder) - SKG** K0/S55":
          omschrijving = "Halve cilinder met SKG** certificering. Beveiligde oplossing voor ruimtes met beperkte toegang.";
          break;
        default:
          return;
      }

      const parent = title.closest('.col-sm-8');
      if (parent && !parent.querySelector('.product-omschrijving')) {
        const paragraph = document.createElement("p");
        paragraph.className = "product-omschrijving";
        paragraph.innerHTML = "<strong>Omschrijving:</strong>" + omschrijving;
        parent.appendChild(paragraph);
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!-- END: Product omschrijving voor Cilinders -->

<!-- START: Product omschrijving HST hor --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h3');

    headers.forEach(header => {
      if (header.textContent.trim() === "Vliegenhor voor schuifdeuren") {
        header.textContent = "Plissé hordeur voor schuifdeuren";

        const parent = header.closest('.col-sm-8');
        const alreadyExists = parent.querySelector('.product-omschrijving');

        if (!alreadyExists) {
          const p = document.createElement('p');
          p.className = "product-omschrijving";
          p.innerHTML = "<strong>Omschrijving:</strong> Deze plissé hordeur wordt stijlvol <u>op het kozijn</u> geplaatst en biedt een praktische oplossing voor schuifdeuren. Een elegante en functionele toevoeging die eenvoudig te monteren is.";
          header.insertAdjacentElement("afterend", p);
        }
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!-- END: Product omschrijving HST hor --->

<!-- START: Product omschrijving hor enkel deur --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const configs = [
      {
        title: "Inzethor",
        description: "Een praktische en elegante hor die zonder boren of schroeven in het kozijn geplaatst wordt. Ideaal voor draaikiepramen."
      },
      {
        title: "Plisséhor voor enkel deur",
        description: "Deze plisséhor is ontworpen voor enkeldeuren en wordt stijlvol op het kozijn geplaatst. Een duurzame en ruimtebesparende oplossing met een soepele bediening."
      }
    ];

    configs.forEach(({ title, description }) => {
      document.querySelectorAll(".option-item").forEach((item) => {
        const header = item.querySelector("h3");
        if (header && header.textContent.trim() === title) {
          const exists = item.querySelector(".subtitle-productomschrijving");
          if (!exists) {
            const paragraph = document.createElement("p");
            paragraph.className = "subtitle-productomschrijving";
            paragraph.innerHTML = "<strong>Informatie:</strong><br>" + description;
            const container = item.querySelector(".col-sm-8");
            if (container) container.insertBefore(paragraph, container.querySelector("div"));
          }
        }
      });
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<style>
.subtitle-productomschrijving {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>
<!-- END: Product omschrijving hor enkel deur --->

<!-- START: Product omschrijving hor dubbele deur --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    document.querySelectorAll(".option-item").forEach((item) => {
      const header = item.querySelector("h3");
      if (header && header.textContent.trim() === "Plisséhor voor dubbele deuren") {
        const exists = item.querySelector(".subtitle-productomschrijving");
        if (!exists) {
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-productomschrijving";
          paragraph.innerHTML = "<strong>Informatie:</strong><br>Deze plisséhor voor dubbele deuren wordt op het kozijn gemonteerd. Ideaal voor brede deuropeningen en eenvoudig te bedienen dankzij de soepele vouwtechniek.";
          const container = item.querySelector(".col-sm-8");
          if (container) container.insertBefore(paragraph, container.querySelector("div"));
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>

<style>
.subtitle-productomschrijving {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>
<!-- END: Product omschrijving hor dubbele deur --->

<!-- START: Extra knoppen zwart maken in Winkelwagen --->
<style>
/* Zwarte knoppen met witte tekst */
#addNewConfiguration.btn-outline-secondary,
#duplicateLastConfiguration .btn-outline-secondary,
#addNewArticle.btn-outline-secondary {
    background-color: #000 !important;
    border-color: #000 !important;
    color: #fff !important;
}

/* Hover-effect voor knoppen */
#addNewConfiguration.btn-outline-secondary:hover,
#duplicateLastConfiguration .btn-outline-secondary:hover,
#addNewArticle.btn-outline-secondary:hover {
    background-color: #222 !important;
    border-color: #222 !important;
    color: #fff !important;
}

/* Zorg ervoor dat iconen ook wit blijven */
#addNewConfiguration .fas,
#duplicateLastConfiguration .far,
#addNewArticle .fas {
    color: #fff !important;
}
</style>
<style>
/* Zwarte stijl voor de Opslaan-knop */
button.btn-outline-secondary.btn-sm[form^="form-quantity-"] {
    background-color: #000 !important;
    border-color: #000 !important;
    color: #fff !important;
}

/* Hover-effect */
button.btn-outline-secondary.btn-sm[form^="form-quantity-"]:hover {
    background-color: #222 !important;
    border-color: #222 !important;
    color: #fff !important;
}
</style>
<!-- END: Extra knoppen zwart maken in Winkelwagen --->

<!-- START: Omschrijving diensten --->
<style>
.diensten-omschrijving {
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
  margin-top: 0.25rem;
  margin-bottom: 1rem;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h2.hyphenate.d-inline');

    headers.forEach(header => {
      if (header.textContent.trim() === "Diensten") {
        const container = header.closest('.col-auto.mb-2');
        if (!container.querySelector('.diensten-omschrijving')) {
          const paragraph = document.createElement("p");
          paragraph.className = "diensten-omschrijving";
          paragraph.innerHTML = "Binnen deze hoofdcategorie vallen aanvullende services, waaronder montage. Selecteer alstublieft één van de beschikbare subcategorieën om verder te gaan met uw configuratie.";
          container.appendChild(paragraph);
        }
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!--- END: Omschrijving diensten --->

<!--- START: Omschrijving voor "Producten"--->
<style>
.producten-omschrijving {
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
  margin-top: 0.25rem;
  margin-bottom: 1rem;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h2.hyphenate.d-inline');

    headers.forEach(header => {
      if (header.textContent.trim() === "Producten") {
        const container = header.closest('.col-auto.mb-2');
        if (!container.querySelector('.producten-omschrijving')) {
          const paragraph = document.createElement("p");
          paragraph.className = "producten-omschrijving";
          paragraph.innerHTML = "Binnen deze hoofdcategorie vallen aanvullende accessoires en opties. Selecteer alstublieft één van de beschikbare subcategorieën om verder te gaan met uw configuratie.";
          container.appendChild(paragraph);
        }
      }
    });
  });

  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!--- END: Omschrijving voor "Producten"--->

<!--- START: Verwijder "Remove all fillers"--->
<style>
/* Verberg visueel de container van de knop */
div.col-md-12 > .remove-all-sashFillers {
  display: none !important;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  // Zoek het div-element met de knop "Alle ventilatieroosters verwijderen"
  const removeAllDiv = document.querySelector('div.col-md-12 > .remove-all-sashFillers');
  if (removeAllDiv) {
    const parentDiv = removeAllDiv.closest('.col-md-12');
    if (parentDiv) {
      parentDiv.remove(); // Verwijder het volledige blok uit de DOM
    } else {
      removeAllDiv.remove(); // Fallback: verwijder alleen de knop
    }
  }
});
</script>
<!--- END: Verwijder "Remove all fillers"--->

<!--- START: Ventilatierooster | Alleen blokkeren als inhoud is "Filler_19491") --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  function checkAndRemoveFillerButtons() {
    const rows = document.querySelectorAll("table tr");

    rows.forEach((row) => {
      const cells = row.querySelectorAll("td");
      if (cells.length > 1) {
        const description = cells[1].textContent.trim();

        if (description === "Filler_19491") {
          // Zoek de verwijderknop
          const deleteButton = row.querySelector(".remove-Button");
          if (deleteButton) {
            // Verwijder de knop volledig uit de DOM
            deleteButton.remove();
            console.log(" Filler_19491 verwijderknop is verwijderd uit de DOM.");
          }

          // Optioneel: markeer rij visueel
          row.style.opacity = "0.6";
          row.style.pointerEvents = "none";
          row.style.cursor = "not-allowed";
        }
      }
    });
  }

  // Direct uitvoeren bij paginalaad
  checkAndRemoveFillerButtons();

  // Herhaal automatisch bij dynamische wijzigingen (SPA, reloads, AJAX)
  const observer = new MutationObserver(() => {
    checkAndRemoveFillerButtons();
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true,
  });
});
</script>
<!--- END: Ventilatierooster | Alleen blokkeren als inhoud is "Filler_19491") --->

<!--- START: Klantenservice Icoon --->
<style>
/* Klantenservice knop styling */
.site-header-action.klantenservice-link {
  margin-right: 1rem;
  display: flex;
  align-items: center;
  text-decoration: none;
  color: inherit;
}

.site-header-action.klantenservice-link .fa-headset {
  margin-right: 6px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const actionContainer = document.querySelector(".site-header-actions");

  if (actionContainer) {
    const klantenserviceLink = document.createElement("a");
    klantenserviceLink.href = "https://www.qwindoors.com/klantenservice";
    klantenserviceLink.className = "site-header-action klantenservice-link";
    klantenserviceLink.title = "Neem contact op met onze klantenservice";
    klantenserviceLink.target = "_blank";

    klantenserviceLink.innerHTML = `
      <span class="fas fa-headset site-header-action-icon"></span>
      <span class="d-none d-sm-block">Klantenservice</span>
    `;

    // Voeg de knop toe vóór de "Website"-knop als die bestaat
    const websiteLink = actionContainer.querySelector(".website-link");
    if (websiteLink) {
      actionContainer.insertBefore(klantenserviceLink, websiteLink);
    } else {
      actionContainer.insertBefore(klantenserviceLink, actionContainer.firstChild);
    }
  }
});
</script>
<!--- END: Klantenservice Icoon --->

<!--- START: Verlaten van de tab --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const originalTitle = document.title;

  document.addEventListener("visibilitychange", function () {
    if (document.hidden) {
      // Wanneer gebruiker de tab verlaat
      document.title = "⚠️ Vergeet niet uw configuratie af te ronden, indien u dit nog niet heeft gedaan.";
    } else {
      // Wanneer gebruiker terugkomt
      document.title = originalTitle;
    }
  });
});
</script>
<!--- END: Verlaten van de tab --->

<!-- START: Remove discount image --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    document.querySelectorAll('img.pricing-discount-image').forEach(img => {
      if (img.src.includes("discount.1742821148.png")) {
        img.remove();
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>
<!-- END: Remove discount image --->

<!-- START: Black text nav-winkelwagen --->
<style>
  .checkout-progressBar .nav-link.disabled {
    color: #000000 !important; /* Zwarte tekst voor niet-geselecteerde */
    pointer-events: none;       /* Blokkeer klikken */
    cursor: default;
    opacity: 1;                 /* Zorg dat zwart niet vervaagd is */
  }

  .checkout-progressBar .nav-link.active {
    /* Houd huidige actieve styling intact; 
       geen wijziging tenzij u iets extra’s wilt */
  }
</style>
<!-- END: Black text nav-winkelwagen --->

<!-- START: Volgende knop --->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const buttons = document.querySelectorAll('input[type="submit"][value="volgende"]');
    buttons.forEach(function (button) {
      button.value = "Volgende";
    });
  });
</script>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    // Pas alle input[type=submit] knoppen aan met value="volgende"
    const inputButtons = document.querySelectorAll('input[type="submit"][value="volgende"]');
    inputButtons.forEach(function (button) {
      button.value = "Volgende";
    });

    // Pas alle <button> knoppen aan waarvan de tekst exact "volgende" is
    const textButtons = document.querySelectorAll('button[type="submit"]');
    textButtons.forEach(function (button) {
      if (button.textContent.trim().toLowerCase() === "volgende") {
        button.textContent = "Volgende";
      }
    });
  });
</script>
<!--- END: Volgende knop --->

<!--- START: Offerteaanvraag titel --->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const elements = document.querySelectorAll("*");
    elements.forEach(function (el) {
      if (el.childNodes.length === 1 && el.childNodes[0].nodeType === 3) {
        if (el.textContent.trim() === "Bestellbestätigung") {
          el.textContent = "Wij hebben uw offerteaanvraag in goede orde ontvangen!";
        }
      }
    });
  });
</script>
<!--- END: Offerteaanvraag titel --->

<!--- START: Offerte bevestiging tekst --->
<style>
  .checkout-body .custom-offerte-tekst {
    font-size: 1rem;
    line-height: 1.6;
    font-weight: normal;
    color: #333333;
    margin-top: 10px;
    margin-bottom: 10px;
  }

  .checkout-body h2 {
    display: none !important;
  }

  .checkout-body h1,
  .column > h1 {
    font-size: 1.4rem;
    font-weight: bold;
    margin-bottom: 15px;
  }
</style>

<script>
  document.addEventListener("DOMContentLoaded", function () {
    const header = document.querySelector("h1");
    const isOfferteBevestiging =
      header && header.textContent.trim() === "Wij hebben uw offerteaanvraag in goede orde ontvangen!";

    if (isOfferteBevestiging) {
      const checkoutBody = document.querySelector(".checkout-body");

      if (checkoutBody) {
        // Verwijder bestaande H2 indien aanwezig
        const oldH2 = checkoutBody.querySelector("h2");
        if (oldH2) oldH2.remove();

        // Voer injectie uit
        const newText = document.createElement("div");
        newText.className = "custom-offerte-tekst";
        newText.innerHTML = `
          <strong>Hartelijk dank voor uw offerteaanvraag!</strong><br>
          Wij bevestigen hierbij dat wij uw offerteaanvraag met de grootste zorgvuldigheid hebben ontvangen.<br>
          Onze medewerkers zullen uw aanvraag grondig beoordelen en nemen zo spoedig mogelijk contact met u op om de vervolgstappen met u te bespreken.<br><br>
          Zo kunnen wij u op een persoonlijke en efficiënte manier begeleiden bij het realiseren van uw wensen.<br>
          Wij waarderen uw geduld gedurende dit proces. U mag van ons een professionele en betrokken benadering verwachten, afgestemd op uw specifieke situatie.<br><br>
          Mocht u in de tussentijd vragen hebben, aanvullende informatie willen delen of ergens onzeker over zijn, dan nodigen wij u van harte uit om contact op te nemen met onze Klantenservice.<br>
          Wij staan klaar om u te helpen en u verder te ondersteunen waar nodig.<br><br>
          <ul class="list-unstyled mb-0 ps-2">
            <li><strong>QWindoors B.V.</strong></li>
            <li><i class="fa fa-map-marker fa-fw me-2"></i> Distributieweg 12A, 4906 AD Oosterhout, Nederland</li>
            <li><i class="fa fa-phone fa-fw me-2"></i> 085 401 1168</li>
            <li><i class="fa fa-envelope fa-fw me-2"></i> servicedesk@qwindoors.com</li>
            <li class="mt-2">KvK-nr: 88013294</li>
            <li>Btw-nr: NL864476954B01</li>
            <li>IBAN-nr: NL41 INGB 0106 6103 33<br>(t.n.v. QWindoors B.V.)</li>
          </ul>
        `;
        checkoutBody.appendChild(newText);
      }
    }
  });
</script>
<!--- END: Offerte bevestiging tekst --->

<!--- START: Leveringsadres bewerken --->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const observer = new MutationObserver(() => {
      const allElements = document.querySelectorAll("*");
      allElements.forEach(function (el) {
        el.childNodes.forEach(function (node) {
          if (node.nodeType === 3 && node.nodeValue.includes("Leveringsadres bearbeiten")) {
            node.nodeValue = node.nodeValue.replace("Leveringsadres bearbeiten", "Leveringsadres bewerken");
          }
        });
      });
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
</script>
<!--- END: Leveringsadres bewerken --->

<!--- START: Montage = Ja -->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const tdElements = document.querySelectorAll("td");
  tdElements.forEach(td => {
    if (td.textContent.includes("Montage") && td.textContent.includes("Aantal")) {
      td.textContent = "Inclusief montage";
    }
  });
});
</script>
<!--- END: Montage = Ja --->

<!--- START: Bewerken, Dupliceren, Verwijderen --->
<script>
document.addEventListener("DOMContentLoaded", function () {
  const woorden = {
    "bewerken": "Configuratie bewerken",
    "dupliceren": "Configuratie dupliceren",
    "verwijderen": "Configuratie verwijderen",
  };

  const walkNodes = (node) => {
    if (node.nodeType === 3) { // tekstnode
      let tekst = node.nodeValue;
      Object.keys(woorden).forEach(orig => {
        const regex = new RegExp("\\b" + orig + "\\b", "gi");
        tekst = tekst.replace(regex, woorden[orig]);
      });
      node.nodeValue = tekst;
    } else if (node.nodeType === 1 && node.nodeName !== "SCRIPT" && node.nodeName !== "STYLE") {
      for (let i = 0; i < node.childNodes.length; i++) {
        walkNodes(node.childNodes[i]);
      }
    }
  };

  walkNodes(document.body);
});
</script>
<!--- END: Bewerken, Dupliceren, Verwijderen --->

<!--- START: Verwijderen van "Kosten" in Verzendmethoden --->
<style>
  /* Verberg kosten bij levering en zelf afhalen */
  #delivery-price,
  #selfCollection-price {
    display: none !important;
  }
</style>
<!--- END: Verwijderen van "Kosten" in Verzendmethoden --->

<!--- START: Mededeling knop voor meer info in besteloverzicht --->
<style>
.qw-black-button {
  display: inline-block;
  background-color: #000000;
  color: #ffffff;
  border: 1px solid #000000;
  padding: 10px 20px;
  text-decoration: none;
  font-size: 14px;
  font-weight: 500;
  border-radius: 4px;
  transition: background-color 0.3s ease, color 0.3s ease;
  margin-top: 12px;
}
.qw-black-button:hover {
  background-color: #ffffff;
  color: #000000;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const container = document.querySelector('.col-12 .callout.callout-solid');
  if (container && !document.querySelector('.qw-black-button')) {
    const btn = document.createElement('a');
    btn.href = 'https://configurator.qwindoors.com/nl/informatie';
    btn.target = '_blank';
    btn.rel = 'noopener noreferrer';
    btn.className = 'qw-black-button';
    btn.textContent = 'Meer info';
    container.appendChild(btn);
  }
});
</script>
<!--- END: Mededeling knop voor meer info in besteloverzicht --->

<!--- START: Cookie usercentrics --->
<script id="usercentrics-cmp" src="https://web.cmp.usercentrics.eu/ui/loader.js" data-settings-id="vDQVoGl-SBMmaI" async></script>
<!--- END: Cookie usercentrics --->

<!--- START: Inloggen met hoofdletter --->
<script>
  document.addEventListener('DOMContentLoaded', function () {
    const loginButtons = document.querySelectorAll('button.btn.btn-primary');

    loginButtons.forEach(function (btn) {
      if (btn.textContent.trim().toLowerCase() === 'inloggen') {
        btn.textContent = 'Inloggen';
      }
    });
  });
</script>
<!--- END: Inloggen met hoofdletter --->

<!--- START: Fax/mobiel/Titel veld verwijderen --->
<script>
  document.addEventListener('DOMContentLoaded', function () {
    // Verwijder het formulierblok voor 'Fax'
    const faxInput = document.getElementById('fax');
    if (faxInput) {
      const faxGroup = faxInput.closest('.mb-3.paper-input.custom-form-group');
      if (faxGroup) faxGroup.remove();
    }

    // Verwijder het formulierblok voor 'Mobiel'
    const mobielInput = document.getElementById('mobil');
    if (mobielInput) {
      const mobielGroup = mobielInput.closest('.mb-3.paper-input.custom-form-group');
      if (mobielGroup) mobielGroup.remove();
    }

    // Verwijder het formulierblok voor 'Titel' (input veld)
    const titelInput = document.getElementById('titel');
    if (titelInput) {
      const titelGroup = titelInput.closest('.mb-3.paper-input.custom-form-group');
      if (titelGroup) titelGroup.remove();
    }
  });
</script>
<!--- END: Fax/mobiel/Titel veld verwijderen --->

<!--- START: Registrieren-Registreren --->
<script>
  document.addEventListener('DOMContentLoaded', function () {
    // Zoek naar alle elementen die de tekst 'Registrieren' bevatten
    document.querySelectorAll('*').forEach(function (el) {
      if (el.childNodes.length === 1 && el.childNodes[0].nodeType === Node.TEXT_NODE) {
        if (el.textContent.trim() === 'Registrieren') {
          el.textContent = 'Log in of registreer om door te gaan';
        }
      }
    });
  });
</script>
<!--- END: Registrieren-Registreren --->

<!--- START: Geen Sticky description --->
<style>
  /* Blokkeer spacer-div die het witte vlak veroorzaakt */
  header.tab-pane-header + div[style*="height"][style*="display: flex"] {
    display: none !important;
    height: 0 !important;
    padding: 0 !important;
    margin: 0 !important;
  }

  /* Als die div elders staat (veiligheidshalve check) */
  .tab-pane-header ~ div[style*="height"][style*="display: flex"] {
    display: none !important;
    height: 0 !important;
    padding: 0 !important;
    margin: 0 !important;
  }

  /* Behoud normale weergave header zonder sticky */
  header.tab-pane-header,
  header.tab-pane-header.sticky,
  header.tab-pane-header.is_stuck {
    position: static !important;
    top: auto !important;
    width: auto !important;
    z-index: auto !important;
  }
</style>
<!--- END: Geen Sticky description --->

<!-- START: "Weerstandsniveau uitleg + verwijder info-knop" -->
<style>
.subtitle-beveiligingsniveau {
  margin-top: 0.25rem;
  font-size: 0.95rem;
  color: #666;
  max-width: 720px;
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    const headers = document.querySelectorAll('h2.hyphenate.d-inline');

    headers.forEach(header => {
      if (header.textContent.trim() === "Beveiligingsniveau") {
        const container = header.closest('.col-auto.mb-2');
        if (!container) return;

        // Verwijder info-knop specifiek met data-bs-content
        const infoButton = container.querySelector('button[data-bs-content="Security%20level"]');
        if (infoButton) {
          infoButton.remove();
        }

        const alreadyExists = container.querySelector('.subtitle-beveiligingsniveau');
        if (!alreadyExists) {
          const paragraph = document.createElement("p");
          paragraph.className = "subtitle-beveiligingsniveau";
          paragraph.textContent = "Kies het gewenste beveiligingsniveau voor uw raam of deur. Dit bepaalt in hoeverre het product bestand is tegen inbraak. RC1 biedt basisbescherming, RC2 biedt verhoogde veiligheid en wordt aanbevolen voor woningen.";

          const info = document.createElement("p");
          info.className = "subtitle-beveiligingsniveau";
          info.innerHTML = "<b>Toelichting:</b><br>RC staat voor 'Resistance Class'. RC2 voldoet aan de eisen van politie en verzekering en is geschikt voor de meeste woningen.";

          container.insertBefore(paragraph, header.nextSibling);
          container.insertBefore(info, paragraph.nextSibling);
        }
      }
    });
  });

  observer.observe(document.body, {
    childList: true,
    subtree: true
  });
});
</script>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const observer = new MutationObserver(() => {
    document.querySelectorAll('h2.hyphenate.d-inline').forEach(header => {
      if (header.textContent.trim() === "Weerstandsniveau") {
        header.textContent = "Beveiligingsniveau";
      }
    });
  });
  observer.observe(document.body, { childList: true, subtree: true });
});
</script>
<!-- END: "Weerstandsniveau uitleg + verwijder info-knop" -->

<!--- START: Account gegevens bewerken knop --->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const buttons = document.querySelectorAll('a.btn.btn-primary.mb-2[href="/nl/account-bewerken"]');
    buttons.forEach(function (btn) {
      if (btn.textContent.trim() === "Configuratie bewerken") {
        btn.textContent = "Gegevens bewerken";
      }
    });
  });
</script>
<script>
  document.addEventListener("DOMContentLoaded", function () {
    // Pas <a>-knop aan (eerste verzoek)
    const configBtn = document.querySelector('a.btn.btn-primary.mb-2[href="/nl/account-bewerken"]');
    if (configBtn && configBtn.textContent.trim() === "Configuratie bewerken") {
      configBtn.textContent = "Gegevens bewerken";
    }

    // Pas <h1>-titel aan (tweede verzoek)
    const h1Headers = document.querySelectorAll("h1");
    h1Headers.forEach(function (h1) {
      if (h1.textContent.trim() === "Account Configuratie bewerken") {
        h1.textContent = "Accountgegevens bewerken";
      }
    });
  });
</script>
<!--- END: Account gegevens bewerken knop --->

<!--- START: Fax en Mobiel verwijderen in accountpagina --->
<script>
  document.addEventListener("DOMContentLoaded", function () {
    const rows = document.querySelectorAll(".table tbody tr");

    rows.forEach(function (row) {
      const headerCell = row.querySelector("th");
      if (!headerCell) return;

      const headerText = headerCell.textContent.trim();
      if (headerText === "Fax:" || headerText === "Mobiel:") {
        row.remove();
      }
    });
  });
</script>
<!--- END: Fax en Mobiel verwijderen in accountpagina --->

<!--- START: Duplicate knop zwart --->
<style>
  #duplicateLastConfiguration {
    background-color: #000000 !important;
    border-color: #000000 !important;
    color: #ffffff !important;
  }

  #duplicateLastConfiguration i {
    color: #ffffff !important;
  }

  #duplicateLastConfiguration:hover {
    background-color: #222222 !important;
    border-color: #222222 !important;
  }
</style>
<!--- END: Duplicate knop zwart --->

<!--- START: Winkelwagen navbar zwart --->
<style>
  .checkout-progressBar .nav-link {
    color: #000000 !important;
  }

  .checkout-progressBar .nav-link.active {
    background-color: #000000 !important;
    color: #ffffff !important;
  }

  .checkout-progressBar .nav-link[disabled] {
    color: #000000 !important;
    background-color: transparent !important;
    border: none !important;
    cursor: default;
  }

  .checkout-progressBar .fas,
  .checkout-progressBar .far {
    color: #000000 !important;
  }

  .checkout-progressBar .nav-link.active .fas,
  .checkout-progressBar .nav-link.active .far {
    color: #ffffff !important;
  }

  .checkout-progressBar .fas.fa-angle-right {
    color: #000000 !important;
    margin: 0 8px;
  }
</style>
<!--- END: Winkelwagen navbar zwart --->

<!--- START: Veldbenamingen --->
<script>
(function () {
  const replacements = {
    "Veld 1_1": "Veld 1",
    "Veld 2_1": "Veld 2",
    "Veld 3_1": "Veld 3",
    "Veld 4_1": "Veld 4",
    "Veld 5_1": "Veld 5"
  };

  function normalize(text) {
    return text.replace(/\s+/g, ' ').trim();
  }

  function replaceAllFields() {
    const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null, false);
    while (walker.nextNode()) {
      const node = walker.currentNode;
      const cleaned = normalize(node.nodeValue);
      if (replacements[cleaned]) {
        node.nodeValue = replacements[cleaned];
      }
    }
  }

  // Start direct bij laden
  document.addEventListener("DOMContentLoaded", () => {
    replaceAllFields();

    // Blijf observeren op veranderingen
    const observer = new MutationObserver(() => {
      replaceAllFields();
    });

    observer.observe(document.body, {
      childList: true,
      subtree: true
    });
  });
})();
</script>
<!--- END: Veldbenamingen --->

<!-- Google Tag Manager -->
<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
})(window,document,'script','dataLayer','GTM-5HJFSJ9P');</script>
<!-- End Google Tag Manager -->

<!--- START: Change je naar u in Configurator voor activeren van account --->
<script>
document.addEventListener("DOMContentLoaded", function() {
    const textNodes = document.querySelectorAll("body *:not(script):not(style)");
    textNodes.forEach(function(node) {
        if (node.childNodes.length === 1 && node.childNodes[0].nodeType === Node.TEXT_NODE) {
            const originalText = node.textContent.trim();
            const oldText = "Voordat u een bestelling kunt plaatsen, moet u eerst uw e-mailadres verifiëren. Hiervoor hebben we een bevestigingslink gestuurd naar het e-mailadres dat je hebt gebruikt om de account aan te maken.";
            const newText = "Voordat u een bestelling kunt plaatsen, moet u eerst uw e-mailadres verifiëren. Hiervoor hebben we een bevestigingslink gestuurd naar het e-mailadres dat u heeft gebruikt om de account aan te maken.";
            
            if (originalText === oldText) {
                node.textContent = newText;
            }
        }
    });
});
</script>
<!--- END: Change je naar u in Configurator voor activeren van account --->

<!-- START: Visuele waarschuwing met animatie, regelbreking en zwarte tekst -->
<style>
.ag-alert-box {
  background-color: #ffcccc !important;
  color: #000000 !important; /* zwarte tekst */
  padding: 15px 20px !important;
  border-left: 6px solid #cc0000 !important;
  border-radius: 5px !important;
  margin: 10px 0 !important;
  animation: ag-pulse-border 2s infinite !important;
  display: flex !important;
  align-items: flex-start !important;
  font-size: 15px !important;
}

.ag-alert-icon {
  margin-right: 10px !important;
  font-size: 20px !important;
  flex-shrink: 0;
  color: #cc0000 !important;
}

.ag-alert-text {
  line-height: 1.5em;
}

@keyframes ag-pulse-border {
  0% {
    box-shadow: 0 0 0 0 rgba(255, 77, 77, 0.3);
  }
  70% {
    box-shadow: 0 0 0 10px rgba(255, 77, 77, 0);
  }
  100% {
    box-shadow: 0 0 0 0 rgba(255, 77, 77, 0);
  }
}
</style>

<script>
document.addEventListener("DOMContentLoaded", function () {
  const warningLine1 = "Voordat u een bestelling kunt plaatsen, moet u eerst uw e-mailadres verifiëren.";
  const warningLine2 = "Hiervoor hebben we een bevestigingslink gestuurd naar het e-mailadres dat u heeft gebruikt om de account aan te maken.";

  // 1. Vervang binnen <label>
  const labels = document.querySelectorAll("label.form-label");
  labels.forEach(function (label) {
    const fullText = warningLine1 + " " + warningLine2;
    if (label.textContent.trim() === fullText) {
      const wrapper = document.createElement("div");
      wrapper.className = "ag-alert-box";

      const icon = document.createElement("span");
      icon.className = "ag-alert-icon";
      icon.textContent = "⚠️";

      const alertText = document.createElement("span");
      alertText.className = "ag-alert-text";
      alertText.innerHTML = warningLine1 + "<br>" + warningLine2;

      wrapper.appendChild(icon);
      wrapper.appendChild(alertText);

      label.parentNode.replaceChild(wrapper, label);
    }
  });

  // 2. Vervang binnen <div class="alert-danger">
  const alerts = document.querySelectorAll("div.alert-danger");
  const originalText = "Voordat u een bestelling kunt plaatsen, moet u eerst uw e-mailadres verifiëren. Hiervoor hebben we een bevestigingslink gestuurd naar het e-mailadres dat je hebt gebruikt om de account aan te maken.";

  alerts.forEach(function (alert) {
    const textNode = Array.from(alert.childNodes).find(node =>
      node.nodeType === Node.TEXT_NODE && node.textContent.includes("e-mailadres")
    );
    if (textNode && textNode.textContent.trim() === originalText.trim()) {
      const newBox = document.createElement("div");
      newBox.className = "ag-alert-box";

      const icon = document.createElement("span");
      icon.className = "ag-alert-icon";
      icon.textContent = "⚠️";

      const alertText = document.createElement("span");
      alertText.className = "ag-alert-text";
      alertText.innerHTML = warningLine1 + "<br>" + warningLine2;

      newBox.appendChild(icon);
      newBox.appendChild(alertText);

      alert.replaceWith(newBox);
    }
  });
});
</script>
<!-- END: Visuele waarschuwing met animatie, regelbreking en zwarte tekst -->

</head>

Aankondigingen en systeemberichten

Winkelwagen
Het toevoegen van producten aan de winkelwagen is pas mogelijk zodra u zich in de fase "Diensten -> Montage" bevindt.
Deze maatregel voorkomt dat incomplete configuraties met mogelijk ontbrekende onderdelen per ongeluk worden toegevoegd aan uw bestelling.

Materiaalsoort
De materiaalsoort ‘Aluminium’ is momenteel niet beschikbaar. Deze optie zal op een later moment worden toegevoegd.

QWindoors B.V. Configurator - Uw kozijnen, volledig op maat.

Bij QWindoors B.V. begrijpen wij dat ieder project uniek is. Daarom bieden wij onze klanten een gebruiksvriendelijke en krachtige configurator aan, waarmee u uw gewenste kozijnen volledig op maat kunt samenstellen. Overzichtelijk en volledig afgestemd op uw wensen.

Met behulp van onze configurator behoudt u als particuliere klant volledige controle over uw bestelling. Of het nu gaat om renovatie of een nieuwe situatie: onze online tool begeleidt u stapsgewijs door het configuratieproces, op een overzichtelijke en efficiënte wijze zonder onnodige vertragingen.

Wat kunt u configureren?

Onze configurator biedt een breed scala aan opties, zodat u precies datgene kunt samenstellen wat u nodig heeft:

  • Materiaalkeuze: kies tussen hoogwaardige kunststof of aluminium kozijnen
  • Kleur en afwerking: bepaal de exacte uitstraling met onze kleurenpaletten en structuuropties
  • Afmetingen: geef de exacte breedte en hoogte van elk kozijn op
  • Glasopties: selecteer het gewenste type glas, zoals HR++, veiligheidsglas, zonwerend of matglas
  • Type kozijn of raam: zoals draaikiep, vast raam, schuifpui, etc.
  • Extra opties: zoals ventilatieroosters, horren, dorpels, beslag en meer

Heldere samenvatting vóór afronding

Voordat u uw bestelling definitief plaatst, krijgt u een overzichtelijke samenvatting van alle door u gekozen specificaties. Zo kunt u alles rustig controleren voordat u doorgaat naar het afronden van de bestelling.

Gebruiksgemak en ondersteuning

Onze configurator is ontwikkeld met oog voor gebruiksgemak. Toch begrijpen wij dat u tijdens het samenstellen vragen kunt hebben of hulp nodig heeft.

Direct aan de slag

Bent u klaar om uw kozijnen samen te stellen? Klik dan hieronder om direct gebruik te maken van onze configurator en ontdek hoe eenvoudig het is om hoogwaardige maatwerkkozijnen samen te stellen, helemaal naar uw wensen. Start uw configuratie vandaag nog – op uw gemak, waar en wanneer het u uitkomt.

Servicedesk

Heeft u problemen met het gebruik van de configurator, of komt u ergens niet uit? Dan staat onze Servicedesk voor u klaar.
In het formulier selecteert u de categorie 'Technisch' en vervolgens 'Configurator'.

Ticket indienen