/** Shopify CDN: Minification failed

Line 308:0 Unexpected "}"

**/
/* Gallery screen — blocks/product_gallery-screen.liquid, docs/gallery-screens.md.
   Every value comes from a --gs-* variable the block sets inline; the
   fallbacks match the schema defaults. */

.gallery-screen {
  position: relative;
  box-sizing: border-box;
  display: flex;
  flex-direction: column;
  width: 100%;
  overflow: hidden;
  color: rgb(var(--color-foreground));
  isolation: isolate;
}
/* The theme's color-scheme classes (.color-background-1 …) also paint
   background-color on the element itself, which made "Transparent" and the
   opacity slider look solid. The scheme only sets colors here; the background
   is drawn by ::before below. */
.gallery-screen[class*="color-"],
.gallery-screen-layout[class*="color-"] { background-color: transparent; }

/* New slide: sized by the gallery like a photo. The slide carries the same
   .product-media-container > .product__media.media box as a gallery image
   (snippets/gallery-screen-unit.liquid), so the Gallery block's Media aspect
   ratio, the theme's Media fit and Constrain to viewport size it, and the
   screen fills that box. Content that doesn't fit is cut off. */
.gallery-screen-media.media { background: transparent; }
/* The theme's `.media > :not(.zoom):not(.deferred-media__poster-button)`
   (display: block, absolute fill — what makes a photo fill its box) is
   0,3,0: this has to be more specific to keep the screen a flex column. */
.media.gallery-screen-media > .gallery-screen.gallery-screen--slide {
  position: absolute;
  inset: 0;
  display: flex;
}

/* Over an existing image: fills the image's box and rides with its slide. */
.gallery-screen--overlay {
  position: absolute;
  inset: var(--gs-overlay-inset, 0px);
  width: auto;
  z-index: 3;
  pointer-events: none;
}
.gallery-screen--overlay .gallery-screen__content > * { pointer-events: auto; }
/* The gallery's pagination drawn over the image (Mobile pagination: dots
   overlay / editorial bar) has no z-index, so a screen (z-index 3) covered it.
   Same z-index, later in the DOM = painted above the screen; media badges
   (z-index 4) stay above both, as before. */
media-gallery:has(.gallery-screen) .slider-mobile-buttons-overlay { z-index: 4; }
/* …and screens keep clear of it: --gs-pager-h is the bar's reach into the
   image, measured by assets/gallery-screen.js (0 when hidden / on desktop).
   Slides and overlays both run to the image's bottom edge (backgrounds and
   edge-to-edge blocks reach it) and pad their blocks up by the bar instead.
   Overlays used to end above the bar, which left a strip of the image showing:
   the bar's box includes the editorial segments' tap padding, not just the line. */
.gallery-screen .gallery-screen-layout__content { padding-bottom: calc(var(--gsl-pad-v, 26px) + var(--gs-pager-h, 0px)); }

.gallery-screen .media-background { z-index: -2; }
.gallery-screen__content {
  position: relative;
  display: flex;
  flex-direction: column;
  flex: 1 1 auto;
  min-height: 0;
  gap: 0;
  padding: 0;
  width: 100%;
  box-sizing: border-box;
}
.gallery-screen__content > * { margin-block: 0; max-width: 100%; }
/* "Disable all margins of children blocks" (default on, like the Container's):
   blocks' own top / bottom margins would add to "Space between blocks" (a gap
   of 0 still showed space). !important beats the blocks' own margin rules, as in
   blocks/container.liquid; "Last block at the bottom" (more specific) still wins. */
.gallery-screen-layout--no-child-margins > .gallery-screen-layout__content > * { margin-top: 0 !important; margin-bottom: 0 !important; }


/* Show when (sold out / in stock): off for the selected variant (assets/gallery-screen.js). */
.gs-when-off { display: none !important; }

@media screen and (max-width: 749px) {
  .gallery-screen-slide--desktop { display: none !important; }
  .gallery-screen-layer--desktop { display: none !important; }
}
@media screen and (min-width: 750px) {
  .gallery-screen-slide--mobile { display: none !important; }
  .gallery-screen-layer--mobile { display: none !important; }
}

