<section class="section">
    <div class="item item-12">
        <section class="text-item">
            <h1>Sega 200x220 no spalvas 90% spalvu standarts, visu gadu, 100% kokvilna, rozā krāsā</h1><h2>Sega izgatavota no 90% spalvu, 100% dabīgi materiāli, ideāli piemērota jebkurai guļamistabai.</h2><ul><li>Izmērs: 200x220</li><li>Pārvads: 100% kokvilna</li><li>Krāsa: ekru/rozā</li><li>Pildījums: Materiāls: 90% spalvu, 10% pūkas</li><li>Pildījuma svars: 2,1 kg</li></ul><p>Mūsu 90% spalvu sega ir izstrādājums, kas izgatavots no dabīga materiāla ar termoregulējošām īpašībām, nodrošinot ērtu nakts miegu.</p><p>Aprīkojiet savu guļamistabu un savus tuviniekus ar elegantu un ekoloģiski kvalitatīvu gultasveļu. Mūsu spalvu segas ir pildītas ar spalvu un pūkas maisījumu, kas ir viens no veselīgākajiem risinājumiem cilvēkiem, kuri guļamistabai meklē tikai dabīgus produktus. Pildījuma attiecība 9:1 nodrošina lielisku mīkstumu, siltumu un elastīgumu.</p><h2 open="" sans",="" sans-serif;"="" style="font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif; line-height: 1.3; color: rgba(0, 0, 0, 0.87); font-size: 18px; caret-color: rgba(0, 0, 0, 0.87);">Ideāli piemērots visa gada garumā</h2><p open="" sans",="" sans-serif;"="" style="font-size: 16px; color: rgba(0, 0, 0, 0.87); caret-color: rgba(0, 0, 0, 0.87);">Pen-Pol spalvu segas ir ideāls risinājums dažādiem gadalaikiem. Vasarā sega spēj patīkami atvēsināt, bet ziemā tā izdala siltumu, nodrošinot komfortu pat pie zemākās temperatūras. Mūsu piedāvājumā ir dažādu izmēru segas, piemēram, 140x200, 160x200, 180x200 un 200x220, tāpēc tās ir piemērotas jebkurai guļamistabai neatkarīgi no tās mērķa. Turklāt blīvi austie segu pārvalki neļauj pildījumam izplūst uz ārpusi, un smalkais apšuvums baltos vai zelta toņos piešķir tām eleganci, lieliski iederoties pie elegantā mājas iekārtojuma.</p><p open="" sans",="" sans-serif;"="" style="font-size: 16px; color: rgba(0, 0, 0, 0.87); caret-color: rgba(0, 0, 0, 0.87);"><br></p><h2 open="" sans",="" sans-serif;"="" style="font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif; line-height: 1.3; color: rgba(0, 0, 0, 0.87); font-size: 18px; caret-color: rgba(0, 0, 0, 0.87);">Polijas ražojums = Polijas kvalitāte</h2><p open="" sans",="" sans-serif;"="" style="font-size: 16px; color: rgba(0, 0, 0, 0.87); caret-color: rgba(0, 0, 0, 0.87);">Augstas kvalitātes gultasveļa, kas ražota Polijā, kļūs par lielisku papildinājumu jūsu ērtai guļamistabai. Pateicoties tiem, jūs iegrimtīsiet garā un atsvaidzinošā miegā, baudot ne tikai kvalitāti, bet arī vietējās ražošanas atbalstu.</p><p open="" sans",="" sans-serif;"="" style="font-size: 16px; color: rgba(0, 0, 0, 0.87); caret-color: rgba(0, 0, 0, 0.87);"><b>Kā lietot: </b>Lai spilvens kalpotu pēc iespējas ilgāk, iesakām to nodot ķīmiskajā tīrītavā, ja tas kļūst netīrs. Mēs arī lūdzam nelietot balinātājus vai citas ķīmiskās vielas, kas varētu sabojāt izstrādājumu. Mēs arī iesakām negludināt izstrādājumu, jo augsta temperatūra var sabojāt segas pārvalku un pildījumu. Ja spilvens kļūst slapjš, iesakām to saudzīgi izklāt brīvā dabā vai telpā, kur ir istabas temperatūra.</p>
        </section>
    </div>
</section><section class="section">
    <div class="item item-12">
        <section class="text-item">
            
        </section>

    </div>
</section>