Creëer
onvergetelijke
herinneringen
met
gepersonaliseerde
aankondigingen
en
uitnodigingen
van
Maison
June
Vier het leven samen met jou
Jouw geluk verdient het om in stijl aangekondigd te worden.
Van de belofte van eeuwige liefde tot de eerste herinneringen die u deelt met uw pasgeboren baby: Maison June neemt u mee in zijn werelden vol emotie en elegantie.
Op kleine papieren, groot geluk
Vers geluk, klaar om te posten
Hier
vieren
we
liefde
en
geluk.
We
schreeuwen
ze,
we
delen
ze,
op
de
best
mogelijke
manier,
die
van
jou.
Welkom thuis
Liefde in al zijn vormen
Favoriet bij het bruidspaar
Favoriet van de ouders
Notre collection capsule Mariage
Notre collection capsule Naissance


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-vierkant-basisfotografie"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333868007662"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333868007662 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333868007662">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010093-KR0-RV-FP_0.jpg?v=1712360494&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8333868007662 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8333868007662"
							data-variant-id="44930523496686"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-vierkant-basisfotografie"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Vierkant
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333868007662"
							>

							
								Basisfotografie
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="336" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,21 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,21 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-portret-petite-pousse"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8316964929774"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8316964929774 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8316964929774">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010079-RN1-RV-FP_0.jpg?v=1713163939&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8316964929774 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8316964929774"
							data-variant-id="44878529724654"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-portret-petite-pousse"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Portret
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8316964929774"
							>

							
								Petite Pousse
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-landschap-biscuitranden-bijt-me-met-kussen"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8329145024750"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8329145024750 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8329145024750">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010104-RB1-RV-FP_0.jpg?v=1713200755&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8329145024750 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8329145024750"
							data-variant-id="44914466324718"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-landschap-biscuitranden-bijt-me-met-kussen"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Landschap, biscuitranden
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8329145024750"
							>

							
								Bijt me met kussen
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-fotocabine-bladwijzer-jungle-geluk"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8309279981806"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8309279981806 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8309279981806">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010073-FP2-RV-FP_0.jpg?v=1713162394&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8309279981806 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8309279981806"
							data-variant-id="44852697596142"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-fotocabine-bladwijzer-jungle-geluk"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Fotocabine bladwijzer
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8309279981806"
							>

							
								Jungle Geluk
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="416" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,39 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,39 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-dubbel-vierluik-meervoudige-foto-vierkante-jongen"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290369765614"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290369765614 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290369765614">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_008198-DQ1-RV-FP_0.jpg?v=1713163230&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8290369765614 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8290369765614"
							data-variant-id="44799948161262"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-dubbel-vierluik-meervoudige-foto-vierkante-jongen"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Dubbel vierluik
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290369765614"
							>

							
								Meervoudige foto Vierkante jongen
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="304" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,42 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,42 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-kleine-boog-een-ster-is-geboren"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333615956206"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333615956206 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333615956206">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010362-HH2-RV-FP_0.jpg?v=1712713450&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8333615956206 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8333615956206"
							data-variant-id="44926623842542"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-kleine-boog-een-ster-is-geboren"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Kleine boog
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8333615956206"
							>

							
								een ster is geboren
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="315" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,10 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,10 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-vierkant-jonge-loot-2-fotos"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8265301885166"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8265301885166 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8265301885166">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_008158-KR0-RV-FP_0.jpg?v=1713163543&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8265301885166 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8265301885166"
							data-variant-id="44729685508334"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-vierkant-jonge-loot-2-fotos"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"><span
										class="badge badge--primary badge--dorure">Dorure</span></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Vierkant
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8265301885166"
							>

							
								Jonge loot, 2 foto's
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="394" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,53 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,53 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/faire-part-naissance-carre-les-jouets-de-bebe"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290317172974"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290317172974 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290317172974">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 6
	}
