/**********************************************************************************

    ██████╗ ██████╗  ██████╗ ██████╗ ██╗   ██╗ ██████╗████████╗███████╗
    ██╔══██╗██╔══██╗██╔═══██╗██╔══██╗██║   ██║██╔════╝╚══██╔══╝██╔════╝
    ██████╔╝██████╔╝██║   ██║██║  ██║██║   ██║██║        ██║   ███████╗
    ██╔═══╝ ██╔══██╗██║   ██║██║  ██║██║   ██║██║        ██║   ╚════██║
    ██║     ██║  ██║╚██████╔╝██████╔╝╚██████╔╝╚██████╗   ██║   ███████║
    ╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚═════╝  ╚═════╝  ╚═════╝   ╚═╝   ╚══════╝

 **********************************************************************************/



    /*
        Figma reference — Homepage / "Comfortable Armchairs", 1920px artboard.

            section .......... padding-top 110, heading to products gap 110
            heading .......... 1440 wide, icon 49x44, gap 50 icon to title
            title ............ Hauora ExtraBold 50px, lh 55, #231F20
            view all ......... Hauora Bold 14px, lh 21, uppercase
            description ...... Hauora Regular 15px, lh 22.5, 530 wide
            arrows ........... 48x48 circles, right of the heading
                               (the artboard has bare 32x60 chevrons; see
                               the note at the arrow rules for why)
            card ............. 345 x 462, 20 gap, photo 345 square
            card title ....... Hauora Bold 18px, #231F20
            card price ....... Hauora ExtraBold 13px, #7F7F7F
            card button ...... 345 x 40, 1px border #231F20, plus icon 24

        The products row is drawn 1805 wide against a 1440 heading, so the
        carousel deliberately runs wider than the text column and is clipped at
        the right edge. That is reproduced by letting the track overflow rather
        than by fixing widths.
    */

    /*
        The block is full width on purpose and must not be placed inside a
        panel. In the artboards the heading sits in a 1440 column centred in
        1920 — a 240 inset each side — while the products row starts at that
        same inset and runs to 2045, i.e. 125px past the right edge of the
        canvas. A panel would clip the cards at the content column instead of
        at the edge of the screen, losing that effect.

        So the inset is reproduced as padding on the left only, and the section
        clips whatever overflows on the right.
    */

    /* The inset comes from --nvm-content-inset in theme.init.css, so this
       section starts on the same line as every other one. It used to compute
       its own, which is how three blocks ended up with three slightly
       different margins. */

    .nvm-products-carousel {
        padding-top: 110px;
        padding-left: var(--nvm-content-inset);
        overflow: hidden;
    }