/* Thumbnail for a screen with no thumbnail image: its label on a tile. */
.gallery-screen-thumb {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 100%;
  aspect-ratio: 1 / 1;
  padding: 4px;
  box-sizing: border-box;
  background: rgb(var(--color-foreground), 0.06);
  color: rgb(var(--color-foreground));
  font-size: 1.1rem;
  font-weight: 600;
  line-height: 1.2;
  text-align: center;
  overflow: hidden;
}
.gallery-screen-thumb img { width: 100%; height: 100%; object-fit: cover; }

/* Entrance — per Godlike screen layout (its Animation settings). The script
   toggles .is-shown on the screen as it comes into view; a layout with "Play
   every time…" off gets .is-played the first time and stays shown. The blocks
   inside the layout animate, staggered; the layout's own background / glass
   stays put. */
.gallery-screen-layout[class*="gallery-screen-layout--anim-"] > .gallery-screen-layout__content > * {
  transition: opacity var(--gsl-anim-ms, 500ms) ease, transform var(--gsl-anim-ms, 500ms) cubic-bezier(0.16, 1, 0.3, 1);
}
.gallery-screen:not(.is-shown) .gallery-screen-layout--anim-fade:not(.is-played) > .gallery-screen-layout__content > * { opacity: 0; }
.gallery-screen:not(.is-shown) .gallery-screen-layout--anim-rise:not(.is-played) > .gallery-screen-layout__content > * { opacity: 0; transform: translate(var(--gsl-enter-x, 0px), var(--gsl-enter-y, 24px)); }
.gallery-screen:not(.is-shown) .gallery-screen-layout--anim-zoom:not(.is-played) > .gallery-screen-layout__content > * { opacity: 0; transform: scale(var(--gsl-enter-scale, 0.92)); }
/* Glass inside a block (snippets/glass-filter.liquid writes backdrop-filter
   inline). Two browser rules decide this:
   - an ancestor with opacity < 1 becomes the blur's backdrop root, so a fading
     wrapper shows the glass see-through until the fade ends;
   - moving a blurred panel re-renders the blur every frame, which stutters.
   So a block that is or holds glass gets no fade and no offset of its own, and
   the glass inside fades in place (its own opacity doesn't break its blur).
   Glass on the layout itself is unaffected: only its blocks move. */
.gallery-screen-layout[class*="gallery-screen-layout--anim-"] > .gallery-screen-layout__content > :is([style*="backdrop-filter"], :has([style*="backdrop-filter"])) { opacity: 1 !important; transform: none !important; transition: none; }
.gallery-screen-layout[class*="gallery-screen-layout--anim-"] > .gallery-screen-layout__content [style*="backdrop-filter"] { transition: opacity var(--gsl-anim-ms, 500ms) ease; }
.gallery-screen:not(.is-shown) .gallery-screen-layout[class*="gallery-screen-layout--anim-"]:not(.is-played) > .gallery-screen-layout__content [style*="backdrop-filter"] { opacity: 0; }
/* Entrance delay counts from the moment the screen is in view (.is-shown),
   plus a small stagger per block; leaving the view hides without delay. */
.gallery-screen.is-shown .gallery-screen-layout__content > *,
.gallery-screen.is-shown .gallery-screen-layout__content [style*="backdrop-filter"] { transition-delay: var(--gsl-delay, 0ms); }
.gallery-screen.is-shown .gallery-screen-layout__content > :nth-child(2) { transition-delay: calc(var(--gsl-delay, 0ms) + 60ms); }
.gallery-screen.is-shown .gallery-screen-layout__content > :nth-child(3) { transition-delay: calc(var(--gsl-delay, 0ms) + 120ms); }
.gallery-screen.is-shown .gallery-screen-layout__content > :nth-child(4) { transition-delay: calc(var(--gsl-delay, 0ms) + 180ms); }
.gallery-screen.is-shown .gallery-screen-layout__content > :nth-child(n + 5) { transition-delay: calc(var(--gsl-delay, 0ms) + 240ms); }