'
									 data-other-slides="["\u003cdiv class=\"swiper-slide grid__item card__slide\"\u003e\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"media media--transparent media--hover-effect\"\u003e\t\t\t\t\t\t\t\t\t\t\t\t\u003cimg\t\t\t\t\t\t\t\t\t\t\t\t\tsrcset=\"\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=165 165w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=360 360w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=533 533w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=600 600w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=720 720w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=800 800w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=850 850w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=940 940w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=1066 1066w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995 2000w\t\t\t\t\t\t\t\t\t\t\t\t\"\t\t\t\t\t\t\t\t\t\t\t\t\tsrc=\"\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_1.jpg?v=1713195995\u0026width=1066\"\t\t\t\t\t\t\t\t\t\t\t\t\tsizes=\"(min-width: 990px) calc((100vw - 40px) \/ 3), (min-width: 750px) calc((100vw - 25px) \/ 2), calc((100vw - 25px) \/ 2)\"\t\t\t\t\t\t\t\t\t\t\t\t\talt=\"fr\"\t\t\t\t\t\t\t\t\t\t\t\t\tclass=\"motion-reduce\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tloading=\"lazy\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\twidth=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\theight=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\u003e\t\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"swiper-slide grid__item card__slide\"\u003e\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"media media--transparent media--hover-effect\"\u003e\t\t\t\t\t\t\t\t\t\t\t\t\u003cimg\t\t\t\t\t\t\t\t\t\t\t\t\tsrcset=\"\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=165 165w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=360 360w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=533 533w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=600 600w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=720 720w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=800 800w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=850 850w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=940 940w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=1066 1066w,\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994 2000w\t\t\t\t\t\t\t\t\t\t\t\t\"\t\t\t\t\t\t\t\t\t\t\t\t\tsrc=\"\/\/maisonjune.nl\/cdn\/shop\/files\/FR_009968-KR0-RV-FP_2.jpg?v=1713195994\u0026width=1066\"\t\t\t\t\t\t\t\t\t\t\t\t\tsizes=\"(min-width: 990px) calc((100vw - 40px) \/ 3), (min-width: 750px) calc((100vw - 25px) \/ 2), calc((100vw - 25px) \/ 2)\"\t\t\t\t\t\t\t\t\t\t\t\t\talt=\"fr\"\t\t\t\t\t\t\t\t\t\t\t\t\tclass=\"motion-reduce\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tloading=\"lazy\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\twidth=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\theight=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\u003e\t\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"swiper-slide grid__item card__slide\"\u003e\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"media media--transparent media--hover-effect\"\u003e\t\t\t\t\t\t\t\t\t\t\t\t\u003cimg\t\t\t\t\t\t\t\t\t\t\t\t\tsrcset=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=165 165w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=360 360w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=533 533w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=600 600w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=720 720w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=800 800w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=850 850w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=940 940w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=1066 1066w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994 2000w\t\t\t\t\t\t\t\t\t\t\t\t\"\t\t\t\t\t\t\t\t\t\t\t\t\tsrc=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_0.jpg?v=1713195994\u0026width=1066\"\t\t\t\t\t\t\t\t\t\t\t\t\tsizes=\"(min-width: 990px) calc((100vw - 40px) \/ 3), (min-width: 750px) calc((100vw - 25px) \/ 2), calc((100vw - 25px) \/ 2)\"\t\t\t\t\t\t\t\t\t\t\t\t\talt=\"de\"\t\t\t\t\t\t\t\t\t\t\t\t\tclass=\"motion-reduce\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tloading=\"lazy\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\twidth=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\theight=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\u003e\t\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"swiper-slide grid__item card__slide\"\u003e\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"media media--transparent media--hover-effect\"\u003e\t\t\t\t\t\t\t\t\t\t\t\t\u003cimg\t\t\t\t\t\t\t\t\t\t\t\t\tsrcset=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=165 165w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=360 360w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=533 533w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=600 600w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=720 720w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=800 800w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=850 850w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=940 940w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=1066 1066w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996 2000w\t\t\t\t\t\t\t\t\t\t\t\t\"\t\t\t\t\t\t\t\t\t\t\t\t\tsrc=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_1.jpg?v=1713195996\u0026width=1066\"\t\t\t\t\t\t\t\t\t\t\t\t\tsizes=\"(min-width: 990px) calc((100vw - 40px) \/ 3), (min-width: 750px) calc((100vw - 25px) \/ 2), calc((100vw - 25px) \/ 2)\"\t\t\t\t\t\t\t\t\t\t\t\t\talt=\"de\"\t\t\t\t\t\t\t\t\t\t\t\t\tclass=\"motion-reduce\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tloading=\"lazy\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\twidth=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\theight=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\u003e\t\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"swiper-slide grid__item card__slide\"\u003e\t\t\t\t\t\t\t\t\t\t\t\u003cdiv class=\"media media--transparent media--hover-effect\"\u003e\t\t\t\t\t\t\t\t\t\t\t\t\u003cimg\t\t\t\t\t\t\t\t\t\t\t\t\tsrcset=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=165 165w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=360 360w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=533 533w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=600 600w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=720 720w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=800 800w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=850 850w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=940 940w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=1066 1066w,\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995 2000w\t\t\t\t\t\t\t\t\t\t\t\t\"\t\t\t\t\t\t\t\t\t\t\t\t\tsrc=\"\/\/maisonjune.nl\/cdn\/shop\/files\/DE_009968-KR0-RV-FP_2.jpg?v=1713195995\u0026width=1066\"\t\t\t\t\t\t\t\t\t\t\t\t\tsizes=\"(min-width: 990px) calc((100vw - 40px) \/ 3), (min-width: 750px) calc((100vw - 25px) \/ 2), calc((100vw - 25px) \/ 2)\"\t\t\t\t\t\t\t\t\t\t\t\t\talt=\"de\"\t\t\t\t\t\t\t\t\t\t\t\t\tclass=\"motion-reduce\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tloading=\"lazy\"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\twidth=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\theight=\"2000\"\t\t\t\t\t\t\t\t\t\t\t\t\u003e\t\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e\t\t\t\t\t\t\t\t\t\t\u003c\/div\u003e"]">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=165 165w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=360 360w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=533 533w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=600 600w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=720 720w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=800 800w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=850 850w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=940 940w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=1066 1066w,//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/FR_009968-KR0-RV-FP_0.jpg?v=1713195995&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="fr"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8290317172974 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8290317172974"
							data-variant-id="44799676219630"
							data-product-url="https://maisonjune.fr/products/faire-part-naissance-carre-les-jouets-de-bebe"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"><span
										class="badge badge--primary badge--dorure">Dorure</span></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Aankondiging
								
									Geboorte
								
								
									Vierkant
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8290317172974"
							>

							
								Les jouets de bébé
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="394" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,53 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,53 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-1"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353460912366"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353460912366 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353460912366">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010599-RN2-RV-FP_0.jpg?v=1712998968&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353460912366 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353460912366"
							data-variant-id="45007218606318"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-1"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portrait
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353460912366"
							>

							
								We zeggen ja.
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-hallo-liefde-roze"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353448558830"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353448558830 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353448558830">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_021181-RN2-RV-FP_0.jpg?v=1712676961&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353448558830 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353448558830"
							data-variant-id="45007203139822"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-hallo-liefde-roze"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portrait
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353448558830"
							>

							
								Hallo liefde roze.
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-heerlijke-dag"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352820429038"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352820429038 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352820429038">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_021179-RN2-RV-FP_0.jpg?v=1712661109&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8352820429038 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8352820429038"
							data-variant-id="45005473972462"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-heerlijke-dag"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portrait
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352820429038"
							>

							
								Heerlijke dag
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336110616814"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336110616814 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336110616814">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010559-RN2-RV-FP_0.jpg?v=1712881010&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8336110616814 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8336110616814"
							data-variant-id="44943012692206"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portret
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336110616814"
							>

							
								Gele zonneschijn
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-liefde-in-jaren-tachtig-rood"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352806928622"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352806928622 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352806928622">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_021176-RN2-RV-FP_0.jpg?v=1712660680&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8352806928622 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8352806928622"
							data-variant-id="45005399621870"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-liefde-in-jaren-tachtig-rood"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portrait
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352806928622"
							>

							
								Liefde in jaren tachtig rood
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-ovaal-1"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353443807470"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353443807470 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353443807470">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010562-GU2-RV-FP_0.jpg?v=1712881019&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353443807470 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353443807470"
							data-variant-id="45007195373806"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-ovaal-1"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Ovaal
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353443807470"
							>

							
								Gele grafische
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="336" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,21 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,21 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-tijd-van-liefde"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352957628654"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352957628654 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352957628654">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_021178-RN2-RV-FP_0.jpg?v=1712664751&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8352957628654 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8352957628654"
							data-variant-id="45005950058734"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-tijd-van-liefde"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portrait
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8352957628654"
							>

							
								Tijd van liefde
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-huwelijk-portret-de-verrassing"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353171308782"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353171308782 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353171308782">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_021175-RN1-RV-FP_0.jpg?v=1712669464&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353171308782 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353171308782"
							data-variant-id="45006663844078"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-huwelijk-portret-de-verrassing"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Huwelijk
								
								
									Portret
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353171308782"
							>

							
								De verrassing
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-kleine-boog-nieuw-vichy-rood"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353668956398"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353668956398 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353668956398">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010598-HH2-RV-FP_0.jpg?v=1712998320&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353668956398 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353668956398"
							data-variant-id="45007610904814"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-kleine-boog-nieuw-vichy-rood"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Kleine boog
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353668956398"
							>

							
								Nieuw Vichy Rood
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="315" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,10 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,10 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-ovaal-klein-wonder"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353608302830"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353608302830 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353608302830">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010588-GU2-RV-FP_0.jpg?v=1712998030&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353608302830 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353608302830"
							data-variant-id="45007478620398"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-ovaal-klein-wonder"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Ovaal
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353608302830"
							>

							
								Klein wonder.
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="336" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,21 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,21 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-kleine-boog-geel-paars"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353593524462"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353593524462 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353593524462">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010568-HH2-RV-FP_0.jpg?v=1712901710&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353593524462 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353593524462"
							data-variant-id="45007443034350"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-kleine-boog-geel-paars"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Kleine boog
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353593524462"
							>

							
								Geel & Paars
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="315" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,10 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,10 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-portret-afgeronde-randen-klein-rood-hart"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247685358"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247685358 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247685358">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010593-RR2-RV-FP_0.jpg?v=1712998070&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8336247685358 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8336247685358"
							data-variant-id="44945244684526"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-portret-afgeronde-randen-klein-rood-hart"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Portret, afgeronde randen
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247685358"
							>

							
								Klein Rood Hart
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-kleine-boog-nieuwe-vichy-lavendel"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353660403950"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353660403950 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353660403950">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010596-HH2-RV-FP_0.jpg?v=1712998313&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353660403950 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353660403950"
							data-variant-id="45007586361582"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-kleine-boog-nieuwe-vichy-lavendel"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Kleine boog
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353660403950"
							>

							
								Nieuwe Vichy Lavendel
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="315" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,10 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,10 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-portret-afgeronde-randen-klein-hart-lavendel"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247423214"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247423214 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247423214">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010592-RR2-RV-FP_0.jpg?v=1712998058&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8336247423214 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8336247423214"
							data-variant-id="44945234952430"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-portret-afgeronde-randen-klein-hart-lavendel"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Portret, afgeronde randen
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8336247423214"
							>

							
								Klein Hart Lavendel
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="365" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,31 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,31 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-kleine-boog-verse-roomijs-roos"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353631469806"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353631469806 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353631469806">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="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">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010594-HH2-RV-FP_0.jpg?v=1712998080&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353631469806 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353631469806"
							data-variant-id="45007523905774"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-kleine-boog-verse-roomijs-roos"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Kleine boog
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353631469806"
							>

							
								Verse Roomijs Roos
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="315" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,10 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,10 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>