/*******************************

    ██╗  ██╗███████╗ █████╗ ██████╗
    ██║  ██║██╔════╝██╔══██╗██╔══██╗
    ███████║█████╗  ███████║██║  ██║
    ██╔══██║██╔══╝  ██╔══██║██║  ██║
    ██║  ██║███████╗██║  ██║██████╔╝
    ╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝╚═════╝

 *******************************/



    /* The heading stays inside the 1440 column; only the track bleeds right. */

    /*
        The header is a row of the framework's columns, and the widths stay
        ours — which is why every rule below names the section as well.

        responsiville.ingrid.css is enqueued after this file, and `.column`
        there sets flex-basis: 100%, max-width: 100% and a 10px gutter, all at
        one class. A lone `.nvm-products-carousel__intro` carries one class
        too, so it would lose on source order alone and the three columns of
        the header would each try to be the full width.

        The extra class in front is what keeps the 380 and the 530 the design
        draws. The gutters go as well: the gaps here are 40, set on the row.
    */

    /*
        `.row.row` names the row twice, and it is the only way to win.

        responsiville.ingrid.css carries `.row .row { margin-left: -10px;
        margin-right: -10px }` — a nested row is expected to pull back over
        its parent's gutters. This row is nested, inside the one the editor
        places, so it took that pull: DevTools showed margin 0 -10px 110px and
        a row 1410 wide in a 1390 line.

        Two classes there, two classes in `.nvm-products-carousel > .row`, and
        ingrid.css is enqueued after this file — so it won on order alone.
        Repeating the class costs nothing and settles it on weight.
    */

    .nvm-products-carousel > .row.row {
        display: flex;
        flex-direction: row;
        align-items: flex-end;
        gap: 0;
        max-width: var(--nvm-panel-medium-width);
        margin-top: 0;
        margin-right: 0;
        margin-bottom: 110px;
        margin-left: 0;
        padding-right: var(--nvm-content-inset);
    }

        /* The title column is 380 wide in the design, which is what makes
           "Comfortable Armchairs" fall onto two lines on its own. A <br> in
           the field still overrides where it breaks. */

        /*
            No gutters on any of these columns.

            `.column` pads 10px on each side, and the grid's spacing here does
            not come from that — it comes from the empty column between the
            title and the paragraph. Left in, the gutter pushed the icon and
            the title to 60 while the section began at 50, which is the kind
            of ten pixels nobody can account for later.
        */

        .nvm-products-carousel > .row > .column {
            padding-left: 0;
            padding-right: 0;
        }

        /* Width comes from laptop-column-25 now; this arranges what is
           inside the column and nothing else. */

        .nvm-products-carousel .nvm-products-carousel__intro {
            display: flex;
            flex-direction: column;
            align-items: flex-start;
            gap: 50px;
        }

            .nvm-products-carousel__icon img {
                display: block;
                width: auto;
                max-height: 44px;
            }

            /* The .nvm-products-carousel prefix is required, not cosmetic.
               theme.typography.css carries `.responsiville h2 { font-size:
               clamp(25px, …, 42px) }` at one class plus one element, which
               outranks a lone class here and would render this at 42px
               instead of the 50px in the design. */

            .nvm-products-carousel .nvm-products-carousel__title {
                margin: 0;
                font-size: clamp(30px, 2.6vw, 50px);
                font-weight: 800;
                line-height: 1.1;
                color: var(--nvm-color-ink);
            }

            /* The icon-to-title gap is 50 in the design, but the title-to-link
               gap is much tighter, so the flex gap is cancelled here. */

            .nvm-products-carousel__view-all {
                display: inline-flex;
                align-items: center;
                gap: 10px;
                margin-top: -30px;
                padding: 0;
                background: none;
                color: var(--nvm-color-ink);
                font-size: 14px;
                font-weight: 700;
                line-height: 1.5;
                text-transform: uppercase;
                transition: opacity 0.2s ease-in-out;
            }

            .nvm-products-carousel__view-all:hover {
                background: none;
                opacity: 0.6;
            }

        .nvm-products-carousel .nvm-products-carousel__description {
            font-size: 15px;
            font-weight: 400;
            line-height: 1.5;
            color: var(--nvm-color-ink);
        }



    /* Arrows. */

    /*
        The empty column exists only to hold the 343 the artboard leaves
        between the title and the paragraph, and that gap only exists once the
        header is a row — which is at desktop. Below that the header stacks
        and an empty column would be an empty line in the stack.
    */

    .nvm-products-carousel__spacer {
        display: none;
    }

    /* The arrows sit at the right edge of their column, which is what puts
       them on the page's right margin as the artboard has them. */

    .nvm-products-carousel .nvm-products-carousel__arrows {
        display: flex;
        flex-direction: row;
        align-items: center;
        justify-content: flex-end;
        gap: 14px;
    }

        /*
            Buttons, not a mark.

            The artboard draws two bare 32x60 chevrons side by side. On the
            page they butt together into what reads as one decorative symbol
            — the client could not tell they were controls, and looking at
            the rendered header beside the alternatives, they are right: what
            is missing is not size, it is the edge that says a thing can be
            pressed.

            So the chevron keeps its shape and sits inside a filled circle.
            Ink and white, which are the colours the page already uses, and
            gold on hover — the same gold every other hover on this site
            takes, so nothing new is introduced to make a control visible.

            48 and not 60. The first pass filled a 60 circle, which answered
            the complaint and then sat heavier on the page than anything
            around it. Drawn against 44 and 40 at the top of the live
            carousel, 48 is the smallest that still reads as a control at a
            glance — the triangle keeps the same share of the circle, a
            little over two fifths, so only the scale changes.
        */

        .nvm-products-carousel__arrow {
            display: flex;
            align-items: center;
            justify-content: center;
            width: 48px;
            height: 48px;
            padding: 0;
            border: none;
            border-radius: 50%;
            background: var(--nvm-color-ink);
            box-shadow: none;
            color: var(--nvm-color-white);
            cursor: pointer;
            transition: background-color 0.2s ease-in-out, color 0.2s ease-in-out;
        }

        .nvm-products-carousel__arrow:hover,
        .nvm-products-carousel__arrow:focus {
            opacity: 1;
            background: var(--nvm-color-gold);
            color: var(--nvm-color-white);
        }

        /*
            The gold fill is the hover; a keyboard needs a ring as well, or
            tabbing to the arrows shows the same thing as hovering past them
            and the focus is impossible to follow. :focus-visible only, so a
            mouse press does not leave a ring behind it.
        */

        .nvm-products-carousel__arrow:focus-visible {
            outline: 2px solid var(--nvm-color-ink);
            outline-offset: 3px;
        }

        /*
            Slick greys the arrow at either end of a non-looping set, and here
            that would be a lie: the carousel does not end — an arrow at the
            last card goes round to the first. So the arrows stay live, and
            look it.

            The class is still added by Slick and still useful: the script
            reads whether a press moved anything, not this.
        */

        .nvm-products-carousel__arrow.slick-disabled {
            opacity: 1;
            cursor: pointer;
            pointer-events: auto;
        }

            /* The chevron inside the circle, at the size the circle leaves
               it. height carries !important because Slick's own stylesheet
               sets a height on button svgs. */

            .nvm-products-carousel__arrow svg {
                display: block;
                width: 10px;
                height: 20px !important;
            }

            /*
                Optical centring, two pixels of it.

                A triangle centred box-against-box looks pushed toward its
                base, because its weight is there: the centre of gravity sits
                at x 23.94 of the icon's frame while the frame's middle is at
                27.46. Moving it that difference toward the tip puts the
                weight on the circle's centre, which is what the eye reads as
                centred.

                Moved here and not inside the icon. The triangle is 21.49
                wide in a 22.5 viewBox, so there is half a unit of air on
                each side, and an SVG clips to its viewBox: a nudge of that
                size inside the file flattened the tip of every arrow on the
                site. The element has no such edge to hit.
            */

            .nvm-products-carousel__arrow--prev svg {
                transform: translateX( -2px );
            }

            .nvm-products-carousel__arrow--next svg {
                transform: translateX( 2px );
            }



