/* ═══════════════════════════════════════════════════════════════════════════
   COMPILA · CENAS — a continuação da abertura pelo site inteiro
   ---------------------------------------------------------------------------
   A abertura termina com a câmera ATRAVESSANDO a tela do notebook: "e então
   você entra". Até aqui o site contradizia essa promessa — dois pixels depois
   começava uma página empilhada comum. Este arquivo faz o resto do site
   acontecer DENTRO da máquina.

   Três mecanismos, e nenhum deles custa JavaScript por quadro:

   1) UM AMBIENTE SÓ. O chão em grade e a poça de luz da abertura não morrem
      nela: viram a camada de fundo do site, mudando de temperatura por ato.

   2) HANDOFF EM VEZ DE CORTE. Cada seção entrega um objeto para a seguinte em
      vez de simplesmente sumir. A constelação da abertura vira o mapa; a
      partícula do mapa cai nos cartões; um cartão vira a etapa 01.

   3) VIZINHAS NUNCA REPETEM O ESQUELETO. Duas grades seguidas com a mesma
      entrada fazem o visitante sentir o mesmo molde carimbado duas vezes. Por
      isso os cartões do catálogo chegam da profundidade e os dos desafios
      chegam pelos lados.

   Tudo aqui é transform e opacity. E a variável raspada é escrita o mais
   PERTO possível de quem a usa, nunca num container para os filhos herdarem:
   invalidar uma propriedade herdada obriga o navegador a recalcular a
   subárvore inteira, e nesta página isso custava sete vezes mais caro do que
   escrever uma por uma nas folhas (8,86 ms contra 1,26 ms por quadro).
   ═════════════════════════════════════════════════════════════════════════ */

/* ═════════════════════════════════════════════════════════════════════════
   O AMBIENTE — uma camada só, atrás de tudo
   ---------------------------------------------------------------------------
   As três camadas fixas de tela cheia do compila-world.css pediam
   `will-change: transform` e nunca animavam nada: camada de composição
   permanente em troca de zero movimento. Aqui elas devolvem a promoção.
   ═════════════════════════════════════════════════════════════════════════ */
body::before,
body::after,
.pixel-grid-overlay{ will-change: auto }

/* O chão da abertura, continuando por baixo do site. Fica bem apagado: a
   função dele é dizer "você ainda está no mesmo lugar", não chamar atenção. */
body::before{
  background-image:
    linear-gradient(rgba(79,195,247,.030) 1px, transparent 1px),
    linear-gradient(90deg, rgba(79,195,247,.030) 1px, transparent 1px),
    radial-gradient(ellipse 60% 45% at 15% 8%,  rgba(124,58,237,.22), transparent 60%),
    radial-gradient(ellipse 55% 40% at 88% 18%, rgba(79,195,247,.14), transparent 60%),
    radial-gradient(ellipse 50% 45% at 50% 95%, rgba(217,70,239,.10), transparent 60%);
  background-size: 54px 54px, 54px 54px, auto, auto, auto;
}

/* Cada seção é uma câmara do mesmo espaço: a perspectiva mora AQUI, uma por
   seção, para que os filhos dividam um ponto de fuga só. Perspectiva por
   cartão dá a cada um o seu próprio universo, e o 3D compartilhado acaba. */
#jornada, #trilhas, #trilha-aprendizado, #playground, #tutor-ia,
#desafios, #progresso, #projetos, #galeria, #beneficios,
#numeros, #feedback, #planos{
  perspective: var(--persp);
  perspective-origin: 50% 42%;
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO I · #jornada — o mapa ganha vida
   ---------------------------------------------------------------------------
   O caminho pontilhado continua sendo o mapa inteiro: você vê aonde dá para
   ir. Por cima dele, um traço aceso desenha o quanto você já avançou, e uma
   partícula percorre esse traço. É o princípio do café: o movimento desce
   porque o dedo desce.
   ═════════════════════════════════════════════════════════════════════════ */
/* O seletor precisa do `path` junto: o <style> da página declara
   `.journey-path path { stroke-dasharray: 2 12; opacity: .6 }`, que é uma
   classe MAIS um tipo. Só `.jornada-aceso` perdia a disputa e o traço
   continuava pontilhado e apagado — o desenho progressivo nunca aparecia,
   mesmo com o dashoffset certo. */