@media (prefers-reduced-motion: reduce) {
  .gallery-screen .gallery-screen-layout__content > *,
  .gallery-screen .gallery-screen-layout__content [style*="backdrop-filter"] { transition: none !important; opacity: 1 !important; transform: none !important; }
}

/* Block picker preview (request.visual_preview_mode): the screen stands alone. */
.gallery-screen-preview { position: relative; width: 100%; max-width: 480px; margin: 0 auto; aspect-ratio: 4 / 5; }
.gallery-screen-preview > .gallery-screen--slide { height: 100%; aspect-ratio: auto; }
.gallery-screen-preview__image { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: cover; }
.gallery-screen[data-gs-preview] .gallery-screen-layout__content > *,
.gallery-screen[data-gs-preview] .gallery-screen-layout__content [style*="backdrop-filter"] { opacity: 1 !important; transform: none !important; }

/* Godlike screen layout (blocks/gallery-screen-layout.liquid): fills the frame
   edge to edge and owns the whole look — colors, background, layout, corners /
   border / shadow, animation; the screen only places it. */
.gallery-screen__content:has(> .gallery-screen-layout) { padding: 0; gap: 0; }
.gallery-screen-layout {
  position: relative;
  display: flex;
  flex-direction: column;
  flex: 1 1 auto;
  min-height: 100%;
  isolation: isolate;
  color: var(--gsl-text, rgb(var(--color-foreground)));
  overflow: hidden;
  border: var(--gsl-border-w, 0px) solid var(--gsl-border-color, transparent);
  border-radius: var(--gsl-radius, 0px);
  box-shadow: var(--gsl-shadow, none);
  box-sizing: border-box;
}
.gallery-screen-layout::before {
  content: '';
  position: absolute;
  inset: 0;
  z-index: -3;
  background: var(--gsl-bg, var(--gradient-background, rgb(var(--color-background))));
  opacity: var(--gsl-bg-alpha, 1);
  pointer-events: none;
}
.gallery-screen-layout--bg-none::before { content: none; }
.gallery-screen-layout .media-background { z-index: -2; }
/* Glass over the layout's own background media: the media is inside the
   layout, so backdrop-filter can't reach it. Blur the media itself (bled past
   the edges so the blur has no soft rim) and lay the background color over it
   as the frosted tint. */
.gallery-screen-layout--glass-media .media-background {
  top: calc(var(--gsl-glass-blur, 0px) * -2);
  left: calc(var(--gsl-glass-blur, 0px) * -2);
  width: calc(100% + var(--gsl-glass-blur, 0px) * 4);
  height: calc(100% + var(--gsl-glass-blur, 0px) * 4);
  filter: blur(var(--gsl-glass-blur, 0px)) saturate(var(--gsl-glass-sat, 100%));
}
/* Same for an Image grid (also inside the layout). */
.gallery-screen-layout--glass-media .gsl-grid {
  inset: calc(var(--gsl-glass-blur, 0px) * -2);
  filter: blur(var(--gsl-glass-blur, 0px)) saturate(var(--gsl-glass-sat, 100%));
}
.gallery-screen-layout--glass-media::before { z-index: -1; }
/* Background media = Image grid: columns of tiles under the overlay. The gap
   shows the gap color; staggered columns hold one extra tile and every other
   one is lifted by half a tile. */