/******************************************

    ████████╗██████╗  █████╗  ██████╗██╗  ██╗
    ╚══██╔══╝██╔══██╗██╔══██╗██╔════╝██║ ██╔╝
       ██║   ██████╔╝███████║██║     █████╔╝
       ██║   ██╔══██╗██╔══██║██║     ██╔═██╗
       ██║   ██║  ██║██║  ██║╚██████╗██║  ██╗
       ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝

 ******************************************/



    /* Before Slick initialises, the slides are a plain flex row. This keeps
       the block looking right in the editor preview and during the moment
       before the script runs. */

    /*
        The track carries `row`, because it is one: a line of columns, one per
        product, which is what the grid debug is meant to draw.

        Three things have to be held against the framework's own rule, which
        is enqueued after this file:

        nowrap — `.row` wraps, and the cards must run off the right edge
        instead. Wrapping only shows before Slick initialises, but that is the
        first paint and the cards would visibly jump.

        The margins — this row is nested inside the one the editor places, so
        `.row .row` pulls it 10px over each gutter.

        And `.row.row` in the selector, to outweigh that at three classes
        rather than tie at two and lose on load order.
    */

    .nvm-products-carousel .nvm-products-carousel__track.row.row {
        display: flex;
        flex-direction: row;
        flex-wrap: nowrap;
        gap: 20px;
        margin-left: 0;
        margin-right: 0;
    }

    /*
        Once Slick owns the layout the track stops being a `.row`.

        What had to go was everything `.row` brings with it — the wrapping,
        the negative margins, the gutters — which fights Slick's own
        measuring. It was turned back into a block for that, and a block is
        what it stayed.

        A block leaves every slide at its own height, though, and floated
        beside one another they end wherever their content ends. So a card
        carrying "/ minimum quantity 4 items" runs a line longer than its
        neighbours and its button sits a line lower than theirs, which is
        exactly what the row looks like now.

        Flex puts that right and brings none of the trouble back: wrapping is
        refused outright, there are no margins here to reinstate, and the
        widths are Slick's own inline styles on each slide, which flex
        honours. The slides stretch to the tallest, the card fills the slide,
        and the buttons come to rest along one line.
    */

    .nvm-products-carousel .nvm-products-carousel__track.row.slick-initialized {
        display: flex;
        flex-wrap: nowrap;
        align-items: stretch;
    }

    /*
        Cards of one height, in a row that is one row.

        The grid on the shop and the search pages gets this for nothing: the
        cards are grid items, so every card in a line is drawn to the height
        of the tallest — measured, 503 503 503 503, then 527 527 527 527 on
        the line below. A carousel is a single line and ought to be the
        easiest case of all, and it was the only one getting it wrong: the
        XMAS row came out 504, 528 and 552, with the add-to-cart buttons at
        464, 488 and 512, because a two, three and four line title each add
        24px underneath themselves.

        The reason is one element. The track this stylesheet makes a flex
        container is not the one holding the slides — Slick builds a
        .slick-track of its own inside it and leaves it display: block, so
        the stretch had nothing to act on.

        From the laptop up only. Below 600 the carousel is set to
        adaptiveHeight so a single card on a phone is its own height rather
        than the tallest in the set, and that is deliberate.
    */

    .laptop .nvm-products-carousel .slick-track {
        display: flex;
        align-items: stretch;
    }

        /* Slick writes an inline height on each slide as it measures them.
           Auto hands the decision back to the stretch above. */

        .laptop .nvm-products-carousel .slick-track > .slick-slide {
            height: auto;
        }

        .laptop .nvm-products-carousel .slick-slide .nvm-product-card {
            height: 100%;
        }

        /* Slick gives each slide height: 100%, which against a flex parent of
           no stated height resolves to nothing. Auto lets stretch do it. */

        .nvm-products-carousel__track.slick-initialized .slick-slide {
            height: auto;
        }

    /*
        Fewer cards than the row holds.

        products-carousel-script.js does not start Slick in that case — see
        there for why — and marks the track instead.

        The cards then take exactly the width Slick would have given them:
        the track divided by the column count, with the twenty-pixel gutter
        as padding inside each one, which is how Slick lays a slide out. So
        two related products are the size of two products anywhere else on
        the site rather than half a page each, and the row ends where they
        end.

        Written at three and four classes on purpose. The fixed widths
        further down this file — 260 before the tablet, 345 from the desktop
        — are what the block shows in the editor before Slick runs, and they
        come later in the file, so a rule that merely tied with them would
        lose.
    */

    .nvm-products-carousel .nvm-products-carousel__track--static.row.row {
        gap: 0;
        overflow-x: auto;
        scroll-snap-type: x proximity;
        -webkit-overflow-scrolling: touch;
        scrollbar-width: none;
    }

        .nvm-products-carousel .nvm-products-carousel__track--static.row.row::-webkit-scrollbar {
            display: none;
        }

        /*
            Two cards fit side by side on a desktop and do not on a phone,
            where the row holds 1.2 of them — so the track still has to be
            swipeable there. It scrolls rather than being a carousel: the
            arrows are hidden, and a short row that fits produces no
            scrollbar and nothing to scroll, so this costs the desktop
            nothing.
        */

        .nvm-products-carousel .nvm-products-carousel__track--static > .nvm-products-carousel__slide {
            scroll-snap-align: start;
        }

        .nvm-products-carousel .nvm-products-carousel__track--static > .nvm-products-carousel__slide {
            flex: 0 0 calc( 100% / var(--nvm-carousel-cols-mobile, 1) );
            width: auto;
            max-width: calc( 100% / var(--nvm-carousel-cols-mobile, 1) );
            padding-left: 0;
            padding-right: 20px;
        }

    .tablet .nvm-products-carousel .nvm-products-carousel__track--static > .nvm-products-carousel__slide {
        flex-basis: calc( 100% / var(--nvm-carousel-cols-tablet, 2) );
        max-width:  calc( 100% / var(--nvm-carousel-cols-tablet, 2) );
    }

    .laptop .nvm-products-carousel .nvm-products-carousel__track--static > .nvm-products-carousel__slide {
        flex-basis: calc( 100% / var(--nvm-carousel-cols-desktop, 4) );
        max-width:  calc( 100% / var(--nvm-carousel-cols-desktop, 4) );
    }

    /*
        The fifth card in the design carries a LAYER_BLUR of radius 14 — the
        card running off the right edge is deliberately out of focus, hinting
        that the row continues.

        Blurring the card itself, rather than laying a blurred strip over the
        right edge: a strip also blurs the background wherever no card reaches,
        which reads as a smudge. Slick marks the slides that are fully in view
        with .slick-active, so anything without it is either off-screen to the
        left or the one peeking on the right — exactly what should be soft.

        Figma's blur radius is roughly twice the CSS one, hence 7 rather
        than 14.
    */

    .nvm-products-carousel__carousel {
        position: relative;
    }

        .nvm-products-carousel__track.slick-initialized .nvm-product-card {
            transition: filter 0.3s ease-in-out;
        }

        /*
            .is-cut is put on by products-carousel-script.js, on the one slide
            the viewport actually cuts. Slick's own .slick-active could not do
            this: it marks a fixed count of slides whatever the screen width,
            so a rule built on it always blurs the same position in the row
            rather than the card that is really hanging off the edge.

            When every card fits, no slide gets the class and nothing is
            blurred — correct, since there is nothing cut to soften.
        */

        /*
            Nothing at all on a phone.

            The effect says "the row goes on past the edge", which is worth
            saying on a wide screen where several cards are in view and one
            is clipped. On a phone the cut card is a finger's width of
            picture; blurred, it stops looking like a product that continues
            and starts looking like a fault.

            Base first and restored upwards, because the breakpoint classes
            are cumulative: anything hung on `.small` would apply at every
            width, not only the small ones.
        */

        .nvm-products-carousel__track.slick-initialized .slick-slide.is-cut .nvm-product-card {
            filter: none;
        }

        /* Softer on a tablet: 7px across a narrow card is a smudge. */

        .tablet .nvm-products-carousel__track.slick-initialized .slick-slide.is-cut .nvm-product-card {
            filter: blur(4px);
        }

        .desktop .nvm-products-carousel__track.slick-initialized .slick-slide.is-cut .nvm-product-card {
            filter: blur(7px);
        }

        /*
            Slick's own list keeps its default overflow: hidden. The track
            already begins at the inset and runs to the right edge of the
            viewport, so that clip lands exactly where the design clips —
            at the screen edge. Making it visible instead would spill the
            previous slides into the left inset while navigating.
        */

        .nvm-products-carousel .nvm-products-carousel__slide {
            flex: 0 0 345px;
            width: auto;
            max-width: 345px;
            padding-left: 0;
            padding-right: 0;
        }

        /*
            Slick lays the slides out itself once initialised, and the gap has
            to become padding on each slide instead.

            padding-left is stated as well, and it is not redundant: `.column`
            gives a gutter on both sides, and left alone the left one would
            have pushed every card ten pixels along while the right was being
            overruled here.
        */

        .nvm-products-carousel .slick-initialized .nvm-products-carousel__slide {
            flex: none;
            max-width: none;
            padding-left: 0;
            padding-right: 20px;
        }