.journey-path path.jornada-aceso{
  fill: none;
  stroke: var(--cyan);
  stroke-width: 3.4;
  stroke-linecap: round;
  opacity: 1;
  filter: drop-shadow(0 0 6px rgba(79,195,247,.55));
  stroke-dasharray: var(--len, 2400);
  stroke-dashoffset: calc(var(--len, 2400) * (1 - var(--k, 0)));
}

/* A partícula: um grupo só, movido por transform. O JS calcula o ponto sobre
   a curva e a opacidade; o CSS cuida da aparência. */
.jornada-particula{ opacity: 0 }
.jornada-particula circle:first-child{ fill: var(--cyan); opacity: .22 }
.jornada-particula circle:last-child { fill: #eafcff }

/* Os nós acendem na ordem em que a partícula passa.
   ---------------------------------------------------------------------------
   O --aceso é escrito pelo JS DIRETO em cada ponto e em cada rótulo, e não
   herdado de uma variável no container. Parece desperdício e é o contrário:
   medido nesta página, uma escrita no `.journey-wrap` custa 8,86 ms por
   quadro, porque invalidar uma propriedade herdada obriga o navegador a
   recalcular o estilo da subárvore INTEIRA. Dezesseis escritas nas folhas
   custam 1,26 ms — sete vezes menos, pelo mesmo resultado na tela.

   A regra que fica: variável raspada mora o mais perto possível de quem a
   usa. Sem --aceso (JS fora do ar), tudo nasce aceso. */
/* Os nós DESCEM para o lugar, não sobem. A constelação que a abertura
   desenha fica acima, e é de lá que eles vêm — o movimento continua o da
   rolagem em vez de brigar com ele. É o princípio do café: o dedo desce, a
   cena desce.

   Só transform e opacity aqui dentro. A primeira versão acendia o nó com
   `color-mix()` no border-color, o que parecia elegante e custava 14,21 ms
   por quadro: cor é PINTURA, e o navegador precisa repintar oito nós a cada
   passo da rolagem. A borda acesa virou um ::after que já nasce na cor certa
   e só troca de opacidade — o compositor resolve sozinho, de graça. */
.jmap-dot{
  position: relative;
  transform: translateY(calc((1 - var(--aceso, 1)) * -18px * var(--forca)))
             scale(calc(.86 + .14 * var(--aceso, 1)));
  opacity: calc(.42 + .58 * var(--aceso, 1));
  border-color: rgba(148,163,184,.30);        /* o apagado, e é estático */
}
.jmap-dot::after{
  content: "";
  position: absolute; inset: -2px;
  border: 2px solid var(--node-color);
  border-radius: inherit;
  opacity: var(--aceso, 1);                      /* a única coisa que muda */
  pointer-events: none;
}
.jmap-label{ opacity: calc(.25 + .75 * var(--aceso, 1)) }

/* O nó final é o destino: quando a partícula chega nele, ele acende mais
   forte que os outros. O brilho mora no ::after em força total e entra pela
   opacidade dele — nunca por um box-shadow recalculado por quadro. */
.jmap-node--final .jmap-dot::after{ box-shadow: 0 0 26px var(--node-color) }

@media (max-width: 760px){
  /* No celular o mapa vira lista e o traço não existe. Os nós continuam
     acendendo em sequência: a sensação de percurso é preservada, o custo de
     desenhar a curva não. */
  .jornada-particula{ display: none }
  .jmap-dot{ transform: translateY(calc((1 - var(--aceso, 1)) * -10px)) }
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO II · #trilhas — os cartões chegam de três profundidades
   ---------------------------------------------------------------------------
   Não é fila indiana: eles vinham todos do mesmo lugar e chegavam iguais.
   Agora vêm de distâncias diferentes e se organizam na grade, como peças
   encontrando o lugar delas.
   ═════════════════════════════════════════════════════════════════════════ */
/* Só variáveis. O transform em si mora no motor.css, e é isso que deixa a
   regra de chegada (.m-in) continuar ganhando na cascata. */
#trilhas .course-grid > *:nth-child(3n+1){ --fundura: 1.55; --m-ry:  5deg }
#trilhas .course-grid > *:nth-child(3n+2){ --fundura: .70;  --m-ry:  0deg }
#trilhas .course-grid > *:nth-child(3n)  { --fundura: 1.20; --m-ry: -5deg }

/* ═════════════════════════════════════════════════════════════════════════
   ATO II · #trilha-aprendizado — a linha se desenha e as etapas acendem
   ═════════════════════════════════════════════════════════════════════════ */
/* A transição de 1,3s saiu: agora a linha é a rolagem, não um cronômetro.
   O seletor precisa do id porque o sistema antigo escreve o estado final em
   `.path-track.in-view .path-line-fill`, que são três classes — sem o id,
   aquela regra ganharia e a linha voltaria a ser um cronômetro. */
#trilha-aprendizado .path-track .path-line-fill{
  transition: none;
  transform: scaleY(var(--k, 1));
}
/* Mesma disciplina do mapa: o --aceso de cada etapa é escrito pelo JS no
   número e no corpo dela, não herdado do .path-track. */
/* Mesma disciplina do mapa: a borda acesa é um ::after em cor fixa, e só a
   opacidade dele anda com a rolagem. */
.path-step__num{
  position: relative;
  transform: scale(calc(.8 + .2 * var(--aceso, 1)));
  opacity: calc(.5 + .5 * var(--aceso, 1));
}
.path-step__num::after{
  content: "";
  position: absolute; inset: -2px;
  border: 2px solid var(--cyan);
  border-radius: 50%;
  opacity: var(--aceso, 1);
  pointer-events: none;
}
.path-step__body{
  opacity: calc(.3 + .7 * var(--aceso, 1));
  transform: translateX(calc((1 - var(--aceso, 1)) * 18px * var(--forca)));
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO III · #playground — o painel LIGA, como a tela do notebook
   ---------------------------------------------------------------------------
   A barra de título acende antes do conteúdo, igual ao ato 02 da abertura.
   O painel em si tem data-sem-transicao: dentro dele a pessoa digita, e nada
   pode fugir de baixo do cursor.
   ═════════════════════════════════════════════════════════════════════════ */
#playground .playground-panel{
  transition: box-shadow var(--t-cena) var(--e-chega),
              border-color var(--t-cena) var(--e-chega);
}
#playground.ligado .playground-panel{
  box-shadow: var(--luz-sutil), 0 30px 80px rgba(0,0,0,.45);
  border-color: rgba(79,195,247,.28);
}
/* a luzinha verde do cabeçalho só acende quando a seção chega */
#playground .pg-run-row .btn{ transition: transform var(--t-micro) var(--e-toque) }

