@1doc/1ds-react 0.0.1 → 2.7.1

package/src/teste/Popover.test.tsx

@@ -0,0 +1,221 @@
+import { describe, expect, it, vi, beforeAll } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import Popover from "../components/Popover/Popover";
+import Button from "../components/Button/Button";
+
+/**
+ * O `@floating-ui/dom` observa o tamanho do gatilho para reposicionar o painel.
+ * O jsdom não implementa `ResizeObserver`, e sem este stub o `autoUpdate`
+ * estoura no primeiro `open()` — o teste falharia por falta de ambiente, não
+ * por defeito do componente.
+ */
+beforeAll(() => {
+  if (!(globalThis as any).ResizeObserver) {
+    (globalThis as any).ResizeObserver = class {
+      observe() {}
+      unobserve() {}
+      disconnect() {}
+    };
+  }
+});
+
+/**
+ * Três contratos que só existem em runtime e que a foto não pega:
+ *
+ *  - o foco VOLTA ao gatilho ao fechar pelo teclado. É o caso que quebrou de
+ *    verdade: o wrapper do gatilho é um `<span>` sem tabindex quando o slot
+ *    traz um `Button`, e `focus()` num span sem tabindex é no-op;
+ *  - `aria-expanded` e `aria-haspopup` moram no elemento INTERATIVO, não no
+ *    wrapper genérico — num `<span>` de role genérico o axe reprova e o
+ *    leitor de tela nunca anuncia o estado;
+ *  - o diálogo nunca fica sem nome.
+ */
+
+const abrir = () => (
+  <Popover title="Sobre o prazo" closable content={<p>Corpo do painel</p>}>
+    <Button variant="secondary">Abrir</Button>
+  </Popover>
+);
+
+const gatilho = () => screen.getByRole("button", { name: "Abrir" });
+
+describe("Popover · abrir e fechar", () => {
+  it("o clique no gatilho abre o diálogo", async () => {
+    const usuario = userEvent.setup();
+    render(abrir());
+
+    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    await usuario.click(gatilho());
+
+    await waitFor(() =>
+      expect(screen.getByRole("dialog", { name: "Sobre o prazo" })).toBeInTheDocument(),
+    );
+  });
+
+  /**
+   * O defeito real: fechava, mas largava o foco no nada, porque quem recebia
+   * o `focus()` era o `<span>` wrapper — sem tabindex, e portanto no-op.
+   */
+  it("o Escape fecha E devolve o foco ao gatilho", async () => {
+    const usuario = userEvent.setup();
+    render(abrir());
+
+    await usuario.click(gatilho());
+    await waitFor(() => expect(screen.getByRole("dialog")).toBeInTheDocument());
+
+    await usuario.keyboard("{Escape}");
+    await waitFor(() =>
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument(),
+    );
+    expect(gatilho()).toHaveFocus();
+  });
+
+  it("o botão de fechar também devolve o foco ao gatilho", async () => {
+    const usuario = userEvent.setup();
+    render(abrir());
+
+    await usuario.click(gatilho());
+    await waitFor(() => expect(screen.getByRole("dialog")).toBeInTheDocument());
+
+    await usuario.click(screen.getByRole("button", { name: "Fechar" }));
+    await waitFor(() =>
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument(),
+    );
+    expect(gatilho()).toHaveFocus();
+  });
+
+  it("avisa o pai quando abre e quando fecha", async () => {
+    const usuario = userEvent.setup();
+    const aoMudar = vi.fn();
+    render(
+      <Popover title="X" content={<p>corpo</p>} onOpenChange={aoMudar}>
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+
+    await usuario.click(gatilho());
+    await waitFor(() => expect(aoMudar).toHaveBeenCalledWith(true));
+
+    await usuario.keyboard("{Escape}");
+    await waitFor(() => expect(aoMudar).toHaveBeenLastCalledWith(false));
+  });
+});
+
+describe("Popover · semântica do gatilho", () => {
+  /**
+   * `aria-expanded` e `aria-haspopup` não são atributos globais: num `<span>`
+   * de role genérico o axe reprova, e quem recebe o foco é o botão de dentro —
+   * que nunca anunciaria o estado.
+   */
+  it("os atributos de estado ficam no botão, não no wrapper", async () => {
+    const usuario = userEvent.setup();
+    const { container } = render(abrir());
+
+    const wrapper = container.querySelector(".umds-popover__trigger")!;
+    expect(wrapper.hasAttribute("aria-haspopup")).toBe(false);
+    expect(wrapper.hasAttribute("aria-expanded")).toBe(false);
+
+    expect(gatilho()).toHaveAttribute("aria-haspopup", "dialog");
+    expect(gatilho()).toHaveAttribute("aria-expanded", "false");
+
+    await usuario.click(gatilho());
+    await waitFor(() =>
+      expect(gatilho()).toHaveAttribute("aria-expanded", "true"),
+    );
+  });
+});
+
+describe("Popover · nome acessível", () => {
+  it("com título, o nome é o título", async () => {
+    const usuario = userEvent.setup();
+    render(abrir());
+    await usuario.click(gatilho());
+    await waitFor(() =>
+      expect(
+        screen.getByRole("dialog", { name: "Sobre o prazo" }),
+      ).toBeInTheDocument(),
+    );
+  });
+
+  it("sem título, o nome é o ariaLabel", async () => {
+    const usuario = userEvent.setup();
+    render(
+      <Popover ariaLabel="Detalhes do prazo" content={<p>corpo</p>}>
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+    await usuario.click(gatilho());
+    await waitFor(() =>
+      expect(
+        screen.getByRole("dialog", { name: "Detalhes do prazo" }),
+      ).toBeInTheDocument(),
+    );
+  });
+
+  /**
+   * Sem título e sem ariaLabel o diálogo ficaria ANÔNIMO, que o axe reprova
+   * (aria-dialog-name). O nome cai no texto do gatilho, que sempre existe.
+   */
+  it("sem título e sem ariaLabel, o nome vem do gatilho", async () => {
+    const usuario = userEvent.setup();
+    render(
+      <Popover content={<p>corpo</p>}>
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+    await usuario.click(gatilho());
+    await waitFor(() => {
+      const dialogo = screen.getByRole("dialog");
+      expect(dialogo).toHaveAccessibleName();
+    });
+  });
+});
+
+describe("Popover · modo controlado", () => {
+  it("nasce aberto quando o pai manda", async () => {
+    render(
+      <Popover open title="Aberto pelo pai" content={<p>corpo</p>}>
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+    await waitFor(() =>
+      expect(
+        screen.getByRole("dialog", { name: "Aberto pelo pai" }),
+      ).toBeInTheDocument(),
+    );
+  });
+
+  /**
+   * No modo controlado o gatilho PEDE para fechar; quem fecha é o pai, trocando
+   * `open`. O que precisa ser garantido é que o pedido chega e que o painel
+   * segue a prop — não em que tick a remontagem acontece.
+   */
+  it("o gatilho pede para fechar, e o painel segue a prop do pai", async () => {
+    const usuario = userEvent.setup();
+    const aoMudar = vi.fn();
+    const { rerender } = render(
+      <Popover open title="X" content={<p>corpo</p>} onOpenChange={aoMudar}>
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+    await waitFor(() => expect(screen.getByRole("dialog")).toBeInTheDocument());
+
+    await usuario.click(gatilho());
+    expect(aoMudar).toHaveBeenCalledWith(false);
+
+    rerender(
+      <Popover
+        open={false}
+        title="X"
+        content={<p>corpo</p>}
+        onOpenChange={aoMudar}
+      >
+        <Button variant="secondary">Abrir</Button>
+      </Popover>,
+    );
+    await waitFor(() =>
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument(),
+    );
+  });
+});

package/src/teste/SegmentedControl.test.tsx

@@ -0,0 +1,183 @@
+import { describe, expect, it, vi } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { faList } from "@fortawesome/free-solid-svg-icons";
+import SegmentedControl from "../components/SegmentedControl/SegmentedControl";
+
+/**
+ * A aposta do componente é usar `<input type="radio">` nativo escondido em vez
+ * de `<button role="radio">` com roving tabindex. O que precisa ser provado é
+ * justamente que essa aposta entrega o que prometeu:
+ *
+ *  - as SETAS funcionam sem uma linha de código de teclado;
+ *  - clicar no segmento marca, apesar de o input ter `pointer-events: none`;
+ *  - o `name` compartilhado agrupa de verdade (submit nativo).
+ */
+
+const POR_PAGINA = [
+  { label: "25", value: "25" },
+  { label: "50", value: "50" },
+  { label: "100", value: "100" },
+];
+
+describe("SegmentedControl · escolha", () => {
+  it("clicar no segmento marca, mesmo o input tendo pointer-events: none", async () => {
+    const usuario = userEvent.setup();
+    const aoMudar = vi.fn();
+    render(
+      <SegmentedControl
+        label="Itens"
+        options={POR_PAGINA}
+        defaultValue="25"
+        onChange={aoMudar}
+      />,
+    );
+
+    await usuario.click(screen.getByRole("radio", { name: "100" }));
+
+    expect(aoMudar).toHaveBeenCalledWith("100");
+    expect(screen.getByRole("radio", { name: "100" })).toBeChecked();
+    expect(screen.getByRole("radio", { name: "25" })).not.toBeChecked();
+  });
+
+  /**
+   * O motivo de existir o input nativo: a navegação por seta é do navegador.
+   * Se um dia alguém trocar por `<button role="radio">`, este teste cai.
+   */
+  it("a seta move a escolha, sem código de teclado no componente", async () => {
+    const usuario = userEvent.setup();
+    render(
+      <SegmentedControl label="Itens" options={POR_PAGINA} defaultValue="25" />,
+    );
+
+    screen.getByRole("radio", { name: "25" }).focus();
+    await usuario.keyboard("{ArrowRight}");
+
+    await waitFor(() =>
+      expect(screen.getByRole("radio", { name: "50" })).toBeChecked(),
+    );
+  });
+
+  it("no modo controlado, quem manda é a prop", async () => {
+    const usuario = userEvent.setup();
+    const aoMudar = vi.fn();
+    const { rerender } = render(
+      <SegmentedControl
+        label="Itens"
+        options={POR_PAGINA}
+        value="25"
+        onChange={aoMudar}
+      />,
+    );
+
+    await usuario.click(screen.getByRole("radio", { name: "50" }));
+    expect(aoMudar).toHaveBeenCalledWith("50");
+
+    rerender(
+      <SegmentedControl
+        label="Itens"
+        options={POR_PAGINA}
+        value="50"
+        onChange={aoMudar}
+      />,
+    );
+    expect(screen.getByRole("radio", { name: "50" })).toBeChecked();
+  });
+});
+
+describe("SegmentedControl · desabilitado", () => {
+  it("o grupo desabilitado desabilita todos os radios", () => {
+    render(
+      <SegmentedControl label="Itens" options={POR_PAGINA} disabled />,
+    );
+    screen.getAllByRole("radio").forEach((r) => expect(r).toBeDisabled());
+  });
+
+  it("um segmento desabilitado não é escolhido no clique", async () => {
+    const usuario = userEvent.setup();
+    const aoMudar = vi.fn();
+    render(
+      <SegmentedControl
+        label="Itens"
+        defaultValue="25"
+        onChange={aoMudar}
+        options={[
+          { label: "25", value: "25" },
+          { label: "100", value: "100", disabled: true },
+        ]}
+      />,
+    );
+
+    await usuario.click(screen.getByRole("radio", { name: "100" }));
+
+    expect(aoMudar).not.toHaveBeenCalled();
+    expect(screen.getByRole("radio", { name: "25" })).toBeChecked();
+  });
+});
+
+describe("SegmentedControl · acessibilidade", () => {
+  it("o grupo é um radiogroup nomeado pelo rótulo", () => {
+    render(
+      <SegmentedControl label="Itens por página" options={POR_PAGINA} />,
+    );
+    expect(
+      screen.getByRole("radiogroup", { name: /Itens por página/ }),
+    ).toBeInTheDocument();
+  });
+
+  /** Segmento só com ícone depende do `ariaLabel` para ter nome. */
+  it("segmento só com ícone recebe o nome do ariaLabel", () => {
+    render(
+      <SegmentedControl
+        label="Visualização"
+        options={[{ value: "lista", icon: faList, ariaLabel: "Lista" }]}
+      />,
+    );
+    expect(screen.getByRole("radio", { name: "Lista" })).toBeInTheDocument();
+  });
+
+  it("a mensagem de erro é ligada ao grupo", () => {
+    render(
+      <SegmentedControl
+        label="Itens"
+        options={POR_PAGINA}
+        errorMessage="Escolha um tamanho."
+      />,
+    );
+    const grupo = screen.getByRole("radiogroup");
+    expect(grupo).toHaveAttribute("aria-invalid", "true");
+    const id = grupo.getAttribute("aria-describedby");
+    expect(id).toBeTruthy();
+    expect(document.getElementById(id!)).toHaveTextContent("Escolha um tamanho.");
+  });
+
+  /**
+   * `name` compartilhado é o que faz o grupo existir para o navegador — sem
+   * ele as setas atravessariam para outros radios da página.
+   */
+  it("os radios do grupo compartilham o mesmo name", () => {
+    const { container } = render(
+      <SegmentedControl label="Itens" options={POR_PAGINA} name="porPagina" />,
+    );
+    const nomes = new Set(
+      Array.from(container.querySelectorAll("input[type=radio]")).map((r) =>
+        r.getAttribute("name"),
+      ),
+    );
+    expect(nomes).toEqual(new Set(["porPagina"]));
+  });
+
+  it("sem name, um é gerado e ainda assim é único por grupo", () => {
+    const { container } = render(
+      <>
+        <SegmentedControl label="A" options={POR_PAGINA} />
+        <SegmentedControl label="B" options={POR_PAGINA} />
+      </>,
+    );
+    const nomes = Array.from(
+      container.querySelectorAll("input[type=radio]"),
+    ).map((r) => r.getAttribute("name"));
+    // Três de cada grupo, e os dois grupos com nomes diferentes.
+    expect(new Set(nomes).size).toBe(2);
+  });
+});

package/src/teste/Timeline.test.tsx

@@ -0,0 +1,100 @@
+import { describe, expect, it } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { faCheck } from "@fortawesome/free-solid-svg-icons";
+import Timeline from "../components/Timeline/Timeline";
+
+/**
+ * A Timeline é quase toda renderização, e disso cuidam a esteira visual e o
+ * axe. O que não se vê numa foto é a regra do conector: N eventos têm N-1
+ * conectores, porque o último não tem para onde seguir. É a regra que quebra
+ * quando alguém troca o `index === length - 1` por um `>=` ou esquece que a
+ * lista pode ter um item só.
+ */
+
+const EVENTOS = [
+  { title: "Criado", timestamp: "18/09 09:12" },
+  { title: "Em análise", timestamp: "19/09 10:05" },
+  { title: "Concluído", timestamp: "22/09 08:30" },
+];
+
+const conectores = (c: HTMLElement) =>
+  c.querySelectorAll(".umds-timeline__connector").length;
+
+describe("Timeline · trilha", () => {
+  it("N eventos têm N-1 conectores — o último não tem para onde seguir", () => {
+    const { container } = render(<Timeline items={EVENTOS} />);
+    expect(screen.getAllByRole("listitem")).toHaveLength(3);
+    expect(conectores(container)).toBe(2);
+  });
+
+  it("um evento só não tem conector nenhum", () => {
+    const { container } = render(<Timeline items={[EVENTOS[0]]} />);
+    expect(conectores(container)).toBe(0);
+  });
+
+  it("lista vazia não quebra e não rende evento", () => {
+    const { container } = render(<Timeline items={[]} />);
+    expect(screen.queryAllByRole("listitem")).toHaveLength(0);
+    expect(conectores(container)).toBe(0);
+  });
+});
+
+describe("Timeline · marcador", () => {
+  /**
+   * Um evento com ícone e outro sem, na mesma lista, precisam do MESMO
+   * marcador — tamanho por item faria a trilha ziguezaguear.
+   */
+  it("o marcador tem a mesma classe de tamanho com e sem ícone", () => {
+    const { container } = render(
+      <Timeline
+        items={[
+          { title: "Sem ícone" },
+          { title: "Com ícone", icon: faCheck, variant: "positive" },
+        ]}
+      />,
+    );
+    const marcadores = container.querySelectorAll(".umds-timeline__marker");
+    expect(marcadores).toHaveLength(2);
+    // Nenhum dos dois carrega modificador de tamanho: o tamanho vem da lista.
+    marcadores.forEach((m) => {
+      expect(m.className).not.toMatch(/--sm|--md/);
+    });
+    expect(marcadores[1].className).toContain("umds-timeline__marker--icon");
+    expect(marcadores[0].className).not.toContain(
+      "umds-timeline__marker--icon",
+    );
+  });
+
+  it("a variante vira classe no marcador", () => {
+    const { container } = render(
+      <Timeline items={[{ title: "Recusado", variant: "negative" }]} />,
+    );
+    expect(
+      container.querySelector(".umds-timeline__marker--negative"),
+    ).toBeInTheDocument();
+  });
+
+  it("sem variante, o marcador é o padrão", () => {
+    const { container } = render(<Timeline items={[{ title: "Criado" }]} />);
+    expect(
+      container.querySelector(".umds-timeline__marker--default"),
+    ).toBeInTheDocument();
+  });
+});
+
+describe("Timeline · conteúdo", () => {
+  it("evento sem título, sem data e sem autor não rende cabeçalho vazio", () => {
+    const { container } = render(
+      <Timeline items={[{ title: "", description: "Só o texto." }]} />,
+    );
+    expect(container.querySelector(".umds-timeline__header")).toBeNull();
+    expect(screen.getByText("Só o texto.")).toBeInTheDocument();
+  });
+
+  it("a lista é nomeada para quem usa leitor de tela", () => {
+    render(<Timeline items={EVENTOS} ariaLabel="Despachos do processo" />);
+    expect(
+      screen.getByRole("list", { name: "Despachos do processo" }),
+    ).toBeInTheDocument();
+  });
+});

package/src/teste/Tree.test.tsx

@@ -0,0 +1,74 @@
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import Tree from "../components/Tree/Tree";
+
+/**
+ * O `Tree` é dos poucos componentes com navegação por teclado própria, e a
+ * especificação do padrão treeview é detalhada: ArrowRight abre, ArrowLeft
+ * fecha — e, em nó já fechado, sobe para o pai. É o tipo de regra que se perde
+ * numa refatoração e que nenhuma foto de tela pega.
+ */
+
+const ITENS = [
+  {
+    id: "processo",
+    label: "Processo 964/2025",
+    children: [
+      { id: "d1", label: "Despacho 01" },
+      { id: "d2", label: "Despacho 02" },
+    ],
+  },
+  { id: "avulso", label: "Documento avulso" },
+];
+
+describe("Tree · teclado e estado", () => {
+  it("ArrowRight abre o nó e ArrowLeft fecha", async () => {
+    const usuario = userEvent.setup();
+    render(<Tree items={ITENS} ariaLabel="Pasta" />);
+
+    const raiz = screen.getByRole("treeitem", { name: /Processo 964/ });
+    expect(raiz).toHaveAttribute("aria-expanded", "false");
+
+    raiz.focus();
+    await usuario.keyboard("{ArrowRight}");
+    expect(raiz).toHaveAttribute("aria-expanded", "true");
+
+    await usuario.keyboard("{ArrowLeft}");
+    expect(raiz).toHaveAttribute("aria-expanded", "false");
+  });
+
+  it("filho só existe no DOM quando o pai está aberto", async () => {
+    const usuario = userEvent.setup();
+    render(<Tree items={ITENS} ariaLabel="Pasta" />);
+
+    expect(screen.queryByRole("treeitem", { name: /Despacho 01/ })).not.toBeInTheDocument();
+
+    const raiz = screen.getByRole("treeitem", { name: /Processo 964/ });
+    raiz.focus();
+    await usuario.keyboard("{ArrowRight}");
+
+    expect(screen.getByRole("treeitem", { name: /Despacho 01/ })).toBeInTheDocument();
+  });
+
+  it("defaultExpandedIds abre o nó já na montagem", () => {
+    render(<Tree items={ITENS} ariaLabel="Pasta" defaultExpandedIds={["processo"]} />);
+    expect(screen.getByRole("treeitem", { name: /Despacho 02/ })).toBeInTheDocument();
+  });
+
+  it("seleção simples devolve o id escolhido", async () => {
+    const usuario = userEvent.setup();
+    const aoSelecionar = vi.fn();
+    render(
+      <Tree
+        items={ITENS}
+        ariaLabel="Pasta"
+        selectionMode="single"
+        onSelectionChange={aoSelecionar}
+      />,
+    );
+
+    await usuario.click(screen.getByRole("treeitem", { name: /Documento avulso/ }));
+    expect(aoSelecionar).toHaveBeenCalledWith(["avulso"]);
+  });
+});

package/src/teste/setup.ts

@@ -0,0 +1,7 @@
+import "@testing-library/jest-dom/vitest";
+import { cleanup } from "@testing-library/react";
+import { afterEach } from "vitest";
+
+// Cada teste monta o componente do zero. Sem isto, o DOM do anterior fica de pé
+// e um `getByRole` encontra dois — falha que parece do componente e é do teste.
+afterEach(() => cleanup());

package/src/utils/bandeiras.ts

@@ -0,0 +1,22 @@
+/**
+ * Bandeiras do `PhoneInput`, embutidas. GERADO — não edite à mão.
+ *
+ * Antes vinham de `flagcdn.com` em tempo de execução. Três problemas: a rede
+ * corporativa bloqueia e a bandeira some; cada usuário que abre o campo entrega
+ * o IP dele a um serviço de fora; e não há contrato de disponibilidade nenhum.
+ *
+ * Origem: os SVGs do pacote `flag-icons` (MIT, © 2013 Panayiotis Lipiridis),
+ * rasterizados em 40×30 por `scripts/rasterizar-bandeiras.mjs`.
+ */
+export const BANDEIRAS: Record<string, string> = {
+  BR: "data:image/png;base64,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",
+  US: "data:image/png;base64,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",
+  PT: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAG5ElEQVR4nOyabWxT1xnHf9ev18ZviR1MEhNCSUJISAikZKVAoWhjCnQCWlWZEGsF69CG0NaNTYXBqrHsQ8emtVO1lQap25D6oa3Ssm5Tx9Z0QOhQ00CaNKXhzSEJJJD3OE5sx/a9u9eh0ib1kxMuleufruzjc8+1/ffz3POc5/ExsJu7ilzHFwodXzLSglOdtOBUJy041UkLTnXSglOdtOBUJy041bk7gmUIwwTrMmlbzbDaROILgYFZZa6JTUWUein1YTNihslHuD2JKcxUO2ILngbsw9xDZk2wWWbvA3xjGT4XwQj+21zsYWk2ngGks4ScWFYi1zDYxtBfyT2OMcY9YXYEV+XwzDrWl9Pu50gDdedAr/a/8ii+XopfUNtBxbG3MrIF12G6HmTur3BcQXv0VDJDnljBoQ04Lfz2TfbWc74LFOtFIMT9HsRe9I0EIKpMGB3Y/kLPVcybCFZjGcV4GY0RZljEWzufXzxMJMKik7tD10+IEb23P18QBOWUJMT75nXJgpx7a6EgqbOjLMu3c7uniFnzt/aufdkksPgQjja0ZEYuXWbn2VWqPZWvruu/1LO4fw7cV9uXcGciem4cVH/SghO3p+9Y5aH3MJNxym50GRyITs7XsnQPWTfRjBmEJZk/7+Dh9SyvwGxTXhv0VmKCqiqeOKZ0SCb1iMh3epQjpsNgRYoIxl2MncWeTduLaEnyFq7OViRy8yYZGVSUMh523n9A7Z988kljTY3akuXiQEB9ftsxmbgk/tprFT87rjRi2+fwO1xeoiG8+Qza8YyjDckL3rgMUSQYZHyc4RFKdDp3on9s4UJbdfX0mN//qUWKc6BmeeKmZqypaXrMgKSzvYKnlfB8Jl5m/Gk8tWhDsi4dI99N5yCtXRQVsbRUMefnjKpv8L91+vrnfKqE7wSZnTjOINwgXKzdOixJC5uUGSuPt5o4copojJJc8pEHMzD9v+w1FTlxSZo27zRjmcQlJANdR8h4G9tZwtewlKP4vA0tSFJwURbBAIVujj5OXiaCRNA6cGEXVomVihN/xvP7Vv3vVVE5+uFOwhKVgdHIKkY2M6ZEaRvjIg49tjgakKTgxwowm9VJ69VmOkdp7uSSBYcPQxx5jO0HG1ovDx396UN7nmuUJPnYoXXf+eXpogXOOotgzsWkQ/hIzlqLvI5gCZFtWDO5sousY2hAkoJFAyMjRMOsmI/dQjCEOOgoeV0Juhg3CQ6d0WzSZzrMLrtJlvC4RItZ77KZjDq5+A31cv0iy4Q9kUPFmRgnFkDKQhuSFHyshcdWE4iwJktNGL6/FuvzVs859VRgQ7x2X1XTJ/2lizL+sH9tPC4rtq39XlXlEo9w5GROYkx/sSVwClFCdwuLHrsT30toQ5KC/QF1Wr46xg9fpcxLlY8fZFvd6rIK4dIlt9O0eU2eMuxw3XnFpet/vbF69XxJkiY6Okgky6F8i/A+7neY04T/GXQLsY2gDcnGYT3dwyyZp07RFwbUo8QbL0hEOeOpU7GhIVOW6qONLX1x6c7EHRsY0J85Q2K9pa+M5ZQy1of4DuJKotewohHJC27r5dEVLHGj5AXlXsS80WhFhd/wkeXBwdDebYXHG0xm81PbiiUJJSxFQqGre7aKO0fkRnJYGfT1+/KxHqS7DHMepte1KzUlnx529PFIIat81FTy1WLG4936yn3IJz914FvVY/jxmfiSkvXVy9bn6ac++GBiR42083zrMM65THz7QEh3NDAoZS/AXkjvdbL3IIbQhhmkh1He3Um2m/908NL7XOjDm+H9p3GloeBvc3+Dp+tOFkGiFqA4Un8Bwz+Cq1t1jzdmLR4aGiIcZulSmk+zbD1GNGIGBQA9V/p5aAEl+TyQw6ZlrMiZaPeOF/R8K/e9Dv2UkiypOg2fLV+NUftU2VNTRf+SwwPDk4wrhS4Rv58FG3BoWOCbaQFgkY03dqlvc8GPaw4em6rQ0V+T/abBfLnL2N6OwRAtLg4X5fVtiWCvN00ptlYDsGs5UoyRn1D1LloizHzb0tfu47nNCDpefI8/NpPrYoELUceijMJvrviKYxSx/pzov2YPYuhEGGZwB9b9xCJkPo2jEY0RZmWfVpmbF7ZQmEOzX63g/eNKwpXjahGv6mOK96tjlPQg9F3GtmEvJ3gR924yrqE9wmxtTJtj4Ocb+HopDgu3RvjQT0sP28rJHkBsRchBXI3gRDdB7O/MfxbVt+8FwuzuxCt08sRyynIo8hKPqcW9WAynE6MSij/B/CnuOlzd3EOEu7L1MK6m+OXz2LiQ7ReZ928sH6uZ4yz/zZEUQnqvZYqTFpzqpAWnOmnBqU5acKqTFpzqpAWnOmnBqc5/AQAA//9WYv0eAAAABklEQVQDAP1wWowyxbeRAAAAAElFTkSuQmCC",
+  ES: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAFgElEQVR4nOyaW2gcVRiA/3NmzszeL9nN5tLduE2bTTUmbdp6ean6IAqxqIhPRaiCWBCLIvQiBX0pVn0tFEUq+Cp4e2jzIFKbCkovJrVJm3ubNMlmTfY2O7uzcznnuGkVEZ+mKey62e9tbgzf/Oec/z/njPhV8ybYSGDYYDSE652GcL3TEK53GsL1TkO43mkI1zsbThjlz8GGotGk6537KaybUPvcT+FzNyNpVYDaRoT1wTkgLOdLDsqdy1pMMRgqGi4ZyUIeIahB1iEseGZSsizo6ZI3EUpinN/RTgRz1euFhRUZy1FCSm6R+Z05qCXuXXhqwdFUWs2NO4oOdm2UaFPewAfxsVOZ+aJk7tGCVrGpSU1uJc5NPgkrUDPcuzABev6I24d9dHuaGSBwa/7LC85W0K7IdLq88rsnpQad+wtdMQ61xL0Lt4Wy/hdBvw5UpTxCrZhDmxa1RRroI+oCuAIa316MJgBXfGupM9urtJgJs2PgEyDSu3bIGfz6E6yUIC2TWBiXl3TiQ7dNsR2QwzD6+iHccuc2DpkCBD2AayDr24vw0mUYVsDD4emtIDrApNDTD0PXgM+Zc8MgLIGnjYS3GCwCgWbwNYFpARFhfAimMuBF8MTzIFTb2Z4w74bmRRAJ6AiWfxOvnghhhKij1EIlZIoQg7ZDn8uyVLmTGbMzUicvTyboQakHvIsgOcFi/zdht0CIp4dx1S1P5xAiCJnRfO4hjaQgPNoiiljIg2BZbC7pkVIFURAedAMDlxCQQ48h/ocsDkO1sffBiastsO2UM/IWY2uHnPPiLg1vBms3aGG1cgZFguLtUnBBEEoPQmuHIK4VXg5vh6/zfVfopbtPVRd7EaYWLY1PlFOzyzIxVEAIlZQWJeJSWWu4cANcYOo6OLAVD5CKm1KGMKyO40K5XHSM4IAKbVB1bAgvXyJTPxb19LvYySeYu5xFa+ErlxzY5JjqJa6ldXxt1NnbJ5xfkFQm928x9fzwpz7iWAF8TGpiF52eR99U8XrL2XVh4+Ul1TJ0FHzvtK7fSBSPrU5KN7+QuL8wm93Xgc/Oetu/eWRf/MzVNzKZ2M492WxBAC4Q2P2OoqKt+c7P0t+dtEYHKavyjNSGcOdT3BJkvSWSHxy8NS+6EkxrZb7h0C42aBow1NHXnxjziLnxMzOCWxUqw3EaOFKicTZyUgkfNdw9scR2nUhQXWwIM6syTOHUhx9Zc9ObXoVF3ix2ZeWtOs2R0oQAWZ7TA99PDnysv82vXzAtTNw8f7lbOA7eMEkdOiLtahefrX6ZaaN9LV0hqSHDu/e50IkDkf6KPYgYy0QgInY7yDP+s91fXz165XhbS46tAM8BLVNB5JWO3n0gGPnkBHLJY6c9lgXVxUaEm7aZOdOD+3do6Yv/vepqZQ/Hb3jnDeQS57qbOpUVvlxJwn+V0bLfHxzYifi3QrUXCGxE2BWABx5nlFJ2J5+utU7+ryYqIEAyhTxvzxRYmluFMqpMHe7k3spTnLPel6HqqwL2UoSiJAupg5yp3AWhlvQyrQxB/yxkMV8QTSHRbaC0Tme8zr6S5g4QAsuZyULpdcyUSolSdWxE2KJoZGWLYS0Vy4WRZMfmmIH98Uq8714tA472vkKe3A+EOkJM3qZkfmnteiGpWWR0NaZZimLQ4aU4VBsbEbYoXEwNUMQwIy3Oud3R+YHXRn/+IapIASERL/f2XVZ4uauzSzrsSU5j182+wxPRzdnb2eCl1F6KBIIgpk70t9+CqmJvPmyakCz6m135oiGFPcbdk5SuzRMN3lw0/BiZbikj4wL5+0tqlsypmSu7m90FjKDqg1Zjq6Xe2Xi7h42fS+uchnC90xCudxrC9U5DuN5pCNc7DeF6Z8MJ/wkAAP///E9TZgAAAAZJREFUAwBfz1XvSIbzHwAAAABJRU5ErkJggg==",
+  FR: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAAdElEQVR4nOzPMRHCQBRAwT8MVhCDgmuxhIsMFcKoqWPiqpddB3ufec8+az2O4zn7/Nbr//nOPre5GOE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64boTAAD///80axAAAAAGSURBVAMAyTAHawxtAWUAAAAASUVORK5CYII=",
+  DE: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAAZ0lEQVR4nOzSAQ3AMAzAsO4af2Tn9PNIbQaRcmfObPLMMoLrBNcJrhNcJ7hOcJ3gOsF1guvON7tYuk5wneA6wXWC6wTXCa4TXCe4bl3wnXdWsXSd4DrBdYLrBNcJrhNcJ7hOcN264B8AAP//N19P1gAAAAZJREFUAwDcCAJInsKX1wAAAABJRU5ErkJggg==",
+  IT: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAAeklEQVR4nOzPQRVBURiAwf84qshh52ggiB0tpFDBQhYVRHgl7up7Mw3mOK/LrHM7nd/Xx6zzuz//n++sc5idEa4TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrhOuE64TrtsAAAD//2b/whAAAAAGSURBVAMA1nQHq+jgoQAAAAAASUVORK5CYII=",
+  AR: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAADq0lEQVR4nOyY22obRxiAZ2ZnD1qt1rZkyXZVKaZxcE1dxaRpC6WlUHrTkFIoDXmBQl+gfYk+QS8KpaE0hKYFBwK5KIVcNAanBzdWExvFiSU5kWydrF15tYc5ZE2eYfZitR97MezALt/OzP//++Ovbz4FkwQCE0YiHHcS4biTCMedRDjuJMJxJxGOO4lw3EmE404iHHcg5xxMEhhECGcMIhSMjzlhMBypaYQx4DwcgqiIVNh+9q+k54c7t7RChfi+290tnP/csw70uTdlVQORENGnJZ7X3LguGYt27bbEur7VgtSFpN2r3lQ0s7v1I/V9EAlRnOFQplNdnz77UXfrBwm6DKY4ZcGJg3RNRgRy11j50m7cm1v7QpJlIBjhKxx47uH2b+n5N/rb17BqUsKH+386hzu92h120rLbe1K6bO3cmDlzvvXXDSAesSscRqlhY1PR89aT20gx+7UNb7DHqO/0W8yzUjPzRq4M1TlzcdXv/jf7/rd0VM8ULwiNYWKDFoRQzeTDI4rYyThQsaJa/d3SmZG+QMNZx9lvNvpG8SIlGKdy1vZ35vIV0RFb7NNp4B49vItSRagVqdfr7vxRKlkyDv1AeMmYlcvW6Ohx9+G6S3PAbw1rvxPXBiIRLcz0uYpiniMnQ6dTD4739DR/+oh1WrT5hDb2aErn48GRJGc17MPCZ6lXP+RMAiIRKxxu6TDBUjJEGELJZNgMb66+jVNpyZhGK2unMZnjrGO7JKASVkjgi84ZoguPwDm4K0keQwYPmmnTcMdjRQVY5gCeTrsO17VxtrQg6RnvcIODdHZxFYhE7ArL+tTMuY+Ja2HWzi5fUg2tUTfsIcMy1FLQOmb1gyyRl5AEod8B3M9XPkVYASIRnpZGB5uyudR78BNW01bjvoSY09myW3WkZYwZU9azXFuaXnoP4IJZficY1jKld4UG6igqrea9a7PLH/Sqv8haJrDb/qhvPXuQyr8GguPTrJta4L6Vef2q83wzt3IpTF1AJFEIh4V0t7pulN6yd3/mFFGGSeAp4Z6WZEAs6ruzF78a1v8prF5G4kvLiP6HGSGHf38/dfaT/qNbiAzwzBqlY+g/51CdWr462L0zf+GKpIg9vS+JrgFAfM9p/69Mv3J0/7q2UJFVxWlXcyuXg/EgU6yAqIi04xHGsDA1h6vNvFH4VoRlrBkvuwIgKiavxfPNr/tgkkjatHEnEY47iXDcSYTjTiIcdxLhuJMIx51EOO4kwnFn4oRfAAAA//8nrMQoAAAABklEQVQDAEq8rD3UVWu3AAAAAElFTkSuQmCC",
+  MX: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFAAAAA8CAIAAAB+RarbAAAEVklEQVR4nOzZSUwbVxjA8TfjZWyPJ14xsVmMMRgwBsJWEloBSQkgKrokqumiVmqLBIeoVVKpbUIbKYcmolLVQ5VEuaQRh4RINCpCIApkoSkUTCFAFCgQjCEFjME29gxjzxjbzblnZiJN5qe5zuEvvaen7z0haKkF+6exuKKj6RzYP56rN9ZaL4H9A4OXDB/MdXww1/HBXMcHcx0fzHV8MNfxwVzHB3MdH8x1L12wELAuFotdP1ODxSJ79J5Eb0s7erK4ogawhaXgeDzm9zkxedLs79cBBOUffm38bt+uG5+ZGsiY+NP16O2TX3wPWMFS8Oz8IIjGPEs3J+79rVSJd7c3YXkCooyRqwF/VN7za6cSU7/+6ZeAeSztYVSqxdeHUcVq3TspcqE4LSeLpvZQRCwWwhCO0wTe3X5lZWoYMI+l4DRjUVnlaReZFkIrFGpkbmb12TPv3MKaVovtUrQ5UQ7D8Z7LbKxq5oPje57pix6Ps//uL2J15vLYiNu9sxUmJ50bZCRqPCBIMqgEMolSiUw7nX/0dgGGMR8MCbV5Xy27HEIqXFbWiOmMMAipsXiGHkszGpTphYFwjCDpoJ+WAgoP7gCGMRhM0SRNkyBKEPi2SpUsokOue5/nF8kmnZH5RW9hpmYFDxMy/bunLtiqP7AcqZVpzSqt7vmPBOEDjGEwuH/w2qJzjN5aFT0coMI4ml4QpKj5icHqqkIZKn/ijvh81KOhXjzoO9F8Bku1wJjGnFsw6ui8072fr2f/w2BwiCJkwqgIM25illlcRoYCG16hKe8Y5XcdstkEFARROB2F+tqvdvx0ts7+cUb5caVaQ4aJJL0FMIbBc7jh1VovQUAoen5lcWzDfa2hvmguiuneKvjsfUQAp05PdVy5oE62bS09mRx1BKOXGhrtCIKkaDTJiQbAGAaDIYV1fOznLYJuq6/7cWTkbE+fwh+Ud/429XT5jdIS83qXvVGJoCGAfbMiTaxdmBOnmu8P3Xi67PjovTbAGAaDJYhcodA5lxyF1tIfjmaOWkwPnP/Ssdi8L3h7eqZQln3rn1gElqVK58c3Hp4rL28RQ55tp+GgRSLBAGOYPZYqj9iz9cqhv7pgLGdXZtjW53oTrLcyif5XFEGxNA8Kdzc1HcvPbK0uaa6vWXDNlmbl1VU3AyYxGywQYdayU9v+9fabX+dI49+ZoDWKCITdEq/jzcBwY4LHPrFWnp7VUnW8o/P8na42rbFSIJQCJjE+PEAQXFZy4vHjPsnuuBiVX87Szmxalv2e7BzRFlB9a6CFhNe1OK1S6UqLWw9gOsAwNqalZIP1oAJ1uTd7B2+TJG6zVq1qTMXuQPSQaeB+mxNBG+pP11UehsSJgHksjYdC1JhhNqYk55LkTpCmsd4HS3C0KCL90H5RpTSIRBLAFlZvPBAEff6pADB+YioALwZ/icd1fDDX8cFcxwdzHR/MdXww1/HBXMcHcx0fzHV8MNf9BwAA///BQ+ZnAAAABklEQVQDAD9Lpu+qDQU+AAAAAElFTkSuQmCC",
+  GB: "data:image/png;base64,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"
+}