/*************************************

     ██████╗ █████╗ ██████╗ ██████╗
    ██╔════╝██╔══██╗██╔══██╗██╔══██╗
    ██║     ███████║██████╔╝██║  ██║
    ██║     ██╔══██║██╔══██╗██║  ██║
    ╚██████╗██║  ██║██║  ██║██████╔╝
     ╚═════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═════╝

 *************************************/



    /* Shared by the carousel and the product archive, so the card styles are
       not nested inside .nvm-products-carousel. */

    /*
        Every card the same height, and the prices along one line.

        Two things were making them ragged. The photograph is square on all
        of them, so it was never the photograph — it was the name above the
        price, one line on some products and two on others, which pushed the
        price down by a line wherever it wrapped.

        So the name is given two lines whether it needs them or not, and the
        price is pushed to the foot of the card. A card in a taller row then
        grows in the middle, where nothing is, rather than at the bottom
        where the eye is reading across.
    */

    .nvm-product-card {
        display: flex;
        flex-direction: column;
        height: 100%;
        gap: 20px;
    }

        /* overflow keeps the zoomed photo inside the card's square. */

        .nvm-product-card__media {
            display: block;
            padding: 0;
            overflow: hidden;
            background: var(--nvm-color-white);
        }

        .nvm-product-card__media:hover {
            background: var(--nvm-color-white);
        }

            .nvm-product-card__media img {
                display: block;
                width: 100%;
                transition: transform 0.5s ease-in-out;
            }

            /* Hovering anywhere on the card zooms, not just the photo — the
               title and the button are part of the same target. */

            .nvm-product-card:hover .nvm-product-card__media img {
                transform: scale(1.05);
            }

            /* Respect a reduced-motion preference: the gold still lands, the
               movement does not. */

            @media ( prefers-reduced-motion: reduce ) {

                .nvm-product-card__media img,
                .nvm-product-card:hover .nvm-product-card__media img {
                    transition: none;
                    transform: none;
                }

            }

        .nvm-product-card__body {
            display: flex;
            flex-direction: column;
            flex: 1 1 auto;
            gap: 15px;
        }

            /* Same story as the section title: `.responsiville h3` resolves
               to 34px and outranks a bare class, so the design's 18px needs
               the extra class to win. */

            /*
                Two lines of room, and more if the name asks for it.

                min-height holds the space open so a one-line name does not
                pull its price up above the others, but nothing is cut: a
                name that runs to three lines gets three. The card grows, the
                row grows with it, and the prices stay along the foot because
                of the margin-top below.

                2 x 1.35em is two lines at this size, written in em so it
                follows the font rather than being restated in pixels.
            */

            /*
                15 on a phone, the drawn 18 from a tablet up.

                Written the smaller way round because the breakpoint classes
                are cumulative min-widths: `.small` is on the html element at
                every width there is, so a rule hung on it would set 15px on
                the widest desktop as surely as on a phone — and, carrying an
                extra class, would outrank the base rule while doing it.

                The base value is therefore the phone's, and `.tablet` puts
                the design's back.
            */

            .nvm-product-card .nvm-product-card__title {
                min-height: 2.7em;
                margin: 0;
                font-size: 15px;
                font-weight: 700;
                line-height: 1.35;
                text-transform: uppercase;
            }

            .tablet .nvm-product-card .nvm-product-card__title {
                font-size: 18px;
            }

                /*
                    The weight has to be repeated on the anchor. Line 56 of
                    responsiville.moressette.css sets `* { font-weight: normal }`,
                    which lands directly on this <a>, while the bold on the <h3>
                    would only reach it by inheritance — and a direct rule always
                    beats an inherited value, however low its specificity.
                */

                .nvm-product-card .nvm-product-card__title a {
                    padding: 0;
                    background: none;
                    color: var(--nvm-color-ink);
                    font-weight: 700;
                }

                .nvm-product-card__title a:hover {
                    background: none;
                    opacity: 0.6;
                }

            /* margin-top: auto puts it at the foot of the body, so the
               prices line up across a row whatever is above them. */

            /* margin-top: auto puts it at the foot of the body, so the
               prices line up across a row whatever is above them. */

            .nvm-product-card__meta {
                display: flex;
                flex-direction: row;
                align-items: baseline;
                flex-wrap: wrap;
                margin-top: auto;
                gap: 10px;
            }

                .nvm-product-card__price,
                .nvm-product-card__price .amount,
                .nvm-product-card__note {
                    font-size: 13px;
                    line-height: 1.1;
                    color: var(--nvm-color-stone);
                }

                .nvm-product-card__price,
                .nvm-product-card__price .amount {
                    font-weight: 800;
                }

                /* A discounted product prints the old price in a <del>. */

                .nvm-product-card__price del {
                    opacity: 0.6;
                    margin-right: 6px;
                }

                .nvm-product-card__price ins {
                    text-decoration: none;
                }

                /* Lighter than the price it sits beside: it explains the
                   price's terms rather than competing with it. */

                .nvm-product-card__note {
                    font-weight: 400;
                }



    /* The action. WooCommerce prints the anchor, so the class list it carries
       is matched rather than replaced. */

    /*
        The .responsiville prefix is what makes this stick. theme.buttons.css
        styles `.responsiville .nvm-button` with a grey fill, white text and a
        drop shadow at two classes — the same weight as a rule written here,
        and it loads later, because blocks.php registers its stylesheets before
        enqueues.php does. Adding the body class puts this at three and settles
        it. The shadow has to be switched off explicitly too; the design has
        none.

        Content is aligned left, not centred: in the artboard the plus sits at
        x=11 and the label starts at x=45 inside a 345 wide button.
    */

    .responsiville .nvm-product-card .nvm-product-card__button {
        display: flex;
        align-items: center;
        justify-content: flex-start;
        gap: 10px;
        width: 100%;
        height: 40px;
        margin: 0;
        padding: 10px;
        border: 1px solid var(--nvm-color-ink);
        border-radius: 4px;
        background: none;
        box-shadow: none;
        color: var(--nvm-color-ink);
        font-size: 12px;
        font-weight: 700;
        line-height: 1.366;
        text-transform: uppercase;
        transition: background 0.2s ease-in-out, color 0.2s ease-in-out;
    }

    /*
        The Figma "Property 1=Hovered" variant of the card fills the button
        with gold #C28E44 — border included — and turns the label and the plus
        white. It is the card that is hovered in the design, not the button
        alone, so the whole card drives it; hovering the button directly still
        matches, since the button is inside the card.
    */

    .responsiville .nvm-product-card:hover .nvm-product-card__button,
    .responsiville .nvm-product-card .nvm-product-card__button:hover,
    .responsiville .nvm-product-card .nvm-product-card__button:focus-visible {
        border-color: var(--nvm-color-gold);
        background: var(--nvm-color-gold);
        box-shadow: none;
        color: var(--nvm-color-white);
    }

        .nvm-product-card .nvm-button__icon {
            display: flex;
            align-items: center;
            justify-content: center;
        }

            .nvm-product-card .nvm-button__icon svg {
                display: block;
                width: 24px;
                height: 24px !important;
            }

            .nvm-product-card .nvm-button__icon svg path {
                fill: none;
            }

        /* WooCommerce's AJAX feedback classes. */

        .nvm-product-card .nvm-product-card__button.loading {
            opacity: 0.5;
        }

        .nvm-product-card .added_to_cart {
            display: none;
        }



