La Chaise Longue, dénicheur d'idées cadeaux originales !



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/jukebox-cd-new-york-bluetooth"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_9.jpg?v=1664188492&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_9.jpg?v=1664188492&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_9.jpg?v=1664188492&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_9.jpg?v=1664188492&width=330"
								     alt="JUKEBOX CD NEW YORK BLUETOOTH"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_1.jpg?v=1664188492&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_1.jpg?v=1664188492&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_1.jpg?v=1664188492&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-zc2-012-images-31-zc2-012_1.jpg?v=1664188492&width=330"
									     alt="JUKEBOX CD NEW YORK BLUETOOTH"
									     width="1000"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1000">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -34%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203959799991">
							JUKEBOX CD NEW YORK BLUETOOTH
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203959799991"
						        data-swaction="addToWishlist" data-product-id="7203959799991"
						        data-variant-id="41450889248951"
						        data-product-url="https://www.lachaiselongue.fr/products/jukebox-cd-new-york-bluetooth"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        199,00 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        199,00 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              299,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203959799991'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.00' data-number-of-reviews='1' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.00' tabindex='0' aria-label='4.00 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> 1 review </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203959799991" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450889248951"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203959799991-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203959799991-submit title-template--21600210026833__1663680219a1536ac4-7203959799991"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203959799991" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/fauteuil-acapulco-papaye"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_1.jpg?v=1686212259&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_1.jpg?v=1686212259&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_1.jpg?v=1686212259&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_1.jpg?v=1686212259&width=330"
								     alt="FAUTEUIL ACAPULCO PAPAYE"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_9.jpg?v=1686212259&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_9.jpg?v=1686212259&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_9.jpg?v=1686212259&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1m-008-images-41-1m-008_9.jpg?v=1686212259&width=330"
									     alt="FAUTEUIL ACAPULCO PAPAYE"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -30%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204245471415">
							FAUTEUIL ACAPULCO PAPAYE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204245471415"
						        data-swaction="addToWishlist" data-product-id="7204245471415"
						        data-variant-id="41451478286519"
						        data-product-url="https://www.lachaiselongue.fr/products/fauteuil-acapulco-papaye"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        48,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        48,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              69,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204245471415'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.25' data-number-of-reviews='4' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.25' tabindex='0' aria-label='4.25 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 4 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204245471415" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451478286519"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204245471415-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204245471415-submit title-template--21600210026833__1663680219a1536ac4-7204245471415"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204245471415" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/fauteuil-acapulco-pitaya"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_1.jpg?v=1686304626&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_1.jpg?v=1686304626&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_1.jpg?v=1686304626&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_1.jpg?v=1686304626&width=330"
								     alt="FAUTEUIL ACAPULCO PITAYA"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_9.jpg?v=1686304635&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_9.jpg?v=1686304635&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_9.jpg?v=1686304635&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1m-006-images-41-1m-006_9.jpg?v=1686304635&width=330"
									     alt="FAUTEUIL ACAPULCO PITAYA"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -30%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204245438647">
							FAUTEUIL ACAPULCO PITAYA
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204245438647"
						        data-swaction="addToWishlist" data-product-id="7204245438647"
						        data-variant-id="41451478253751"
						        data-product-url="https://www.lachaiselongue.fr/products/fauteuil-acapulco-pitaya"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        48,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        48,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              69,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204245438647'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.50' data-number-of-reviews='2' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.50' tabindex='0' aria-label='4.50 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 2 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204245438647" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451478253751"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204245438647-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204245438647-submit title-template--21600210026833__1663680219a1536ac4-7204245438647"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204245438647" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/acapulco-4-pieds-blanc"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-016_CHAISE-ACAPULCO-BLANC.jpg?v=1686213013&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-016_CHAISE-ACAPULCO-BLANC.jpg?v=1686213013&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-016_CHAISE-ACAPULCO-BLANC.jpg?v=1686213013&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/42-1J-016_CHAISE-ACAPULCO-BLANC.jpg?v=1686213013&width=330"
								     alt="CHAISE ACAPULCO BLANC"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-016-images-42-1j-016_8.jpg?v=1686213013&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-016-images-42-1j-016_8.jpg?v=1686213013&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-016-images-42-1j-016_8.jpg?v=1686213013&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/42-1j-016-images-42-1j-016_8.jpg?v=1686213013&width=330"
									     alt="CHAISE ACAPULCO BLANC"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -30%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204289282231">
							CHAISE ACAPULCO BLANC
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204289282231"
						        data-swaction="addToWishlist" data-product-id="7204289282231"
						        data-variant-id="46462261428561"
						        data-product-url="https://www.lachaiselongue.fr/products/acapulco-4-pieds-blanc"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        34,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        34,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              49,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204289282231'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.67' data-number-of-reviews='3' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.67' tabindex='0' aria-label='4.67 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 3 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204289282231" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="46462261428561"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204289282231-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204289282231-submit title-template--21600210026833__1663680219a1536ac4-7204289282231"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204289282231" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/acapulco-4-pieds-noir"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-014-chaise-acapulco-noir.jpg?v=1686212794&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-014-chaise-acapulco-noir.jpg?v=1686212794&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/42-1J-014-chaise-acapulco-noir.jpg?v=1686212794&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/42-1J-014-chaise-acapulco-noir.jpg?v=1686212794&width=330"
								     alt="CHAISE ACAPULCO NOIR"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-014-images-42-1j-014_9.jpg?v=1686212794&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-014-images-42-1j-014_9.jpg?v=1686212794&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/42-1j-014-images-42-1j-014_9.jpg?v=1686212794&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/42-1j-014-images-42-1j-014_9.jpg?v=1686212794&width=330"
									     alt="CHAISE ACAPULCO NOIR"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -30%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204289216695">
							CHAISE ACAPULCO NOIR
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204289216695"
						        data-swaction="addToWishlist" data-product-id="7204289216695"
						        data-variant-id="41451577999543"
						        data-product-url="https://www.lachaiselongue.fr/products/acapulco-4-pieds-noir"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        34,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        34,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              49,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204289216695'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.25' data-number-of-reviews='4' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.25' tabindex='0' aria-label='4.25 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 4 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204289216695" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451577999543"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204289216695-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204289216695-submit title-template--21600210026833__1663680219a1536ac4-7204289216695"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204289216695" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/fauteuil-acapulco-bouche"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE.jpg?v=1688054837&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE.jpg?v=1688054837&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE.jpg?v=1688054837&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE.jpg?v=1688054837&width=330"
								     alt="FAUTEUIL ACAPULCO BOUCHE"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE-2.jpg?v=1688054837&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE-2.jpg?v=1688054837&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE-2.jpg?v=1688054837&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/43-1J-004-FAUTEUIL-ACAPULCO-BOUCHE-2.jpg?v=1688054837&width=330"
									     alt="FAUTEUIL ACAPULCO BOUCHE"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -30%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-8651270422865">
							FAUTEUIL ACAPULCO BOUCHE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_8651270422865"
						        data-swaction="addToWishlist" data-product-id="8651270422865"
						        data-variant-id="46831039021393"
						        data-product-url="https://www.lachaiselongue.fr/products/fauteuil-acapulco-bouche"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        69,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        69,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              99,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='8651270422865'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac48651270422865" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="46831039021393"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac48651270422865-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac48651270422865-submit title-template--21600210026833__1663680219a1536ac4-8651270422865"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="8651270422865" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/fauteuil-acapulco-taupe"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_1.jpg?v=1686212287&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_1.jpg?v=1686212287&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_1.jpg?v=1686212287&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_1.jpg?v=1686212287&width=330"
								     alt="FAUTEUIL ACAPULCO TAUPE"
								     width="1000"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1000">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_9.jpg?v=1686212287&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_9.jpg?v=1686212287&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_9.jpg?v=1686212287&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/35-1m-006t-images-35-1m-006t_9.jpg?v=1686212287&width=330"
									     alt="FAUTEUIL ACAPULCO TAUPE"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -20%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203962290359">
							FAUTEUIL ACAPULCO TAUPE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203962290359"
						        data-swaction="addToWishlist" data-product-id="7203962290359"
						        data-variant-id="41450891673783"
						        data-product-url="https://www.lachaiselongue.fr/products/fauteuil-acapulco-taupe"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        55,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        55,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              69,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203962290359'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203962290359" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450891673783"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203962290359-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203962290359-submit title-template--21600210026833__1663680219a1536ac4-7203962290359"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203962290359" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/fauteuil-elektra"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-1.jpg?v=1676652243&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-1.jpg?v=1676652243&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-1.jpg?v=1676652243&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-1.jpg?v=1676652243&width=330"
								     alt="LOT DE 2 FAUTEUILS ELEKTRA"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-2.jpg?v=1676652242&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-2.jpg?v=1676652242&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-2.jpg?v=1676652242&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/fauteuil-elektra-2.jpg?v=1676652242&width=330"
									     alt="LOT DE 2 FAUTEUILS ELEKTRA"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -39%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7272249327799">
							LOT DE 2 FAUTEUILS ELEKTRA
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7272249327799"
						        data-swaction="addToWishlist" data-product-id="7272249327799"
						        data-variant-id="41667071869111"
						        data-product-url="https://www.lachaiselongue.fr/products/fauteuil-elektra"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        114,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        114,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              189,00 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7272249327799'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47272249327799" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41667071869111"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47272249327799-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47272249327799-submit title-template--21600210026833__1663680219a1536ac4-7272249327799"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7272249327799" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/chaussettes-koala"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU.jpg?v=1697466981&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU.jpg?v=1697466981&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU.jpg?v=1697466981&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU.jpg?v=1697466981&width=330"
								     alt="CHAUSSETTES KOALA"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU1.jpg?v=1697466982&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU1.jpg?v=1697466982&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU1.jpg?v=1697466982&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/37-2S-008_CHAUSSETTE-KOALA-SITU1.jpg?v=1697466982&width=330"
									     alt="CHAUSSETTES KOALA"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"><span class="badge badge--bottom-left badge-on_sale color-accent-2">
                                
	                                
	                                -33%
                                
                            </span></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203971498167">
							CHAUSSETTES KOALA
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203971498167"
						        data-swaction="addToWishlist" data-product-id="7203971498167"
						        data-variant-id="41450907304119"
						        data-product-url="https://www.lachaiselongue.fr/products/chaussettes-koala"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price  price--on-sale ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              29,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203971498167'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203971498167" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450907304119"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203971498167-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203971498167-submit title-template--21600210026833__1663680219a1536ac4-7203971498167"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203971498167" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/coffret-fortune-cookies"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies.jpg?v=1677579631&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies.jpg?v=1677579631&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies.jpg?v=1677579631&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies.jpg?v=1677579631&width=330"
								     alt="COFFRET FORTUNE COOKIES"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies-1.jpg?v=1677579631&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies-1.jpg?v=1677579631&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies-1.jpg?v=1677579631&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/41-1K-039_coffret-fortune-cookies-1.jpg?v=1677579631&width=330"
									     alt="COFFRET FORTUNE COOKIES"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204239409335">
							COFFRET FORTUNE COOKIES
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204239409335"
						        data-swaction="addToWishlist" data-product-id="7204239409335"
						        data-variant-id="41451469602999"
						        data-product-url="https://www.lachaiselongue.fr/products/coffret-fortune-cookies"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              19,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204239409335'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204239409335" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451469602999"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204239409335-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204239409335-submit title-template--21600210026833__1663680219a1536ac4-7204239409335"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204239409335" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/planche-de-4-verres-a-biere"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres-1.jpg?v=1677578961&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres-1.jpg?v=1677578961&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres-1.jpg?v=1677578961&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres-1.jpg?v=1677578961&width=330"
								     alt="PLANCHE DE 4 VERRES A BIERE"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres.jpg?v=1677578961&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres.jpg?v=1677578961&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres.jpg?v=1677578961&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/40-2K-012_planche-4-bieres.jpg?v=1677578961&width=330"
									     alt="PLANCHE DE 4 VERRES A BIERE"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204211851447">
							PLANCHE DE 4 VERRES A BIERE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204211851447"
						        data-swaction="addToWishlist" data-product-id="7204211851447"
						        data-variant-id="41451393876151"
						        data-product-url="https://www.lachaiselongue.fr/products/planche-de-4-verres-a-biere"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              19,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204211851447'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204211851447" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451393876151"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204211851447-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204211851447-submit title-template--21600210026833__1663680219a1536ac4-7204211851447"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204211851447" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>

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



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/seau-a-boisson-cactus-gonflable"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/39-1q-009-images-39-1q-009_2.jpg?v=1697795163&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/39-1q-009-images-39-1q-009_2.jpg?v=1697795163&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/39-1q-009-images-39-1q-009_2.jpg?v=1697795163&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/39-1q-009-images-39-1q-009_2.jpg?v=1697795163&width=330"
								     alt="SEAU A BOISSON CACTUS GONFLABLE"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-1q-009-SEAU-A-BOISSON-CACTUS-GONFLABLE.jpg?v=1697795163&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-1q-009-SEAU-A-BOISSON-CACTUS-GONFLABLE.jpg?v=1697795163&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-1q-009-SEAU-A-BOISSON-CACTUS-GONFLABLE.jpg?v=1697795163&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/39-1q-009-SEAU-A-BOISSON-CACTUS-GONFLABLE.jpg?v=1697795163&width=330"
									     alt="SEAU A BOISSON CACTUS GONFLABLE"
									     width="600"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="600">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204133470391">
							SEAU A BOISSON CACTUS GONFLABLE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204133470391"
						        data-swaction="addToWishlist" data-product-id="7204133470391"
						        data-variant-id="41451185438903"
						        data-product-url="https://www.lachaiselongue.fr/products/seau-a-boisson-cactus-gonflable"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              19,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204133470391'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204133470391" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451185438903"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204133470391-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204133470391-submit title-template--21600210026833__1663680219a1536ac4-7204133470391"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204133470391" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/jeu-de-cartes-xxl-outdoor"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR.jpg?v=1697808433&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR.jpg?v=1697808433&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR.jpg?v=1697808433&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR.jpg?v=1697808433&width=330"
								     alt="JEU DE CARTES XXL OUTDOOR"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR-1.jpg?v=1697808433&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR-1.jpg?v=1697808433&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR-1.jpg?v=1697808433&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/38-1G-004_JEU-DE-CARTES-XXL-OUTDOOR-1.jpg?v=1697808433&width=330"
									     alt="JEU DE CARTES XXL OUTDOOR"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204022649015">
							JEU DE CARTES XXL OUTDOOR
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204022649015"
						        data-swaction="addToWishlist" data-product-id="7204022649015"
						        data-variant-id="41451014127799"
						        data-product-url="https://www.lachaiselongue.fr/products/jeu-de-cartes-xxl-outdoor"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              19,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204022649015'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204022649015" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451014127799"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204022649015-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204022649015-submit title-template--21600210026833__1663680219a1536ac4-7204022649015"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204022649015" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/pendule-de-newton"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-C2-176_pendule-de-newton_idee-cadeau.jpg?v=1674481851&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-C2-176_pendule-de-newton_idee-cadeau.jpg?v=1674481851&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-C2-176_pendule-de-newton_idee-cadeau.jpg?v=1674481851&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-C2-176_pendule-de-newton_idee-cadeau.jpg?v=1674481851&width=330"
								     alt="PENDULE DE NEWTON"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-C2-176_PENDULE-DE-NEWTON-SITU.jpg?v=1697467813&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-C2-176_PENDULE-DE-NEWTON-SITU.jpg?v=1697467813&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-C2-176_PENDULE-DE-NEWTON-SITU.jpg?v=1697467813&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/31-C2-176_PENDULE-DE-NEWTON-SITU.jpg?v=1697467813&width=330"
									     alt="PENDULE DE NEWTON"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203976839351">
							PENDULE DE NEWTON
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203976839351"
						        data-swaction="addToWishlist" data-product-id="7203976839351"
						        data-variant-id="41450916970679"
						        data-product-url="https://www.lachaiselongue.fr/products/pendule-de-newton"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203976839351'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.33' data-number-of-reviews='6' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.33' tabindex='0' aria-label='4.33 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 6 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203976839351" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450916970679"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203976839351-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203976839351-submit title-template--21600210026833__1663680219a1536ac4-7203976839351"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203976839351" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/mug-duo-mat-poussin-chaton"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_9.jpg?v=1664201395&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_9.jpg?v=1664201395&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_9.jpg?v=1664201395&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_9.jpg?v=1664201395&width=330"
								     alt="MUG DUO MAT POUSSIN CHATON"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_1.jpg?v=1664201395&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_1.jpg?v=1664201395&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_1.jpg?v=1664201395&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/40-2x-012-images-40-2x-012_1.jpg?v=1664201395&width=330"
									     alt="MUG DUO MAT POUSSIN CHATON"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204206837943">
							MUG DUO MAT POUSSIN CHATON
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204206837943"
						        data-swaction="addToWishlist" data-product-id="7204206837943"
						        data-variant-id="41451385847991"
						        data-product-url="https://www.lachaiselongue.fr/products/mug-duo-mat-poussin-chaton"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204206837943'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.00' data-number-of-reviews='4' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.00' tabindex='0' aria-label='4.00 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> 4 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204206837943" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451385847991"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204206837943-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204206837943-submit title-template--21600210026833__1663680219a1536ac4-7204206837943"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204206837943" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/coussin-chat"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/40-1Q-029_COUSSIN-CHAT-KAWAII.jpg?v=1697636326&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/40-1Q-029_COUSSIN-CHAT-KAWAII.jpg?v=1697636326&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/40-1Q-029_COUSSIN-CHAT-KAWAII.jpg?v=1697636326&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/40-1Q-029_COUSSIN-CHAT-KAWAII.jpg?v=1697636326&width=330"
								     alt="COUSSIN CHAT"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-1q-029-images-40-1q-029_9.jpg?v=1697636326&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-1q-029-images-40-1q-029_9.jpg?v=1697636326&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/40-1q-029-images-40-1q-029_9.jpg?v=1697636326&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/40-1q-029-images-40-1q-029_9.jpg?v=1697636326&width=330"
									     alt="COUSSIN CHAT"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204184031415">
							COUSSIN CHAT
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204184031415"
						        data-swaction="addToWishlist" data-product-id="7204184031415"
						        data-variant-id="41451312971959"
						        data-product-url="https://www.lachaiselongue.fr/products/coussin-chat"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        39,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        39,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204184031415'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.83' data-number-of-reviews='6' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.83' tabindex='0' aria-label='4.83 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span> </span> <span class='jdgm-prev-badge__text'> 6 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204184031415" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451312971959"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204184031415-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204184031415-submit title-template--21600210026833__1663680219a1536ac4-7204184031415"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204184031415" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/coffret-de-4-tasses-a-cafe-avec-support"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-VF-027_GLOBAL.jpg?v=1725878226&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-VF-027_GLOBAL.jpg?v=1725878226&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/38-VF-027_GLOBAL.jpg?v=1725878226&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/38-VF-027_GLOBAL.jpg?v=1725878226&width=330"
								     alt="COFFRET DE 4 TASSES A CAFE AVEC SUPPORT"
								     width="1500"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1500">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/38-vf-027-images-38-vf-027_9.jpg?v=1664194321&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/38-vf-027-images-38-vf-027_9.jpg?v=1664194321&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/38-vf-027-images-38-vf-027_9.jpg?v=1664194321&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/38-vf-027-images-38-vf-027_9.jpg?v=1664194321&width=330"
									     alt="COFFRET DE 4 TASSES A CAFE AVEC SUPPORT"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204079435959">
							COFFRET DE 4 TASSES A CAFE AVEC SUPPORT
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204079435959"
						        data-swaction="addToWishlist" data-product-id="7204079435959"
						        data-variant-id="41451110170807"
						        data-product-url="https://www.lachaiselongue.fr/products/coffret-de-4-tasses-a-cafe-avec-support"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        24,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        24,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204079435959'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204079435959" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451110170807"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204079435959-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204079435959-submit title-template--21600210026833__1663680219a1536ac4-7204079435959"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204079435959" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/bavoir-de-rasage-label-barbe"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe.jpg?v=1686745343&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe.jpg?v=1686745343&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe.jpg?v=1686745343&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe.jpg?v=1686745343&width=330"
								     alt="BAVOIR DE RASAGE LABEL BARBE"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe-1.jpg?v=1686745343&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe-1.jpg?v=1686745343&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe-1.jpg?v=1686745343&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/39-2F-039_bavoir-de-rasage-label-barbe-1.jpg?v=1686745343&width=330"
									     alt="BAVOIR DE RASAGE LABEL BARBE"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7204173185207">
							BAVOIR DE RASAGE LABEL BARBE
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7204173185207"
						        data-swaction="addToWishlist" data-product-id="7204173185207"
						        data-variant-id="41451279548599"
						        data-product-url="https://www.lachaiselongue.fr/products/bavoir-de-rasage-label-barbe"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        9,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        9,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7204173185207'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='5.00' data-number-of-reviews='1' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='5.00' tabindex='0' aria-label='5.00 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span> </span> <span class='jdgm-prev-badge__text'> 1 review </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47204173185207" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41451279548599"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47204173185207-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47204173185207-submit title-template--21600210026833__1663680219a1536ac4-7204173185207"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7204173185207" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/buzzer-non"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-1G-004_SITU05.jpg?v=1730740075&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-1G-004_SITU05.jpg?v=1730740075&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/37-1G-004_SITU05.jpg?v=1730740075&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/37-1G-004_SITU05.jpg?v=1730740075&width=330"
								     alt="BUZZER NON"
								     width="1500"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1500">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-1g-004-images-37-1g-004_9.jpg?v=1664188885&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-1g-004-images-37-1g-004_9.jpg?v=1664188885&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-1g-004-images-37-1g-004_9.jpg?v=1664188885&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/37-1g-004-images-37-1g-004_9.jpg?v=1664188885&width=330"
									     alt="BUZZER NON"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203966877879">
							BUZZER NON
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203966877879"
						        data-swaction="addToWishlist" data-product-id="7203966877879"
						        data-variant-id="41450898817207"
						        data-product-url="https://www.lachaiselongue.fr/products/buzzer-non"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        9,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        9,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203966877879'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203966877879" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450898817207"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203966877879-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203966877879-submit title-template--21600210026833__1663680219a1536ac4-7203966877879"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203966877879" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/plaid-calin"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_9.jpg?v=1664188488&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_9.jpg?v=1664188488&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_9.jpg?v=1664188488&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_9.jpg?v=1664188488&width=330"
								     alt="PLAID CALIN"
								     width="1200"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="1200">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_1.jpg?v=1664188488&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_1.jpg?v=1664188488&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_1.jpg?v=1664188488&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-ma2-001-images-31-ma2-001_1.jpg?v=1664188488&width=330"
									     alt="PLAID CALIN"
									     width="1000"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1000">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203959701687">
							PLAID CALIN
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203959701687"
						        data-swaction="addToWishlist" data-product-id="7203959701687"
						        data-variant-id="41450889150647"
						        data-product-url="https://www.lachaiselongue.fr/products/plaid-calin"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        49,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        49,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              49,99 €
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203959701687'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='4.67' data-number-of-reviews='3' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='4.67' tabindex='0' aria-label='4.67 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--half'></span> </span> <span class='jdgm-prev-badge__text'> 3 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203959701687" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450889150647"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203959701687-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203959701687-submit title-template--21600210026833__1663680219a1536ac4-7203959701687"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203959701687" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/chaussons-thermo-relaxants-blancs"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-S2-006W_chaussons-thermo-relaxant-situ.jpg?v=1697459724&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-S2-006W_chaussons-thermo-relaxant-situ.jpg?v=1697459724&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/31-S2-006W_chaussons-thermo-relaxant-situ.jpg?v=1697459724&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/31-S2-006W_chaussons-thermo-relaxant-situ.jpg?v=1697459724&width=330"
								     alt="CHAUSSONS THERMO RELAXANTS BLANCS"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-S2-006W_chaussettes-thermo-relaxant-1.jpg?v=1697459724&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-S2-006W_chaussettes-thermo-relaxant-1.jpg?v=1697459724&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/31-S2-006W_chaussettes-thermo-relaxant-1.jpg?v=1697459724&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/31-S2-006W_chaussettes-thermo-relaxant-1.jpg?v=1697459724&width=330"
									     alt="CHAUSSONS THERMO RELAXANTS BLANCS"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203959767223">
							CHAUSSONS THERMO RELAXANTS BLANCS
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203959767223"
						        data-swaction="addToWishlist" data-product-id="7203959767223"
						        data-variant-id="41450889216183"
						        data-product-url="https://www.lachaiselongue.fr/products/chaussons-thermo-relaxants-blancs"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        24,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        24,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203959767223'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='5.00' data-number-of-reviews='1' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='5.00' tabindex='0' aria-label='5.00 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span> </span> <span class='jdgm-prev-badge__text'> 1 review </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203959767223" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450889216183"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203959767223-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203959767223-submit title-template--21600210026833__1663680219a1536ac4-7203959767223"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203959767223" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/cadre-bouchon-addict"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2K-013_cadre-bouchon-addict.jpg?v=1680181671&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2K-013_cadre-bouchon-addict.jpg?v=1680181671&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2K-013_cadre-bouchon-addict.jpg?v=1680181671&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/37-2K-013_cadre-bouchon-addict.jpg?v=1680181671&width=330"
								     alt="CADRE BOUCHON ADDICT"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2k-013-images-37-2k-013_9.jpg?v=1680181669&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2k-013-images-37-2k-013_9.jpg?v=1680181669&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/products/37-2k-013-images-37-2k-013_9.jpg?v=1680181669&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/products/37-2k-013-images-37-2k-013_9.jpg?v=1680181669&width=330"
									     alt="CADRE BOUCHON ADDICT"
									     width="1200"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="1200">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203970449591">
							CADRE BOUCHON ADDICT
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203970449591"
						        data-swaction="addToWishlist" data-product-id="7203970449591"
						        data-variant-id="41450905731255"
						        data-product-url="https://www.lachaiselongue.fr/products/cadre-bouchon-addict"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203970449591'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='5.00' data-number-of-reviews='2' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='5.00' tabindex='0' aria-label='5.00 stars' role='button'> <span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span><span class='jdgm-star jdgm--on'></span> </span> <span class='jdgm-prev-badge__text'> 2 reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203970449591" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450905731255"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203970449591-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203970449591-submit title-template--21600210026833__1663680219a1536ac4-7203970449591"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203970449591" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>