/* ═════════════════════════════════════════════════════════════════════════
   ATO III · #playground — a interface LIGA em três tempos
   ---------------------------------------------------------------------------
   Barra de título, depois o editor, depois o console. É o mesmo gesto do ato
   02 da abertura: a tela acende antes de ter conteúdo.

   Aqui é ENTRADA, não raspagem. O painel tem data-sem-transicao porque a
   pessoa digita dentro dele; uma chegada única que termina e nunca mais se
   mexe é segura, uma que acompanha a rolagem faria o editor fugir de baixo
   do cursor.
   ═════════════════════════════════════════════════════════════════════════ */
#playground .pg-barra,
#playground .pg-side,
#playground .pg-out{
  opacity: 0;
  transform: translateY(calc(14px * var(--forca)));
  transition: opacity 520ms var(--e-chega), transform 520ms var(--e-chega);
}
#playground.ligado .pg-barra{ opacity: 1; transform: none; transition-delay: 0ms }
#playground.ligado .pg-side{ opacity: 1; transform: none; transition-delay: 160ms }
#playground.ligado .pg-out { opacity: 1; transform: none; transition-delay: 300ms }
#playground.pronto .pg-barra,
#playground.pronto .pg-side,
#playground.pronto .pg-out{ transition-delay: 0ms !important }

#playground .playground-panel{
  transition: box-shadow var(--t-cena) var(--e-chega),
              border-color var(--t-cena) var(--e-chega);
}
#playground.ligado .playground-panel{
  box-shadow: var(--luz-sutil), 0 30px 80px rgba(0,0,0,.45);
  border-color: rgba(79,195,247,.28);
}

/* O sinal de execução: ao rodar, o console dá um pulso de meio grau. É o
   feedback de "aconteceu alguma coisa" sem piscar nada na cara de ninguém.
   Só transform — box-shadow pulsante é repintura por quadro. */