.gsl-grid { position: absolute; inset: 0; z-index: -2; display: flex; gap: var(--gsl-grid-gap, 0px); background: var(--gsl-grid-gap-color, transparent); overflow: hidden; pointer-events: none; }
.gsl-grid__col { flex: 1 1 0; min-width: 0; display: flex; flex-direction: column; gap: var(--gsl-grid-gap, 0px); }
.gsl-grid__tile { --gsl-tile-h: calc((100% - (var(--gsl-grid-rows, 2) - 1) * var(--gsl-grid-gap, 0px)) / var(--gsl-grid-rows, 2)); flex: 0 0 var(--gsl-tile-h); overflow: hidden; border-radius: var(--gsl-grid-radius, 0px); }
.gsl-grid__tile > img,
.gsl-grid__tile > svg { display: block; width: 100%; height: 100%; object-fit: cover; }
.gsl-grid__tile > svg { background: rgba(var(--color-foreground), 0.06); }
.gsl-grid--stagger .gsl-grid__col:nth-child(even) { transform: translateY(calc((100% - (var(--gsl-grid-rows, 2) - 1) * var(--gsl-grid-gap, 0px)) / var(--gsl-grid-rows, 2) / -2 - var(--gsl-grid-gap, 0px) / 2)); }
/* Animate grid: each column's track holds its tiles twice and slides one
   set (N tiles + N gaps; % = the track's height = the screen) for a seamless
   loop. Odd columns run the other way unless "Alternate" is off. */
.gsl-grid__track { display: flex; flex-direction: column; gap: var(--gsl-grid-gap, 0px); height: 100%; will-change: transform;
  --gsl-loop: calc(-1 * var(--gsl-grid-n, 2) * ((100% - (var(--gsl-grid-rows, 2) - 1) * var(--gsl-grid-gap, 0px)) / var(--gsl-grid-rows, 2) + var(--gsl-grid-gap, 0px)));
  animation: gsl-grid-up var(--gsl-grid-dur, 24s) var(--gsl-grid-ease, linear) infinite;
  animation-delay: calc(var(--gsl-col, 0) * var(--gsl-grid-col-delay, 0s) * -1); }