<link href="//www.lachaiselongue.fr/cdn/shop/t/54/assets/component-rating.css?v=114546011930818364891713946204" rel="stylesheet" type="text/css" media="all" />
<a href="/products/coffret-bouteille-gm"
	   class="product-miniature card-wrapper product-card-wrapper underline-links-hover">
		
		<div class="card card--standard card--media
        
        
        "
		     style="--ratio-percent: 100%;">
			<div class="card__inner color-background-1 ratio"
			     style="--ratio-percent: 100%;"><div class="card__media card__media_secondary">
						<div class="media media--transparent">
							
							<picture><source media="(max-width: 330px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-pm-2.jpg?v=1697460083&width=330"><source media="(max-width: 400px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-pm-2.jpg?v=1697460083&width=400"><source media="(max-width: 550px)"
									        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-pm-2.jpg?v=1697460083&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-pm-2.jpg?v=1697460083&width=330"
								     alt="COFFRET BOUTEILLE 5 ACCESSOIRES"
								     width="3543"
								     class="motion-reduce image-primary"
								     loading="lazy"
								     fetchpriority=""
								     height="3543">
							</picture>
							
<picture><source media="(max-width: 330px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-ouvert-accessoires.jpg?v=1697460083&width=330"><source media="(max-width: 400px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-ouvert-accessoires.jpg?v=1697460083&width=400"><source media="(max-width: 550px)"
										        srcset="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-ouvert-accessoires.jpg?v=1697460083&width=550"><img src="//www.lachaiselongue.fr/cdn/shop/files/33-2K-001G_coffret-bouteille-ouvert-accessoires.jpg?v=1697460083&width=330"
									     alt="COFFRET BOUTEILLE 5 ACCESSOIRES"
									     width="3543"
									     class="motion-reduce image-secondary"
									     loading="lazy"
									     height="3543">
								</picture></div>
					</div><div class="card__content">
					<div class="card__badge top left"></div>
				</div>
			</div>
			<div class="card__content">
				
				<div class="card__information">
					<div class="card__information_wrap">
						<div class="card__heading h6" id="title-template--21600210026833__1663680219a1536ac4-7203960520887">
							COFFRET BOUTEILLE 5 ACCESSOIRES
						</div>
						<!-- Swym Wishlist Plus EPI Button-->
						<button data-with-epi="true"
						        class="swym-button swym-add-to-wishlist-view-product product_7203960520887"
						        data-swaction="addToWishlist" data-product-id="7203960520887"
						        data-variant-id="41450889937079"
						        data-product-url="https://www.lachaiselongue.fr/products/coffret-bouteille-gm"></button>
						<!-- Swym Wishlist Plus EPI Button-->
					</div><span class="caption-large light"></span>