<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-rating.css?v=157771854592137137841699343721" rel="stylesheet" type="text/css" media="all" />
<link href="//maisonjune.nl/cdn/shop/t/3/assets/component-price.css?v=65402837579211014041699343715" rel="stylesheet" type="text/css" media="all" />


<a
		href="/products/uitnodigingskaart-geboorte-ovaal-1"
		id="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353618559214"
		class="full-unstyled-link card-wrapper-link"
		aria-labelledby="CardLink-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353618559214 Badge-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353618559214">
		<div class="card-wrapper product-miniature product-card-wrapper underline-links-hover">
			<div
				class="
					card
					card--standard
					 card--media
					
					
					
					
					
				  "
				style="--ratio-percent: 100%;"
			>
				<div
					class="card__inner color-background-1 gradient ratio"
					style="--ratio-percent: 100%;"
				>

					<slider-card>
						
							
							<div
								class="card__media">
								<div id="Swiper-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331" class="swiper" data-options='
	{
	"slideInView": "auto",
	"slidesToMove": 1,
	"loop": false,
	"autoplay": false,
	"effect": "slide",
	"speed": 500,
	"spaceBetween": 10,
	"sliderLength": 9
	}
'
									 data-other-slides="WyJcdTAwM2NkaXYgY2xhc3M9XCJzd2lwZXItc2xpZGUgZ3JpZF9faXRlbSBjYXJkX19zbGlkZVwiXHUwMDNlXHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx1MDAzY2RpdiBjbGFzcz1cIm1lZGlhIG1lZGlhLS10cmFuc3BhcmVudCBtZWRpYS0taG92ZXItZWZmZWN0XCJcdTAwM2VcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdTAwM2NpbWdcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdHNyY3NldD1cIlwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTE2NSAxNjV3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTM2MCAzNjB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTUzMyA1MzN3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTYwMCA2MDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTcyMCA3MjB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTgwMCA4MDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTg1MCA4NTB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTk0MCA5NDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTEwNjYgMTA2NncsXC9cL21haXNvbmp1bmUubmxcL2Nkblwvc2hvcFwvZmlsZXNcL05MXzAxMDU5MC1HVTItUlYtRlBfMS5qcGc/dj0xNzEyOTk4MDQyIDIwMDB3XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdHNyYz1cIlwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzEuanBnP3Y9MTcxMjk5ODA0Mlx1MDAyNndpZHRoPTEwNjZcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0c2l6ZXM9XCIobWluLXdpZHRoOiA5OTBweCkgY2FsYygoMTAwdncgLSA0MHB4KSBcLyAzKSwgKG1pbi13aWR0aDogNzUwcHgpIGNhbGMoKDEwMHZ3IC0gMjVweCkgXC8gMiksIGNhbGMoKDEwMHZ3IC0gMjVweCkgXC8gMilcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0YWx0PVwibmxcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0Y2xhc3M9XCJtb3Rpb24tcmVkdWNlXCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRsb2FkaW5nPVwibGF6eVwiXHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0d2lkdGg9XCIyMDAwXCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdGhlaWdodD1cIjIwMDBcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx1MDAzZVx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdTAwM2NcL2Rpdlx1MDAzZVx0XHRcdFx0XHRcdFx0XHRcdFx0XHUwMDNjXC9kaXZcdTAwM2VcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdTAwM2NkaXYgY2xhc3M9XCJzd2lwZXItc2xpZGUgZ3JpZF9faXRlbSBjYXJkX19zbGlkZVwiXHUwMDNlXHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx1MDAzY2RpdiBjbGFzcz1cIm1lZGlhIG1lZGlhLS10cmFuc3BhcmVudCBtZWRpYS0taG92ZXItZWZmZWN0XCJcdTAwM2VcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdTAwM2NpbWdcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdHNyY3NldD1cIlwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTE2NSAxNjV3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTM2MCAzNjB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTUzMyA1MzN3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTYwMCA2MDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTcyMCA3MjB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTgwMCA4MDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTg1MCA4NTB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTk0MCA5NDB3LFwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTEwNjYgMTA2NncsXC9cL21haXNvbmp1bmUubmxcL2Nkblwvc2hvcFwvZmlsZXNcL05MXzAxMDU5MC1HVTItUlYtRlBfMi5qcGc/dj0xNzEyOTk4MDQzIDIwMDB3XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdHNyYz1cIlwvXC9tYWlzb25qdW5lLm5sXC9jZG5cL3Nob3BcL2ZpbGVzXC9OTF8wMTA1OTAtR1UyLVJWLUZQXzIuanBnP3Y9MTcxMjk5ODA0M1x1MDAyNndpZHRoPTEwNjZcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0c2l6ZXM9XCIobWluLXdpZHRoOiA5OTBweCkgY2FsYygoMTAwdncgLSA0MHB4KSBcLyAzKSwgKG1pbi13aWR0aDogNzUwcHgpIGNhbGMoKDEwMHZ3IC0gMjVweCkgXC8gMiksIGNhbGMoKDEwMHZ3IC0gMjVweCkgXC8gMilcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0YWx0PVwibmxcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0Y2xhc3M9XCJtb3Rpb24tcmVkdWNlXCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRsb2FkaW5nPVwibGF6eVwiXHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx0d2lkdGg9XCIyMDAwXCJcdFx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdGhlaWdodD1cIjIwMDBcIlx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdFx1MDAzZVx0XHRcdFx0XHRcdFx0XHRcdFx0XHRcdTAwM2NcL2Rpdlx1MDAzZVx0XHRcdFx0XHRcdFx0XHRcdFx0XHUwMDNjXC9kaXZcdTAwM2UiXQ==">
									<div class="swiper-wrapper grid-card grid grid--1-col">
										<div class="swiper-slide grid__item card__slide">
											<div class="media media--transparent media--hover-effect">
												<img
													srcset="//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=165 165w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=360 360w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=533 533w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=600 600w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=720 720w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=800 800w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=850 850w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=940 940w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=1066 1066w,//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043 2000w
													"
													src="//maisonjune.nl/cdn/shop/files/NL_010590-GU2-RV-FP_0.jpg?v=1712998043&width=1066"
													sizes="(min-width: 990px) calc((100vw - 40px) / 3), (min-width: 750px) calc((100vw - 25px) / 2), calc((100vw - 25px) / 2)"
													alt="nl"
													class="motion-reduce"
													
														loading="lazy"
													
													
													width="2000"
													height="2000"
												>
											</div>
										</div>
									</div>
								</div>
							</div><button
							class="swym-button swym-add-to-wishlist-view-product card__swym product_8353618559214 product__thumbnails-mobile swym__product-card"
							data-with-epi="true"
							data-swaction="addToWishlist"
							data-product-id="8353618559214"
							data-variant-id="45007500673262"
							data-product-url="https://maisonjune.fr/products/uitnodigingskaart-geboorte-ovaal-1"
						>
						</button>
						<div class="card__content">
							<div class="card__badge top left"></div>
						</div>

						
							<div class="swiper-pagination card__pagination"></div>

							<div class="card__navigation--next"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
							<div class="card__navigation--prev"><svg aria-hidden="true" focusable="false" class="icon icon-caret" viewBox="0 0 10 6">
	<path stroke-width="1" fill-rule="evenodd" clip-rule="evenodd"
		  d="M9.354.646a.5.5 0 00-.708 0L5 4.293 1.354.646a.5.5 0 00-.708.708l4 4a.5.5 0 00.708 0l4-4a.5.5 0 000-.708z"
		  fill="currentColor" stroke="currentColor">