@keyframes pgRodou{
  0%   { transform: scale(1) }
  38%  { transform: scale(1.012) }
  100% { transform: scale(1) }
}
#playground .pg-output-box.ok,
#playground .pg-output-box.fail{ animation: pgRodou .46s var(--e-chega) }

/* ═════════════════════════════════════════════════════════════════════════
   ATO III · #tutor-ia — o terminal se conecta
   ---------------------------------------------------------------------------
   Cabeçalho, a luz de "online", a mensagem, e por último a caixa de digitar.
   Quatro chegadas, uma cena: o painel não aparece pronto, ele LIGA.
   ═════════════════════════════════════════════════════════════════════════ */
#tutor-ia .tutor-barra,
#tutor-ia .tutor-messages > *,
#tutor-ia .tutor-input-row{
  opacity: 0;
  transform: translateY(calc(12px * var(--forca)));
  transition: opacity 500ms var(--e-chega), transform 500ms var(--e-chega);
}
#tutor-ia.ligado .tutor-barra          { opacity: 1; transform: none; transition-delay: 0ms }
#tutor-ia.ligado .tutor-messages > *   { opacity: 1; transform: none; transition-delay: 220ms }
#tutor-ia.ligado .tutor-input-row      { opacity: 1; transform: none; transition-delay: 400ms }
#tutor-ia.pronto .tutor-barra,
#tutor-ia.pronto .tutor-messages > *,
#tutor-ia.pronto .tutor-input-row{ transition-delay: 0ms !important }

/* a luz de "online" acende junto com a barra, e depois respira devagar */
#tutor-ia .tutor-luz{ opacity: .25; transition: opacity 600ms var(--e-chega) 120ms }
#tutor-ia.ligado .tutor-luz{ opacity: 1; animation: tutorRespira 4.5s ease-in-out -1.2s infinite }
@keyframes tutorRespira{ 0%,100%{ opacity: .55 } 50%{ opacity: 1 } }

/* Mensagem nova, depois que a cena já assentou: entra por conta própria.
   A animação original do <style> da página (msgPop) continua valendo. */
#tutor-ia.pronto .tutor-messages > *{ opacity: 1; transform: none }

/* ═════════════════════════════════════════════════════════════════════════
   ATO IV · #projetos — a janela se constrói linha a linha
   ---------------------------------------------------------------------------
   O que você pediu na "seção de código": as linhas aparecem conforme a
   rolagem avança, e o RESULTADO chega depois delas. Na primeira janela são as
   tarefas entrando uma a uma; na segunda, os números chegam e só então as
   barras sobem — o gráfico é a consequência, não o enfeite.

   Cada linha recebe o próprio --a: escrever no .browser-window faria a
   subárvore inteira ser recalculada por quadro, que é o erro caro que o
   mapa já ensinou.
   ═════════════════════════════════════════════════════════════════════════ */
#projetos .browser-bar{
  opacity: calc(.22 + .78 * var(--a, 1));
}
#projetos .browser-title{
  opacity: var(--a, 1);
}
#projetos .mock-todo__row{
  opacity: var(--a, 1);
  transform: translateX(calc((1 - var(--a, 1)) * -16px * var(--forca)));
}
#projetos .mock-dash__card{
  opacity: var(--a, 1);
  transform: translateY(calc((1 - var(--a, 1)) * 12px * var(--forca)));
}
/* a barra cresce do chão: scaleY, nunca height */
#projetos .mock-dash__bars span{
  transform-origin: 50% 100%;
  transform: scaleY(var(--a, 1));
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO III · #desafios — cartas distribuídas, não empilhadas
   ---------------------------------------------------------------------------
   Vizinha de uma grade que já chega da profundidade. Se repetisse a mesma
   entrada, o visitante sentiria o mesmo molde carimbado duas vezes seguidas.
   ═════════════════════════════════════════════════════════════════════════ */
#desafios .challenge-grid > *{
  --fundura: .18;                                   /* raso: a viagem é lateral */
  --m-x: calc(var(--lado-c, 1) * var(--d-card) * 1.5);
  --m-rz: calc(var(--lado-c, 1) * .9deg);
}
#desafios .challenge-grid > *:nth-child(even){ --lado-c: -1 }
#desafios .challenge-grid > *:nth-child(odd) { --lado-c:  1 }

