/**
 * Módulo Scroll Horizontal (scrollx) — Pack Widgets Avançado
 *
 * Transforma qualquer container do Elementor numa pista de rolagem lateral,
 * com rolagem NATIVA do navegador: nenhuma biblioteca, nenhum JS por quadro.
 * Tudo o que o painel configura chega aqui como variável CSS.
 *
 * Dois seletores em toda regra da pista, sempre: o container "Em caixa"
 * (.e-con-boxed) guarda os filhos numa div interna (.e-con-inner) e é ELA que
 * rola; o "Largura total" guarda os filhos direto. Mirar só o container deixa
 * o modo caixa sem efeito nenhum — e sem erro, o que torna difícil perceber.
 * .e-con-inner só existe no modo caixa, por isso o par abaixo cobre os dois.
 */

/* Interruptor por dispositivo.
 *
 * O controle "Ativar neste dispositivo" grava, dentro da media query de cada
 * breakpoint, o bloco inteiro de variáveis abaixo — ligado com os valores da
 * pista, desligado com as variáveis do PRÓPRIO Elementor (--display,
 * --flex-direction, --flex-wrap, --overflow, --row-gap/--column-gap, conferidas
 * na v3.30). É assim que o container volta a ser um container normal num
 * dispositivo e obedece de novo à Direção e ao Envolver do painel — as regras
 * abaixo usam !important e, sem esse desvio, não haveria como sair delas.
 *
 * Em :where() de propósito: especificidade zero deixa qualquer regra do
 * Elementor (0,1,0) ganhar destes padrões, que só servem de rede de segurança
 * para container salvo antes desta versão. */