/****************************************************

    ██████╗ ███████╗███████╗██████╗  ██████╗ ███╗   ██╗███████╗██╗██╗   ██╗███████╗
    ██╔══██╗██╔════╝██╔════╝██╔══██╗██╔═══██╗████╗  ██║██╔════╝██║██║   ██║██╔════╝
    ██████╔╝█████╗  ███████╗██████╔╝██║   ██║██╔██╗ ██║███████╗██║██║   ██║█████╗
    ██╔══██╗██╔══╝  ╚════██║██╔═══╝ ██║   ██║██║╚██╗██║╚════██║██║╚██╗ ██╔╝██╔══╝
    ██║  ██║███████╗███████║██║     ╚██████╔╝██║ ╚████║███████║██║ ╚████╔╝ ███████╗
    ╚═╝  ╚═╝╚══════╝╚══════╝╚═╝      ╚═════╝ ╚═╝  ╚═══╝╚══════╝╚═╝  ╚═══╝  ╚══════╝

 ****************************************************/



    /*
        No tablet or mobile artboards exist for this section, so everything
        below `desktop` is a reasoned reflow. Responsiville breakpoint classes
        are cumulative, so these read as min-width and the base rules above are
        the small-screen case.
    */

    .small .nvm-products-carousel,
    .tablet .nvm-products-carousel {
        padding-top: 50px;
    }

    .small .nvm-products-carousel > .row.row,
    .tablet .nvm-products-carousel > .row.row {
        flex-direction: column;
        align-items: flex-start;
        gap: 25px;
        margin-bottom: 40px;
    }

    .small .nvm-products-carousel__intro,
    .tablet .nvm-products-carousel__intro {
        gap: 25px;
    }

    .small .nvm-products-carousel__view-all,
    .tablet .nvm-products-carousel__view-all {
        margin-top: -15px;
    }



    .small .nvm-products-carousel__slide,
    .tablet .nvm-products-carousel__slide {
        flex-basis: 260px;
        max-width: 260px;
    }

    .desktop .nvm-products-carousel {
        padding-top: 110px;
    }

    /*
        The header turns at laptop, and it has to be laptop rather than
        desktop because that is where the column widths begin.

        Left to turn at desktop, the 1024 to 1279 band had the row still
        stacked while its columns already carried percentages — the paragraph
        ran the full 1120 of the screen in one line, which is far past what
        anyone reads comfortably and nothing like the 530 the artboard draws.

        The breakpoint classes are cumulative, so `tablet` is still present up
        here and its column direction has to be overruled outright.
    */

    .laptop .nvm-products-carousel > .row.row {
        flex-direction: row;
        align-items: flex-end;
        gap: 0;
        margin-left: 0;
        margin-right: 0;
        margin-bottom: 70px;
    }

    .laptop .nvm-products-carousel__spacer {
        display: block;
    }

    .desktop .nvm-products-carousel > .row.row {
        margin-bottom: 110px;
    }

    .desktop .nvm-products-carousel__intro {
        gap: 50px;
    }

    .desktop .nvm-products-carousel__view-all {
        margin-top: -30px;
    }

    .desktop .nvm-products-carousel__description {
        flex-basis: 530px;
    }

    .desktop .nvm-products-carousel__slide {
        flex-basis: 345px;
        max-width: 345px;
    }