<div class="price ">
  <div class="price__container"><div class="price__regular">
      <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
      <span class="price-item price-item--regular">
        19,99 €
      </span>
    </div>
    <div class="price__sale">
      <span class="visually-hidden visually-hidden--inline">Prix soldé</span>
      <span class="price-item price-item--sale price-item--last">
        19,99 €
      </span>
        <span class="visually-hidden visually-hidden--inline">Prix habituel</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span></div>
    
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Prix unitaire</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;par&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
    <!-- Start of Judge.me code -->
    <div style='' class='jdgm-widget jdgm-preview-badge' data-id='7203960520887'
         data-auto-install='false'>
      <div style='display:none' class='jdgm-prev-badge' data-average-rating='0.00' data-number-of-reviews='0' data-number-of-questions='0'> <span class='jdgm-prev-badge__stars' data-score='0.00' tabindex='0' aria-label='0.00 stars' role='button'> <span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span><span class='jdgm-star jdgm--off'></span> </span> <span class='jdgm-prev-badge__text'> No reviews </span> </div>
    </div>
    <!-- End of Judge.me code -->
  
</div>

				</div><div class="quick-add no-js-hidden"><product-form><form method="post" action="/cart/add" id="quick-add-template--21600210026833__1663680219a1536ac47203960520887" accept-charset="UTF-8" class="form" enctype="multipart/form-data" novalidate="novalidate" data-type="add-to-cart-form"><input type="hidden" name="form_type" value="product" /><input type="hidden" name="utf8" value="✓" /><input type="hidden" name="id"
										       value="41450889937079"
										       disabled>
										<button
												id="quick-add-template--21600210026833__1663680219a1536ac47203960520887-submit"
												type="submit"
												name="add"
												class="quick-add__submit btn btn-primary"
												aria-haspopup="dialog"
												aria-labelledby="quick-add-template--21600210026833__1663680219a1536ac47203960520887-submit title-template--21600210026833__1663680219a1536ac4-7203960520887"
												aria-live="polite"
												data-sold-out-message="true"
												
										>
                    <span>Acheter
</span>
											<span class="sold-out-message hidden">
                      Disponible en magasin
                    </span>
											<div class="loading-overlay__spinner hidden">
												<svg aria-hidden="true" focusable="false" role="presentation"
												     class="spinner" viewBox="0 0 66 66"
												     xmlns="http://www.w3.org/2000/svg">
													<circle class="path" fill="none" stroke-width="6" cx="33" cy="33"
													        r="30"></circle>
												</svg>
											</div>
										</button><input type="hidden" name="product-id" value="7203960520887" /><input type="hidden" name="section-id" value="template--21600210026833__1663680219a1536ac4" /></form></product-form></div></div>
		</div>
	</a>