.gsl-grid--anim-down .gsl-grid__track,
.gsl-grid--anim-up:not(.gsl-grid--anim-same) .gsl-grid__col:nth-child(even) .gsl-grid__track { animation-name: gsl-grid-down; }
.gsl-grid--anim-down:not(.gsl-grid--anim-same) .gsl-grid__col:nth-child(even) .gsl-grid__track { animation-name: gsl-grid-up; }
.gallery-screen-layout:hover > .gsl-grid--anim-hover .gsl-grid__track { animation-play-state: paused; }
@keyframes gsl-grid-up { from { transform: translateY(0); } to { transform: translateY(var(--gsl-loop)); } }
@keyframes gsl-grid-down { from { transform: translateY(var(--gsl-loop)); } to { transform: translateY(0); } }
@media (prefers-reduced-motion: reduce) { .gsl-grid__track { animation: none; } }
.gallery-screen-layout__overlay {
  position: absolute;
  inset: 0;
  z-index: -1;
  background: var(--gsl-overlay, #000);
  opacity: var(--gsl-overlay-opacity, 0);
  pointer-events: none;
  font-size: 0;
}
.gallery-screen-layout__content {
  display: flex;
  flex-direction: column;
  flex: 1 1 auto;
  gap: var(--gsl-gap, 14px);
  padding: var(--gsl-pad-v, 26px) var(--gsl-pad-h, 24px);
  align-items: var(--gsl-halign, stretch);
  text-align: var(--gsl-text-align, left);
  box-sizing: border-box;
  /* Content max width narrows this column; Horizontal alignment places it
     (Full width / Center: centered). */
  width: var(--gsl-max-w, 100%);
  max-width: 100%;
  margin-inline: auto;
}
.gallery-screen-layout--halign-flex-start > .gallery-screen-layout__content { margin-inline: 0 auto; }
.gallery-screen-layout--halign-flex-end > .gallery-screen-layout__content { margin-inline: auto 0; }
/* Left / Right also win over blocks that center themselves with auto side
   margins (Container at Custom / Fit size sets margin-inline: auto on its id). */
.gallery-screen-layout--halign-flex-start > .gallery-screen-layout__content > * { margin-left: 0 !important; margin-right: auto !important; }
.gallery-screen-layout--halign-flex-end > .gallery-screen-layout__content > * { margin-left: auto !important; margin-right: 0 !important; }
/* Like hearts (assets/gallery-screen-hearts.js): a layer over the whole
   layout; each heart is an absolutely placed <span> animated by the script. */
.gsl-hearts { position: absolute; inset: 0; z-index: 1; overflow: hidden; pointer-events: none; font-size: 0; }
.gsl-hearts--behind { z-index: -1; }
.gsl-heart { position: absolute; left: 0; top: 0; display: block; will-change: transform, opacity; }
.gsl-heart svg { display: block; width: 100%; height: 100%; overflow: visible; }
.gallery-screen-layout__content > * { margin-block: 0; max-width: 100%; }
.gallery-screen-layout--valign-center .gallery-screen-layout__content { justify-content: center; }
.gallery-screen-layout--valign-end .gallery-screen-layout__content { justify-content: flex-end; }
.gallery-screen-layout--valign-between .gallery-screen-layout__content { justify-content: space-between; }
.gallery-screen-layout--valign-last .gallery-screen-layout__content > .gallery-screen__last { margin-top: auto !important; }
/* Pins: a screen's "Pin first block to top" / "Pin last block to bottom", and
   a Container / Group with "Pin inside a gallery screen" (.gs-pin, from
   anywhere in the list). Only the pinned block leaves the flow (absolute, on
   the layout), so the others keep their alignment on the whole screen. Side to
   side it keeps its width and follows Horizontal alignment (Full width /
   Center: centered) inside the side padding; full width = flush to both edges.
   With both screen pins on a single block, the bottom pin wins. The gallery's
   pagination bar (z-index 4 above) draws over a bottom pin. */
.gallery-screen-layout { --gsl-pin-x: var(--gsl-pad-h, 24px); }
.gallery-screen-layout--pin-first > .gallery-screen-layout__content > .gallery-screen__first,
.gallery-screen-layout--pin-last > .gallery-screen-layout__content > .gallery-screen__last,
.gallery-screen-layout__content > .gs-pin {
  position: absolute;
  left: 50%;
  translate: -50% 0;
  margin: 0 !important;
}
/* Screen pins take the block's natural width; a Container / Group pin keeps the
   width its own settings give it. */
.gallery-screen-layout--pin-first > .gallery-screen-layout__content > .gallery-screen__first:not(.gs-pin),
.gallery-screen-layout--pin-last > .gallery-screen-layout__content > .gallery-screen__last:not(.gs-pin) { width: max-content; max-width: calc(100% - 2 * var(--gsl-pin-x)); }
.gallery-screen-layout--pin-first > .gallery-screen-layout__content > .gallery-screen__first { top: var(--gsl-pin-top, 0px); bottom: auto; }
.gallery-screen-layout--pin-last > .gallery-screen-layout__content > .gallery-screen__last { top: auto; bottom: var(--gsl-pin-bottom, 0px); }
.gallery-screen-layout__content > .gs-pin--top { top: var(--gs-pin-offset, 0px); bottom: auto; }
.gallery-screen-layout__content > .gs-pin--bottom { top: auto; bottom: var(--gs-pin-offset, 0px); }
.gallery-screen-layout--halign-flex-start > .gallery-screen-layout__content > :is(.gallery-screen__first, .gallery-screen__last, .gs-pin) { left: var(--gsl-pin-x); }
.gallery-screen-layout--halign-flex-end > .gallery-screen-layout__content > :is(.gallery-screen__first, .gallery-screen__last, .gs-pin) { left: auto; right: var(--gsl-pin-x); }
.gallery-screen-layout--halign-flex-start > .gallery-screen-layout__content > :is(.gallery-screen__first, .gallery-screen__last, .gs-pin),
.gallery-screen-layout--halign-flex-end > .gallery-screen-layout__content > :is(.gallery-screen__first, .gallery-screen__last, .gs-pin) { translate: none; }
.gallery-screen-layout--pin-first-full > .gallery-screen-layout__content > .gallery-screen__first,
.gallery-screen-layout--pin-last-full > .gallery-screen-layout__content > .gallery-screen__last,
.gallery-screen-layout__content > .gs-pin--full { left: 0 !important; right: 0 !important; width: auto; max-width: none; translate: none; }
@media screen and (max-width: 749px) {
  .gallery-screen-layout { --gsl-pin-x: var(--gsl-pad-h-m, 18px); }
  .gallery-screen-layout--pin-first > .gallery-screen-layout__content > .gallery-screen__first { top: var(--gsl-pin-top-m, 0px); }
  .gallery-screen-layout--pin-last > .gallery-screen-layout__content > .gallery-screen__last { top: auto; bottom: var(--gsl-pin-bottom-m, 0px); }
}
  .gallery-screen-layout--pin-last > .gallery-screen-layout__content > .gallery-screen__last { bottom: var(--gsl-pin-bottom-m, 0px); }
}
/* Height: Fit the content / Custom %. The panel stops filling the frame; its
   background and glass cover only the panel, placed by Vertical position
   (top / middle / bottom — Spread out and Last block at the bottom sit at the
   bottom and keep their meaning inside the panel). */