</svg>
</div>
						
					</slider-card>
				</div>
				<div class="card__content">
					<div class="card__information">
						
							<div class="card__type">
								Uitnodigingskaart
								
									Geboorte
								
								
									Ovaal
								
							</div>
						
						<h3
							class="card__heading h5"
						
							id="title-template--17003519049966__26508ca5-17a3-4b3a-bd85-5bd396e32331-8353618559214"
							>

							
								Klein hartje
							
						</h3>
						<div class="card-information"><span class="caption-large light"></span>
							
							
<div
  class="
    price "
>
  <div class="price__container"><div class="price__regular" data-price="336" data-currency="€" >
      <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
      <span class="price-item price-item--regular">
        Vanaf 1,21 €
      </span>
    </div>
    <div class="price__sale">
        <span class="visually-hidden visually-hidden--inline">Normale prijs</span>
        <span>
          <s class="price-item price-item--regular">
            
              
            
          </s>
        </span><span class="visually-hidden visually-hidden--inline">Aanbiedingsprijs</span>
      <span class="price-item price-item--sale price-item--last">
        Vanaf 1,21 €
      </span>
    </div>
    <small class="unit-price caption hidden">
      <span class="visually-hidden">Eenheidsprijs</span>
      <span class="price-item price-item--last">
        <span></span>
        <span aria-hidden="true">/</span>
        <span class="visually-hidden">&nbsp;per&nbsp;</span>
        <span>
        </span>
      </span>
    </small>
  </div>
  