:where(.pwax-ativo){
	--pwax-display: flex;
	--pwax-direcao: row;
	--pwax-wrap: nowrap;
	--pwax-overflow-x: auto;
	--pwax-overflow-y: hidden;
	--pwax-espaco: var(--pwax-gap);
	--pwax-encolher: 0;
	--pwax-item-largura: var(--pwax-item);
	--pwax-encaixe: var(--pwax-snap);
	--pwax-alinhar: stretch;
	--pwax-seta-exibir: var(--pwax-seta-escolha, flex);
	--pwax-ind-exibir: block;
	--pwax-mask-on: linear-gradient(to right, transparent 0, #000 var(--pwax-fade), #000 calc(100% - var(--pwax-fade)), transparent 100%);
	--pwax-mask: var(--pwax-mask-on);
}

.pwax-ativo{
	--pwax-item: clamp(280px, 32%, 400px);
	--pwax-gap: 20px;
	--pwax-snap: x proximity;
	--pwax-fade: 32px;

	--pwax-barra-altura: 8px;
	--pwax-barra-espaco: 0px;   /* distância entre os cards e a barra */
	--pwax-barra-recuo: 0px;    /* recuo lateral da barra */
	--pwax-barra-trilho: transparent;
	--pwax-barra-polegar: rgba(0,0,0,.35);
	--pwax-barra-raio: 99px;

	--pwax-seta-escolha: flex;
	--pwax-seta-tam: 40px;
	--pwax-seta-icone: 18px;
	--pwax-seta-desloc: 8px;   /* deslocamento X (distância da borda) */
	--pwax-seta-y: 0px;        /* deslocamento Y */
	--pwax-seta-anc: 50%;      /* ancoragem vertical: 0% topo, 50% meio, 100% base */
	--pwax-seta-cor: #ffffff;
	--pwax-seta-fundo: rgba(0,0,0,.55);
	--pwax-seta-cor-hover: #ffffff;
	--pwax-seta-fundo-hover: rgba(0,0,0,.8);
}

/* ─── A pista ─────────────────────────────────────────────────────────────── */

.pwax-ativo:not(.e-con-boxed),
.pwax-ativo > .e-con-inner{
	display: var(--pwax-display) !important;
	flex-direction: var(--pwax-direcao) !important;
	flex-wrap: var(--pwax-wrap) !important;
	align-items: var(--pwax-alinhar);
	gap: var(--pwax-espaco);

	/* !important: o controle "Overflow" do Elementor grava overflow:hidden no
	   mesmo elemento e mataria a rolagem sem aviso nenhum. */
	overflow-x: var(--pwax-overflow-x) !important;
	overflow-y: var(--pwax-overflow-y) !important;
	-webkit-overflow-scrolling: touch;

	/* Impede que o swipe lateral "vaze" e vire navegação para trás no celular. */
	overscroll-behavior-x: contain;

	scroll-snap-type: var(--pwax-encaixe);
}

/* As propriedades PADRÃO (scrollbar-width/scrollbar-color) desligam os
   pseudo-elementos ::-webkit-scrollbar no Chrome inteiro do elemento: basta uma
   delas com valor não-inicial para a altura, a cor e o arredondamento daqui
   serem ignorados em silêncio — foi por isso que o controle de altura da barra
   não fazia nada. Ficam então só no Firefox, que não conhece o seletor. */
@supports not selector(::-webkit-scrollbar){
	.pwax-ativo:not(.e-con-boxed),
	.pwax-ativo > .e-con-inner{
		scrollbar-width: thin;
		scrollbar-color: var(--pwax-barra-polegar) var(--pwax-barra-trilho);
	}
}

/* ─── Os itens ────────────────────────────────────────────────────────────── */

/* O que cria a pista maior que a tela é NÃO encolher; fixar a largura aqui
   faria o controle de largura do próprio item (painel do Elementor) ser
   ignorado — foi o que aconteceu na primeira versão deste CSS.
   Nada de flex-grow nem max-width aqui de propósito: são controles do painel de
   cada item, e mexer neles tiraria do utilizador o que ele já configurou. */
.pwax-ativo:not(.e-con-boxed) > .elementor-element,
.pwax-ativo > .e-con-inner > .elementor-element{
	flex-shrink: var(--pwax-encolher) !important;
	scroll-snap-align: start;
}

/* Só quem NÃO tem largura definida no painel cai na largura do módulo.
   :where() zera a especificidade DE PROPÓSITO: widget dentro de container não
   recebe largura nenhuma do Elementor (conferido na 3.30 e na 4.1 — só
   min-width:0 e max-width:100%), então tudo o que vier do painel do item
   (Avançado > Largura, 0,1,0) ganha desta regra sem disputa. É o que faz a
   largura definida só no celular continuar valendo só no celular — sniffar as
   classes elementor-widget__width-* deixava passar as variantes -tablet- e
   -mobile- e o módulo atropelava a escolha do utilizador. */
:where(.pwax-ativo:not(.e-con-boxed) > .elementor-widget),
:where(.pwax-ativo > .e-con-inner > .elementor-widget){
	width: var(--pwax-item-largura);
}

/* Container aninhado nasce com --width:100% do próprio Elementor, então não há
   como distinguir "o usuário escolheu 100%" de "não escolheu nada": para ele a
   largura do módulo só entra no modo forçado. */
.pwax-largura-forcar:not(.e-con-boxed) > .elementor-element,
.pwax-largura-forcar > .e-con-inner > .elementor-element{
	--width: var(--pwax-item);
	--container-widget-width: var(--pwax-item);
	width: var(--pwax-item) !important;
	max-width: var(--pwax-item) !important;
}

/* ─── Barra de rolagem ────────────────────────────────────────────────────── */

/* Todas as partes declaradas, com !important: tema que estiliza barra de
   rolagem global (`*::-webkit-scrollbar`) deixa aparecer o que não for
   redeclarado aqui — inclusive os botõezinhos de seta nas pontas, que só
   existem em barra personalizada. */
/* O espaço entre os cards e a barra é feito DENTRO da própria barra: ela
   reserva altura + espaço, e o trilho/indicador recuam essa faixa com uma borda
   transparente (background-clip: padding-box). Fazer com padding na pista
   apagaria o Preenchimento configurado no painel do container, e com margem nos
   itens brigaria com a faixa das setas "abaixo da pista". */
.pwax-ativo:not(.e-con-boxed)::-webkit-scrollbar,
.pwax-ativo > .e-con-inner::-webkit-scrollbar{
	height: calc(var(--pwax-barra-altura) + var(--pwax-barra-espaco)) !important;
	background: transparent !important;
}

.pwax-ativo:not(.e-con-boxed)::-webkit-scrollbar-button,
.pwax-ativo > .e-con-inner::-webkit-scrollbar-button{
	display: none !important;
	width: 0 !important;
	height: 0 !important;
}

.pwax-ativo:not(.e-con-boxed)::-webkit-scrollbar-track,
.pwax-ativo:not(.e-con-boxed)::-webkit-scrollbar-track-piece,
.pwax-ativo > .e-con-inner::-webkit-scrollbar-track,
.pwax-ativo > .e-con-inner::-webkit-scrollbar-track-piece{
	background: var(--pwax-barra-trilho) !important;
	border: 0 !important;
	border-top: var(--pwax-barra-espaco) solid transparent !important;
	background-clip: padding-box !important;
	box-shadow: none !important;
	border-radius: var(--pwax-barra-raio) !important;
	/* Recuo lateral: margem no trilho encolhe a barra inteira, porque o
	   indicador não passa dos limites dele. */
	margin-inline: var(--pwax-barra-recuo) !important;
}

.pwax-ativo:not(.e-con-boxed)::-webkit-scrollbar-thumb,
.pwax-ativo > .e-con-inner::-webkit-scrollbar-thumb{
	background: var(--pwax-barra-polegar) !important;
	border: 0 !important;
	border-top: var(--pwax-barra-espaco) solid transparent !important;
	background-clip: padding-box !important;
	box-shadow: none !important;
	border-radius: var(--pwax-barra-raio) !important;
}

.pwax-barra-nao:not(.e-con-boxed),
.pwax-barra-nao > .e-con-inner{ scrollbar-width: none; }

.pwax-barra-nao:not(.e-con-boxed)::-webkit-scrollbar,
.pwax-barra-nao > .e-con-inner::-webkit-scrollbar{ display: none !important; height: 0 !important; }

/* ─── Bordas desbotadas ───────────────────────────────────────────────────── */

/* Sob classe própria de propósito: máscara sempre ligada cria camada de
   composição mesmo quando o tamanho é 0. */
.pwax-fade-sim:not(.e-con-boxed),
.pwax-fade-sim > .e-con-inner{
	/* Pela variável, para o interruptor por dispositivo poder anulá-la: com a
	   máscara fixa, o container desligado continuava com as bordas desbotadas
	   sem ter mais o que rolar. */
	-webkit-mask-image: var(--pwax-mask);
	        mask-image: var(--pwax-mask);
}

/* ─── Setas ───────────────────────────────────────────────────────────────── */

/* As setas ficam DENTRO da pista, como item de largura zero em position:sticky.
   Parece rebuscado, mas é o único jeito sem JS por quadro: em elemento com
   overflow, filho position:absolute rola junto com o conteúdo — a seta fugiria
   para fora da tela ao arrastar. O sticky gruda na borda do próprio scroller.
   A largura zero (mais o gap negativo) impede que a seta ocupe espaço na
   pista; o botão visível é o <span> filho, posicionado a partir dessa âncora. */
/* Reset blindado, com !important e cobrindo os estados.
   O <button> é território de tema e de kit do Elementor: eles estilizam
   `button` cru com seletores do tipo `.elementor-kit-123 button` (0,1,1), que
   ganham de `.pwax-seta` (0,1,0). O sintoma foi exatamente esse — fundo e borda
   estranhos em volta da seta, e mudança de forma ao chegar no fim, quando o
   `button:disabled` do tema entrava. Como este elemento é 100% do módulo (não
   existe nada aqui para o utilizador estilizar por fora), tomar a propriedade à
   força é seguro; o que ele configura no painel vive no <span> de dentro. */
.pwax-seta,
.pwax-seta:hover,
.pwax-seta:focus,
.pwax-seta:active,
.pwax-seta.pwax-fim{
	position: sticky !important;
	z-index: 2 !important;
	/* Âncora esticada na altura da pista (e largura zero): é o que permite
	   ancorar a seta no topo, no meio ou na base — com altura zero, o `top` do
	   botão não teria referência nenhuma para calcular a porcentagem. */
	align-self: stretch !important;
	flex: 0 0 0px !important;
	width: 0 !important;
	height: auto !important;
	min-width: 0 !important;
	min-height: 0 !important;
	max-width: none !important;
	padding: 0 !important;
	margin-block: 0 !important;
	border: 0 !important;
	border-radius: 0 !important;
	background: none !important;
	box-shadow: none !important;
	outline: none !important;
	filter: none !important;
	opacity: 1 !important;
	transform: none !important;
	overflow: visible !important;
	display: var(--pwax-seta-exibir) !important;
	scroll-snap-align: none;
	cursor: pointer;
	font: inherit;
	color: inherit;
	text-transform: none;
	letter-spacing: normal;
	line-height: 1;
}

.pwax-seta--ant{  left:  var(--pwax-seta-desloc) !important; margin-inline-end:   calc(var(--pwax-gap) * -1) !important; }
.pwax-seta--prox{ right: var(--pwax-seta-desloc) !important; margin-inline-start: calc(var(--pwax-gap) * -1) !important; }

.pwax-seta > span{
	position: absolute;
	/* top posiciona pela altura da âncora, o translate corrige pela altura do
	   próprio botão: com os dois na mesma variável, 0% cola no topo, 50%
	   centraliza e 100% cola na base — e o Y desloca a partir daí. */
	top: var(--pwax-seta-anc);
	transform: translateY(calc(var(--pwax-seta-y) - var(--pwax-seta-anc)));
	display: flex;
	align-items: center;
	justify-content: center;
	width: var(--pwax-seta-tam);
	height: var(--pwax-seta-tam);
	border: 0;
	border-radius: 50%;
	color: var(--pwax-seta-cor);
	background: var(--pwax-seta-fundo);
	font-size: var(--pwax-seta-icone);
	line-height: 1;
	transition: background .2s ease, color .2s ease, opacity .2s ease;
}

/* Âncora tem largura zero: a "anterior" cresce para a direita, a "próxima"
   para a esquerda — assim nenhuma das duas nasce fora da área visível. */
.pwax-seta--ant  > span{ left: 0; }
.pwax-seta--prox > span{ right: 0; }

.pwax-seta:hover > span,
.pwax-seta:focus-visible > span{
	color: var(--pwax-seta-cor-hover);
	background: var(--pwax-seta-fundo-hover);
}

/* O outline do foco tem de sair no <span>: o botão em si mede 0×0 e o anel do
   navegador viraria um pontinho solto ao lado da seta. */
.pwax-seta:focus-visible > span{
	outline: 2px solid currentColor;
	outline-offset: 2px;
}

.pwax-seta > span i{ font-size: inherit; line-height: 1; }
.pwax-seta > span img,
.pwax-seta > span svg{ width: var(--pwax-seta-icone); height: var(--pwax-seta-icone); }

/* ── Posição "Reservar espaço" ──────────────────────────────────────────────
   Abre uma faixa vazia nas pontas da pista para a seta não cobrir o primeiro
   nem o último card. O scroll-padding tem de acompanhar, senão o encaixe
   estaciona o card exatamente debaixo da seta — o problema que a faixa veio
   resolver. !important porque o Elementor zera o padding lateral do
   .e-con-inner com especificidade igual à daqui, e a ordem das folhas não é
   garantida. */
.pwax-setapos-reservar:not(.e-con-boxed),
.pwax-setapos-reservar > .e-con-inner{
	--pwax-faixa: calc(var(--pwax-seta-tam) + var(--pwax-seta-desloc) + 8px);
	scroll-padding-inline: var(--pwax-faixa);
}

/* A faixa sai como MARGEM nas âncoras das setas, não como padding da pista.
   Duas tentativas antes desta falharam pelo mesmo motivo: o offset do
   position:sticky conta a partir da content box (já depois do padding), e o
   sticky nunca move o elemento para antes da posição natural dele — com
   padding, a seta começava em cima do primeiro card e só ia para o lugar certo
   depois que a rolagem começava. Como âncora, ela é o primeiro/último item da
   pista: a margem afasta o card e a seta fica na faixa desde o início.
   A conta desconta o gap porque ele já separa a âncora do card. */
.pwax-setapos-reservar .pwax-seta--ant{
	margin-inline-end: calc(var(--pwax-faixa) - var(--pwax-gap)) !important;
}
.pwax-setapos-reservar .pwax-seta--prox{
	margin-inline-start: calc(var(--pwax-faixa) - var(--pwax-gap)) !important;
}

/* ── Faixa reservada no rodapé da pista ─────────────────────────────────────
   Duas coisas podem querer espaço embaixo dos cards: a seta na posição
   "abaixo" e o indicador próprio. Cada uma declara a SUA reserva numa variável
   e a margem soma as duas — se cada uma escrevesse margin-block-end por conta,
   a segunda apagaria a primeira. A regra só existe sob essas classes: aplicar
   margem a todo item sempre apagaria a Margem que o utilizador configurou no
   painel de cada card.
   As variáveis vão em :where(), com especificidade zero, para que o interruptor
   por dispositivo (que escreve no {{WRAPPER}}, 0,1,0) consiga zerar as reservas
   quando o módulo está desligado naquele breakpoint. Sem isso o container
   voltava ao normal mas os cards continuavam com a faixa reservada embaixo.

   Dois níveis de variável de propósito. As terminadas em "-on" guardam o que
   cada opção pede, e vêm de classe — logo, iguais em todos os dispositivos. As
   sem sufixo são as que o CSS usa, e é nelas que o interruptor por dispositivo
   manda: ligado, apontam para a "-on"; desligado, viram zero. Sem esse segundo
   nível, o bloco "desligado" do desktop (que não está em media query) zeraria
   a faixa também no celular, onde o módulo está ligado — e as setas cairiam em
   cima dos cards. */
:where(.pwax-ativo){
	--pwax-res-topo-on: 0px;
	--pwax-res-seta-on: 0px;
	--pwax-res-barra-on: 0px;

	--pwax-res-topo: var(--pwax-res-topo-on);
	--pwax-res-seta: var(--pwax-res-seta-on);
	--pwax-res-barra: var(--pwax-res-barra-on);
}
:where(.pwax-setapos-acima){ --pwax-res-topo-on: var(--pwax-faixa-v); }
:where(.pwax-setapos-abaixo){ --pwax-res-seta-on: var(--pwax-faixa-v); }
:where(.pwax-barra-propria){ --pwax-res-barra-on: calc(var(--pwax-barra-altura) + var(--pwax-barra-espaco)); }

.pwax-setapos-abaixo:not(.e-con-boxed) > .elementor-element,
.pwax-setapos-abaixo > .e-con-inner > .elementor-element,
.pwax-barra-propria:not(.e-con-boxed) > .elementor-element,
.pwax-barra-propria > .e-con-inner > .elementor-element{
	margin-block-end: calc(var(--pwax-res-seta) + var(--pwax-res-barra)) !important;
}

/* ── Indicador próprio ──────────────────────────────────────────────────────
   No celular a barra nativa é overlay: aparece durante a rolagem e some — e no
   iOS nem aceita estilização. Este indicador é desenhado pelo módulo, então é
   igual em qualquer plataforma.
   A âncora repete o truque das setas (item de largura zero em position:sticky)
   porque filho absoluto dentro de elemento com overflow viaja com a rolagem.
   A largura da barra vem do JS, em pixels: a âncora tem largura zero, então
   porcentagem aqui daria zero. */
.pwax-ind{
	/* Desligado no dispositivo, o indicador tem de sumir junto: senão ele fica
	   como item solto no meio do container, que a essa altura já voltou a ser
	   um container normal (e provavelmente com os itens quebrados em linhas). */
	display: var(--pwax-ind-exibir);
	position: sticky;
	left: 0;
	z-index: 1;
	align-self: stretch;
	flex: 0 0 0px;
	width: 0;
	overflow: visible;
	pointer-events: none;
	margin-inline-end: calc(var(--pwax-gap) * -1);
}
.pwax-ind > i{
	position: absolute;
	bottom: 0;
	left: var(--pwax-barra-recuo);
	display: block;
	height: var(--pwax-barra-altura);
	background: var(--pwax-barra-trilho);
	border-radius: var(--pwax-barra-raio);
}
.pwax-ind > i > b{
	position: absolute;
	inset-block: 0;
	left: 0;
	display: block;
	background: var(--pwax-barra-polegar);
	border-radius: inherit;
	will-change: transform;
}

/* Com indicador próprio, a barra nativa sai de cena. */
.pwax-barra-propria:not(.e-con-boxed),
.pwax-barra-propria > .e-con-inner{ scrollbar-width: none; }

.pwax-barra-propria:not(.e-con-boxed)::-webkit-scrollbar,
.pwax-barra-propria > .e-con-inner::-webkit-scrollbar{ display: none !important; height: 0 !important; }

/* ── Posições "Acima da pista" e "Abaixo da pista" ──────────────────────────
   A faixa das pontas ("reservar") só livra o PRIMEIRO e o ÚLTIMO card: no meio
   da rolagem os cards passam por baixo da seta, porque a seta é sticky dentro
   do scroller e a faixa horizontal rola junto com o conteúdo. Faixa no eixo
   VERTICAL não rola — a pista só rola na horizontal —, então é a única posição
   que garante seta nunca sobre card num container de largura total.
   A faixa é margem nos ITENS, não padding da pista: padding aqui apagaria o
   Preenchimento que o utilizador configurou no painel do container. */
.pwax-setapos-acima,
.pwax-setapos-abaixo{
	--pwax-faixa-v: calc(var(--pwax-seta-tam) + 12px);
}

.pwax-setapos-acima:not(.e-con-boxed) > .elementor-element,
.pwax-setapos-acima > .e-con-inner > .elementor-element{
	/* Pela variável, e não pelo --pwax-faixa-v direto: é o que permite ao
	   interruptor por dispositivo zerar a faixa. Enquanto isto estava fixo, o
	   container desligado no desktop mantinha 52px de margem acima de CADA
	   card — o "espaçamento de linha que não acompanha a configuração". */
	margin-block-start: var(--pwax-res-topo) !important;
}
.pwax-setapos-acima .pwax-seta > span{
	top: 0 !important;
	transform: translateY(calc(6px + var(--pwax-seta-y))) !important;
}

/* A margem dos itens é declarada uma vez só, na regra da faixa do rodapé (mais
   acima) — aqui fica só onde a seta se põe DENTRO dessa faixa, acima do que o
   indicador tiver reservado. */
.pwax-setapos-abaixo .pwax-seta > span{
	top: 100% !important;
	transform: translateY(calc(6px - var(--pwax-res-seta) - var(--pwax-res-barra) + var(--pwax-seta-y))) !important;
}

/* ── Posição "Fora do container" ────────────────────────────────────────────
   Só existe quando o JS confirma que dá: no modo "Em caixa" quem rola é o
   .e-con-inner, então a seta pode morar no container de fora, em position
   absolute, sem ser cortada pelo overflow nem viajar com a rolagem. Em
   "Largura total" o container É o elemento que rola e isso é impossível — o JS
   não põe a classe e a seta continua sticky, dentro da pista.
   top/bottom esticam a âncora na altura do container para a ancoragem
   vertical continuar valendo igual à do modo de dentro. */
.pwax-setas-soltas > .pwax-seta{
	position: absolute !important;
	top: 0 !important;
	bottom: 0 !important;
	height: auto !important;
	align-self: auto !important;
	margin: 0 !important;
	z-index: 3 !important;
}
/* A seta sai da borda do .e-con-inner, NÃO da do container.
   No modo "Em caixa" quem tem largura limitada é o inner; o container de fora
   continua ocupando a página inteira. Mandar a seta para fora dele punha-a
   fora da tela — ela simplesmente não aparecia. A faixa entre uma borda e
   outra é (100% - largura do conteúdo) / 2, e é dentro dela que a seta cabe.
   O max(0px, …) segura o caso em que não há faixa (tela estreita, conteúdo
   ocupando 100%): a seta encosta na borda em vez de sumir. */
.pwax-setas-soltas{
	--pwax-margem-inner: max(0px, calc((100% - var(--content-width, 100%)) / 2));
	--pwax-recuo-solto: max(0px, calc(var(--pwax-margem-inner) - var(--pwax-seta-tam) - var(--pwax-seta-desloc)));
}
.pwax-setas-soltas > .pwax-seta--ant{
	left: var(--pwax-recuo-solto) !important;
	right: auto !important;
}
.pwax-setas-soltas > .pwax-seta--prox{
	right: var(--pwax-recuo-solto) !important;
	left: auto !important;
}

/* Fim da pista: o botão apaga, mas o espaço continua reservado — some o
   "pula-pula" de layout a cada rolagem.
   É classe + aria-disabled, e não o atributo `disabled`, justamente para não
   acordar o `button:disabled` do tema, que trocava a forma da seta ao chegar
   no fim. Quem barra o clique é o JS. */
.pwax-seta.pwax-fim{ cursor: default; }
.pwax-seta.pwax-fim > span{ opacity: .25; }
.pwax-sem-rolagem .pwax-seta{ display: none !important; }

/* ─── Arrasto com o mouse ─────────────────────────────────────────────────── */

.pwax-arrastando:not(.e-con-boxed),
.pwax-arrastando > .e-con-inner{
	cursor: grabbing;
	user-select: none;
}
/* Enquanto arrasta, soltar o mouse em cima de um card não pode virar clique. */
.pwax-arrastando a,
.pwax-arrastando button:not(.pwax-seta){ pointer-events: none; }

@media (prefers-reduced-motion: reduce){
	.pwax-seta > span{ transition: none; }
}