.gallery-screen-layout--h-fit,
.gallery-screen-layout--h-custom { flex: 0 0 auto; min-height: 0; margin: var(--gsl-inset, 0px); }
.gallery-screen-layout--h-custom { flex-basis: calc(var(--gsl-h, 50%) - 2 * var(--gsl-inset, 0px)); }
.gallery-screen-layout--h-fit:not(.gallery-screen-layout--valign-start):not(.gallery-screen-layout--valign-center),
.gallery-screen-layout--h-custom:not(.gallery-screen-layout--valign-start):not(.gallery-screen-layout--valign-center) { margin-top: auto; }
.gallery-screen-layout--h-fit.gallery-screen-layout--valign-center,
.gallery-screen-layout--h-custom.gallery-screen-layout--valign-center { margin-block: auto; }
.gallery-screen-layout--h-fit .gallery-screen-layout__content { flex: 0 0 auto; }
/* Width: Fit the content / Custom %, the same idea sideways. The panel is
   placed by Horizontal alignment (Full width / Center: centered); the edge gap
   applies on every side, so a full-height panel shrinks by it too. */
.gallery-screen-layout--w-fit,
.gallery-screen-layout--w-custom { margin-inline: var(--gsl-inset, 0px); max-width: calc(100% - 2 * var(--gsl-inset, 0px)); }
.gallery-screen-layout--w-fit { width: fit-content; }
.gallery-screen-layout--w-custom { width: calc(var(--gsl-w, 50%) - 2 * var(--gsl-inset, 0px)); }
.gallery-screen-layout--w-fit.gallery-screen-layout--h-fill,
.gallery-screen-layout--w-custom.gallery-screen-layout--h-fill { margin-block: var(--gsl-inset, 0px); min-height: calc(100% - 2 * var(--gsl-inset, 0px)); }
.gallery-screen-layout--w-fit:is(.gallery-screen-layout--halign-stretch, .gallery-screen-layout--halign-center),
.gallery-screen-layout--w-custom:is(.gallery-screen-layout--halign-stretch, .gallery-screen-layout--halign-center) { margin-inline: auto; }
.gallery-screen-layout--w-fit.gallery-screen-layout--halign-flex-start,
.gallery-screen-layout--w-custom.gallery-screen-layout--halign-flex-start { margin-right: auto; }
.gallery-screen-layout--w-fit.gallery-screen-layout--halign-flex-end,
.gallery-screen-layout--w-custom.gallery-screen-layout--halign-flex-end { margin-left: auto; }
/* Several layouts in one screen: a "Fill the screen" layout takes the space the
   others leave instead of a full 100% of its own (which pushed its siblings out
   of the frame); fill layouts split what is left between them. */