</div>

						</div>
					</div><div class="quick-add no-js-hidden">
							<div
								class="quick-add__submit button button--full-width button--primary"
							>
								Ja, ik wil!
</div>
						</div></div>
			</div>
		</div>
	</a>
We are family!
Woord aan onze ambassadeurs
Toekomstig of pasgetrouwd, gelukkige ouders, wij werken aan betekenisvolle samenwerkingen, met mensen die onze waarden delen en jou inspireren.
Love story
Marina Kaye & Grégory, ik vind het geweldig met een hoofdletter L
4,7 (1685)
Beter dan woorden,
uw waardevolle meningen.
{"alt":null,"id":32551496483054,"position":null,"preview_image":{"aspect_ratio":0.992,"height":726,"width":720,"src":"\/\/maisonjune.nl\/cdn\/shop\/files\/preview_images\/dce01bdeeb1948d9a1dc3820a5c1d7d0.thumbnail.0000000000.jpg?v=1700753408"},"aspect_ratio":0.992,"duration":76000,"media_type":"video","sources":[{"format":"mp4","height":480,"mime_type":"video\/mp4","url":"https:\/\/cdn.shopify.com\/videos\/c\/vp\/dce01bdeeb1948d9a1dc3820a5c1d7d0\/dce01bdeeb1948d9a1dc3820a5c1d7d0.SD-480p-0.9Mbps-21083946.mp4","width":476},{"format":"mp4","height":720,"mime_type":"video\/mp4","url":"https:\/\/cdn.shopify.com\/videos\/c\/vp\/dce01bdeeb1948d9a1dc3820a5c1d7d0\/dce01bdeeb1948d9a1dc3820a5c1d7d0.HD-720p-1.6Mbps-21083946.mp4","width":714},{"format":"m3u8","height":720,"mime_type":"application\/x-mpegURL","url":"https:\/\/cdn.shopify.com\/videos\/c\/vp\/dce01bdeeb1948d9a1dc3820a5c1d7d0\/dce01bdeeb1948d9a1dc3820a5c1d7d0.m3u8","width":714}]}
De mening van
Marion
Een geweldig resultaat, consistent met wat we hadden gepersonaliseerd. Topverpakking met leuke attentie in de verpakking. Ik zal niet aarzelen om het aan te bevelen voor de toekomst.
Het Maison June mag'
Maison June is
@Maisonjune.fr
Doe met ons mee
Geluk wordt geschreven en gelezen
Nieuws, goede deals, verrassingen... wat als we je alles vertelden?
Verrassing #1: Check snel je mailbox!
Uw trouwpapeterie:
Dompel jezelf onder in de betoverende wereld van bruiloften met ons verfijnde briefpapier. Zeg ja in stijl met ons complete assortiment aanpasbaar briefpapier. Elke aankondiging, uitnodigingskaart, massaboekje, menu, bedankkaart... geeft de essentie van jullie liefde weer. Of uw dag nu romantisch, verfijnd of eenvoudig is, onze creaties maken elk moment onvergetelijk en uniek. Laat ons u vergezellen op dit avontuur waarbij elk woord uw verhaal weerspiegelt. Omdat jullie huwelijk veel verder gaat dan alleen het vieren, is het de start van een nieuw leven samen.
Uw geboortepapaterie:
Kondig de komst van jouw mini-jij aan met zachtheid, tederheid en poëzie. Van vrolijke ontwerpen tot ontroerende bedankkaartjes, elk stuk is ontworpen om dit magische moment te vieren. Laat ons u begeleiden bij het creëren van dierbare herinneringen die een leven lang meegaan. Met onze charmante ontwerpen en nauwgezette aandacht voor detail wordt elke stap van deze reis nog specialer. De komst van een baby is veel meer dan een gebeurtenis, het is het begin van eindeloze liefde, en we zijn vereerd om samen met jou deel uit te maken van dit prachtige avontuur.
Andere evenementen en fotocadeaus
Vier alle speciale momenten in het leven met onze aanpasbare briefpapier en cadeaus. Van doopfeesten tot verjaardagen tot communies, elke gebeurtenis verdient bijzondere aandacht. Unieke ontwerpen en fotoobjecten, perfect voor alle gelegenheden. Laat ons u helpen onvergetelijke herinneringen te creëren voor elke fase van uw leven. Met onze nauwgezette aandacht voor detail en persoonlijke benadering wordt elk moment een authentieke en onvergetelijke ervaring voor u en uw dierbaren.