/* No celular a viagem lateral vira vertical. Numa coluna de 375px, um cartão
   de 331px que começa 36px para o lado nasce cortado pela borda da tela — o
   `overflow-x: hidden` do body impede a rolagem horizontal, mas o recorte
   continua aparecendo como tremida na chegada. Descer resolve, e mantém o
   movimento acompanhando a rolagem em vez de brigar com ela. */
@media (max-width: 760px){
  #desafios .challenge-grid > *{
    --m-x: 0px;
    --m-rz: 0deg;
    --fundura: .8;
  }
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO IV · #progresso — a barra de XP enche com a rolagem
   ═════════════════════════════════════════════════════════════════════════ */
#progresso .gami-bar-fill{
  transform-origin: 0 50%;
  transition: none;        /* a barra é a rolagem, não um cronômetro */
}

/* ═════════════════════════════════════════════════════════════════════════
   ATO IV · #galeria — o principal à frente, os outros atrás
   ═════════════════════════════════════════════════════════════════════════ */
#galeria .gallery-grid > *:nth-child(1){ --fundura: .55 }
#galeria .gallery-grid > *:nth-child(2){ --fundura: 1.1 }
#galeria .gallery-grid > *:nth-child(3){ --fundura: 1.5 }
#galeria .gallery-grid > *:nth-child(4){ --fundura: 1.9 }

/* ═════════════════════════════════════════════════════════════════════════
   ATO V · #planos — chegam em sequência, o recomendado assenta à frente
   ---------------------------------------------------------------------------
   Aqui a cena ASSENTA. Nada continua se mexendo embaixo de um formulário de
   pagamento: quem chegou até aqui quer ler preço, não assistir a nada.
   ═════════════════════════════════════════════════════════════════════════ */
#planos .planos-grid > *{ --fundura: 1.25; --m-escala: .94 }

/* Depois de chegar, o cartão passa a responder à escolha e ao ponteiro. A
   transição só é declarada em .m-feito para não brigar com a da entrada. */
#planos .planos-grid > *.m-feito{
  transition: transform var(--t-ui) var(--e-chega),
              box-shadow var(--t-ui) var(--e-chega),
              border-color var(--t-ui) var(--e-chega);
}
/* O escolhido assenta um plano à frente: a escada de Z dizendo "é este".
   Só depois de .m-in — sem isso o cartão recomendado nasceria já no lugar e
   seria o único dos três a não fazer a viagem de chegada. */
#planos .plano-card.m-in.selected{
  transform: translate3d(0, 0, var(--z-perto));
  box-shadow: var(--luz-foco), 0 26px 60px rgba(0,0,0,.5);
}
@media (hover: hover) and (pointer: fine){
  #planos .planos-grid > *.m-feito:hover{ transform: translate3d(0,0,var(--z-perto)) }
}

/* ═════════════════════════════════════════════════════════════════════════
   MICROINTERAÇÕES — o site reage a você, não faz exibição
   ---------------------------------------------------------------------------
   Tudo aqui é `hover: hover` e `pointer: fine`. Num celular não existe hover,
   e pagar por um efeito que nunca acontece é a definição de desperdício.

   O limite: nada disso pode competir com o conteúdo. Se você reparar no
   efeito em vez de reparar no cartão, ele passou do ponto.
   ═════════════════════════════════════════════════════════════════════════ */