.gallery-screen__content:has(> .gallery-screen-layout ~ .gallery-screen-layout) > .gallery-screen-layout--h-fill { flex: 1 1 0; min-height: 0; }
.gallery-screen--overlay .gallery-screen-layout { pointer-events: none; }
.gallery-screen--overlay .gallery-screen-layout__content > * { pointer-events: auto; }
@media screen and (max-width: 749px) {
  .gallery-screen-layout__content { gap: var(--gsl-gap-m, 12px); padding: var(--gsl-pad-v-m, 22px) var(--gsl-pad-h-m, 18px); }
  .gallery-screen .gallery-screen-layout__content { padding-bottom: calc(var(--gsl-pad-v-m, 22px) + var(--gs-pager-h, 0px)); }
  /* "Start below the transparent header": --gs-header-clear is the header's
     height, set on the gallery only on mobile with the Gallery's Transparent
     header on (snippets/gallery-transparent-header-css.liquid). --gs-hc is 0
     everywhere else, so these resolve to the plain values. Only a layout
     whose top reaches the image top takes it: full height, or a Fit / Custom
     height panel placed at the top. */
  .gallery-screen-layout--header-clear:is(.gallery-screen-layout--h-fill, .gallery-screen-layout--valign-start) { --gs-hc: var(--gs-header-clear, 0px); }
  .gallery-screen-layout__content { padding-top: calc(var(--gsl-pad-v-m, 22px) + var(--gs-hc, 0px)); }
  .gallery-screen-layout--pin-first > .gallery-screen-layout__content > .gallery-screen__first { top: calc(var(--gsl-pin-top-m, 0px) + var(--gs-hc, 0px)); }
  .gallery-screen-layout__content > .gs-pin--top { top: calc(var(--gs-pin-offset, 0px) + var(--gs-hc, 0px)); }
}

/* A Sizing chart inside a screen is a hidden data source for the Size chart
   mirror (its popup is turned into [data-gs-modal-copy] by gallery-screen.js):
   no button, no popup. */
.gallery-screen modal-opener.sizing-chart,
.gallery-screen .vp-pinned-item > a.no-js,
.gallery-screen [data-gs-modal-copy] { display: none !important; }

/* "Protect gallery swipe on this screen" (.gallery-screen-layout--no-swipe) has
   no CSS: the color picker's large image skips its own swipe there
   (assets/gs-color-picker.js), so the gallery keeps sideways swipes. */

/* Godlike screens block (blocks/godlike-screens.liquid): screens as page
   content, each in a frame the block sizes (aspect ratio, frame style,
   screens per row, gap, width, alignment, spacing). */
.gsx {
  display: grid;
  grid-template-columns: repeat(var(--gsx-cols-m, 1), minmax(0, 1fr));
  gap: var(--gsx-gap, 12px);
  width: 100%;
  max-width: var(--gsx-max-w, 100%);
  margin-top: var(--gsx-mt, 0px);
  margin-bottom: var(--gsx-mb, 0px);
}
.gsx--align-center { margin-left: auto; margin-right: auto; }
.gsx--align-right { margin-left: auto; }
.gsx__cell { position: relative; min-width: 0; }
.gsx:not(.gsx--theme-frame) .gsx__cell {
  border: var(--gsx-border-w, 0px) solid var(--gsx-border-color, transparent);
  border-radius: var(--gsx-radius, 0px);
  overflow: hidden;
}
/* Theme frame: .global-media-settings on the cell (the theme's media border,
   radius, shadow — overflow stays visible for the shadow), so the screen
   clips itself to the radius. */
.gsx--theme-frame .gallery-screen--inline { border-radius: calc(var(--media-radius, 0px) - var(--media-border-width, 0px)); }
.gallery-screen--inline { aspect-ratio: var(--gsx-ratio-m, 0.8); }
@media screen and (min-width: 750px) {
  .gsx { grid-template-columns: repeat(var(--gsx-cols, 1), minmax(0, 1fr)); }
  .gallery-screen--inline { aspect-ratio: var(--gsx-ratio, 0.8); }
}

/* Godlike screens over a Media block (blocks/media.liquid): layers inside
   .media-block__wrapper, like gallery overlays. */
.gs-media-overlays { display: contents; }