@media (hover: hover) and (pointer: fine){

  /* O ícone do cartão respira um triz quando o cartão é apontado. É o
     detalhe que faz o cartão parecer um objeto, e não uma figurinha. */
  .course-card .course-art,
  .course-card .course-icon,
  .challenge-card > span:first-child,
  .gallery-card .gallery-icon,
  .path-step__icon{
    transition: transform var(--t-ui) var(--e-toque);
  }
  .course-card:hover .course-art,
  .course-card:hover .course-icon,
  .challenge-card:hover > span:first-child,
  .gallery-card:hover .gallery-icon{
    transform: scale(1.07) rotate(-2deg);
  }

  /* Glow: mora num ::after em força total, e só a opacidade dele anda.
     Um box-shadow que cresce no hover é repintura a cada quadro da
     transição; a opacidade de uma camada pronta é de graça. */
  .course-card, .challenge-card, .c-card, .gallery-grid > a, .trilha-card{
    position: relative;
  }
  .course-card::after, .challenge-card::after,
  .gallery-grid > a::after{
    content: "";
    position: absolute; inset: -1px;
    border-radius: inherit;
    pointer-events: none;
    opacity: 0;
    transition: opacity var(--t-ui) var(--e-chega);
    box-shadow: 0 0 0 1px rgba(79,195,247,.32), 0 18px 46px rgba(79,195,247,.14);
  }
  .course-card:hover::after, .challenge-card:hover::after,
  .gallery-grid > a:hover::after{ opacity: 1 }

  /* A inclinação ao passar o mouse. O ângulo é pequeno de propósito: cartão
     que gira demais vira brinquedo, e o texto dentro dele fica torto de ler.
     Quatro graus é o bastante para a mão sentir que tem um objeto ali.

     O JS escreve só --tx e --ty; o transform inteiro mora aqui. É o que
     mantém a inclinação, o levantar e a escada de Z numa conta só — três
     regras brigando pelo mesmo transform é como o efeito some sem avisar. */
  .m-inclina.m-feito:hover{
    transform: perspective(900px)
               rotateX(var(--ty, 0deg))
               rotateY(var(--tx, 0deg))
               translate3d(0, -4px, var(--z-perto));
    transition-duration: var(--t-micro);
  }

  /* O nó do mapa já tinha hover próprio; aqui ele ganha o mesmo tempo dos
     outros, para o site inteiro responder na mesma velocidade. */
  .jmap-dot{ transition: transform var(--t-ui) var(--e-chega),
                         box-shadow var(--t-ui) var(--e-chega) }
}

/* Foco visível, na cor do acento: quem navega por teclado precisa ver onde
   está tanto quanto quem usa mouse. */
:focus-visible{
  outline: 2px solid var(--amber);
  outline-offset: 3px;
  border-radius: 4px;
}

/* ═════════════════════════════════════════════════════════════════════════
   MOVIMENTO REDUZIDO — tudo chegado, nada em movimento
   ═════════════════════════════════════════════════════════════════════════ */
@media (prefers-reduced-motion: reduce){
  /* Estado final de tudo. O caminho aparece inteiro desenhado, os nós todos
     acesos, a linha da trilha cheia — a informação continua toda lá, só não
     acontece nada. As variáveis de chegada zeram na origem, então o cartão
     nasce no lugar em vez de precisar de um !important por seção. */
  #trilhas .course-grid > *, #desafios .challenge-grid > *,
  #galeria .gallery-grid > *, #planos .planos-grid > *{
    --fundura: 0 !important; --m-x: 0px !important;
    --m-ry: 0deg !important; --m-rz: 0deg !important; --m-escala: 1 !important;
  }
  .journey-path path.jornada-aceso{ stroke-dashoffset: 0 !important }
  .jornada-particula{ display: none }
  .jmap-node, .path-step{ --aceso: 1 !important }
  .jmap-dot, .path-step__num, .path-step__body{
    transform: none !important; opacity: 1 !important;
  }
  #trilha-aprendizado .path-track .path-line-fill{
    transform: scaleY(1) !important; opacity: 1 !important;
  }
  #playground .playground-panel, #planos .planos-grid > *.m-feito{
    transition: none !important;
  }
  /* as cenas que ligam em etapas nascem ligadas e sem atraso nenhum */
  #playground .pg-barra, #playground .pg-side, #playground .pg-out,
  #tutor-ia .tutor-barra, #tutor-ia .tutor-messages > *, #tutor-ia .tutor-input-row{
    opacity: 1 !important; transform: none !important;
    transition: none !important; transition-delay: 0ms !important;
  }
  #tutor-ia .tutor-luz{ opacity: 1 !important; animation: none !important }
  #playground .pg-output-box.ok,
  #playground .pg-output-box.fail{ animation: none !important }
  /* a janela dos projetos aparece construída */
  #projetos .browser-bar, #projetos .browser-title,
  #projetos .mock-todo__row, #projetos .mock-dash__card{
    opacity: 1 !important; transform: none !important;
  }
  #projetos .mock-dash__bars span{ transform: scaleY(1) !important }
}
