(function (global) {
  "use strict";

  if (global.FormularioInscricaoCore) return;

  const ANEXOS_DB_NAME = "FormularioInscricaoAnexos";
  const ANEXOS_DB_VERSION = 1;
  const ANEXOS_STORE_NAME = "anexos";
  const ANEXOS_INDEX_ENVIO = "envioId";
  const ANEXOS_RETENCAO_MAXIMA_MS = 24 * 60 * 60 * 1000;
  const ANEXOS_TIPOS_PERMITIDOS = new Set([
    "image/jpeg",
    "image/png",
    "application/pdf",
  ]);
  const ANEXOS_TAMANHO_MAXIMO = 5 * 1024 * 1024;
  let anexosDbPromise = null;

  function validarCpf(valor) {
    const cpf = String(valor || "").replace(/\D/g, "");
    if (cpf.length !== 11 || /^(\d)\1{10}$/.test(cpf)) return false;

    const calcularDigito = (quantidade) => {
      let soma = 0;
      for (let indice = 0; indice < quantidade; indice += 1) {
        soma += Number(cpf[indice]) * (quantidade + 1 - indice);
      }
      const resto = (soma * 10) % 11;
      return resto === 10 ? 0 : resto;
    };

    return calcularDigito(9) === Number(cpf[9]) &&
      calcularDigito(10) === Number(cpf[10]);
  }

  function validarEmail(valor) {
    const email = String(valor || "").trim();
    if (!email || email.length > 254 || /\s/.test(email)) return false;

    const partes = email.split("@");
    if (partes.length !== 2) return false;

    const [local, dominio] = partes;
    if (
      !local ||
      local.length > 64 ||
      local.startsWith(".") ||
      local.endsWith(".") ||
      local.includes("..") ||
      !/^[a-z0-9.!#$%&'*+/=?^_`{|}~-]+$/i.test(local)
    ) {
      return false;
    }

    const rotulos = dominio.split(".");
    const ultimoRotulo = rotulos[rotulos.length - 1];
    if (rotulos.length < 2 || !/^[a-z]{2,}$/i.test(ultimoRotulo)) return false;

    return rotulos.every(
      (rotulo) =>
        rotulo.length >= 1 &&
        rotulo.length <= 63 &&
        /^[a-z0-9-]+$/i.test(rotulo) &&
        !rotulo.startsWith("-") &&
        !rotulo.endsWith("-")
    );
  }

  function formatFileSize(bytes) {
    if (!Number.isFinite(bytes) || bytes < 1) return "0 KB";

    const units = ["B", "KB", "MB", "GB"];
    const unitIndex = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
    const value = bytes / Math.pow(1024, unitIndex);
    const maximumFractionDigits = unitIndex === 0 || value >= 10 ? 0 : 1;

    return `${value.toLocaleString("pt-BR", { maximumFractionDigits })} ${units[unitIndex]}`;
  }

  function updateFileInfo(fileInput) {
    if (!fileInput) return;

    const fileInfo = document.getElementById(`${fileInput.id}-file-info`);
    if (!fileInfo) return;

    const file = fileInput.files?.[0];
    fileInfo.textContent = file
      ? `${file.name} (${formatFileSize(file.size)})`
      : "Nenhum arquivo escolhido";
  }

  function atualizarMensagemValidacaoArquivo(fileInput, mensagem, exibir) {
    const validacao = document.getElementById(`${fileInput.id}-span`);
    if (!validacao) return;

    validacao.textContent = mensagem || "";
    validacao.style.display = exibir ? "block" : "none";
  }

  async function validarArquivo(fileInput) {
    if (!fileInput) {
      return { ok: false, erro: "Campo de arquivo não disponível." };
    }

    updateFileInfo(fileInput);

    const file = fileInput?.files?.[0];
    if (!file) {
      atualizarMensagemValidacaoArquivo(fileInput, "", false);
      return { ok: true, arquivo: null };
    }

    let mensagemErro = "";
    if (!ANEXOS_TIPOS_PERMITIDOS.has(file.type)) {
      mensagemErro = "Apenas imagens (JPG, PNG) ou PDF são permitidos.";
    } else if (file.size > ANEXOS_TAMANHO_MAXIMO) {
      mensagemErro = "O arquivo deve ter no máximo 5MB.";
    }

    if (mensagemErro) {
      global.alert(mensagemErro);
      fileInput.value = "";
      updateFileInfo(fileInput);
      atualizarMensagemValidacaoArquivo(fileInput, mensagemErro, true);
      return { ok: false, erro: mensagemErro };
    }

    atualizarMensagemValidacaoArquivo(
      fileInput,
      `O anexo: ${file.name} foi selecionado com êxito!`,
      true
    );
    return { ok: true, arquivo: file };
  }

  function criarGuidAnexo() {
    if (global.crypto?.randomUUID) return global.crypto.randomUUID();

    if (global.crypto?.getRandomValues) {
      const bytes = new Uint8Array(16);
      global.crypto.getRandomValues(bytes);
      bytes[6] = (bytes[6] & 0x0f) | 0x40;
      bytes[8] = (bytes[8] & 0x3f) | 0x80;
      const hex = Array.from(bytes, (item) => item.toString(16).padStart(2, "0")).join("");
      return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
    }

    return `anexo-${Date.now()}-${Math.random().toString(16).slice(2)}`;
  }

  function abrirBancoAnexos() {
    if (!global.indexedDB) {
      return Promise.reject(new Error("IndexedDB não está disponível neste navegador."));
    }
    if (anexosDbPromise) return anexosDbPromise;

    anexosDbPromise = new Promise((resolve, reject) => {
      const request = global.indexedDB.open(ANEXOS_DB_NAME, ANEXOS_DB_VERSION);

      request.onupgradeneeded = () => {
        const db = request.result;
        if (db.objectStoreNames.contains(ANEXOS_STORE_NAME)) return;

        const store = db.createObjectStore(ANEXOS_STORE_NAME, { keyPath: "id" });
        store.createIndex(ANEXOS_INDEX_ENVIO, ANEXOS_INDEX_ENVIO, { unique: false });
      };
      request.onsuccess = () => resolve(request.result);
      request.onerror = () => {
        anexosDbPromise = null;
        reject(request.error || new Error("Não foi possível abrir o armazenamento dos anexos."));
      };
      request.onblocked = () => {
        anexosDbPromise = null;
        reject(new Error("O armazenamento dos anexos está bloqueado por outra aba."));
      };
    });

    return anexosDbPromise;
  }

  function aguardarTransacaoAnexos(transaction) {
    return new Promise((resolve, reject) => {
      transaction.oncomplete = () => resolve();
      transaction.onerror = () =>
        reject(transaction.error || new Error("Falha ao acessar os anexos temporários."));
      transaction.onabort = () =>
        reject(transaction.error || new Error("A operação com anexos temporários foi cancelada."));
    });
  }

  async function persistirAnexos(envioId, anexos) {
    if (!envioId) throw new Error("Identificador do envio de anexos ausente.");

    const db = await abrirBancoAnexos();
    const transaction = db.transaction(ANEXOS_STORE_NAME, "readwrite");
    const transactionDone = aguardarTransacaoAnexos(transaction);
    const store = transaction.objectStore(ANEXOS_STORE_NAME);

    (anexos || []).forEach((anexo, ordem) => {
      if (!anexo?.arquivo) return;

      store.put({
        id: `${envioId}:${ordem}`,
        envioId,
        ordem,
        titulo: String(anexo.titulo || ""),
        nome: String(anexo.arquivo.name || `anexo-${ordem + 1}`),
        tipo: String(anexo.arquivo.type || "application/octet-stream"),
        tamanho: Number(anexo.arquivo.size || 0),
        arquivo: anexo.arquivo,
        criadoEm: Date.now(),
        enviado: false,
      });
    });

    await transactionDone;
    return { ok: true, quantidade: (anexos || []).filter((item) => item?.arquivo).length };
  }

  async function listarAnexos(envioId) {
    if (!envioId) return [];

    const db = await abrirBancoAnexos();
    const transaction = db.transaction(ANEXOS_STORE_NAME, "readonly");
    const transactionDone = aguardarTransacaoAnexos(transaction);
    const index = transaction.objectStore(ANEXOS_STORE_NAME).index(ANEXOS_INDEX_ENVIO);
    const request = index.getAll(envioId);
    const requestDone = new Promise((resolve, reject) => {
      request.onsuccess = () => resolve(request.result || []);
      request.onerror = () =>
        reject(request.error || new Error("Não foi possível recuperar os anexos temporários."));
    });
    const [anexos] = await Promise.all([requestDone, transactionDone]);

    return anexos.sort((a, b) => Number(a.ordem || 0) - Number(b.ordem || 0));
  }

  async function marcarAnexoEnviado(anexoId) {
    if (!anexoId) return;

    const db = await abrirBancoAnexos();
    const transaction = db.transaction(ANEXOS_STORE_NAME, "readwrite");
    const transactionDone = aguardarTransacaoAnexos(transaction);
    const store = transaction.objectStore(ANEXOS_STORE_NAME);
    const request = store.get(anexoId);

    request.onsuccess = () => {
      if (!request.result) return;
      store.put({ ...request.result, enviado: true });
    };
    await transactionDone;
  }

  async function removerAnexos(envioId) {
    if (!envioId || !global.indexedDB) return;

    const db = await abrirBancoAnexos();
    const transaction = db.transaction(ANEXOS_STORE_NAME, "readwrite");
    const transactionDone = aguardarTransacaoAnexos(transaction);
    const index = transaction.objectStore(ANEXOS_STORE_NAME).index(ANEXOS_INDEX_ENVIO);
    const request = index.openCursor(envioId);

    request.onsuccess = () => {
      const cursor = request.result;
      if (!cursor) return;
      cursor.delete();
      cursor.continue();
    };
    await transactionDone;
  }

  async function removerAnexosExpirados(retencaoMs = ANEXOS_RETENCAO_MAXIMA_MS) {
    if (!global.indexedDB) return;

    const db = await abrirBancoAnexos();
    const transaction = db.transaction(ANEXOS_STORE_NAME, "readwrite");
    const transactionDone = aguardarTransacaoAnexos(transaction);
    const request = transaction.objectStore(ANEXOS_STORE_NAME).openCursor();
    const limite = Date.now() - Math.max(0, Number(retencaoMs) || 0);

    request.onsuccess = () => {
      const cursor = request.result;
      if (!cursor) return;

      if (Number(cursor.value?.criadoEm || 0) < limite) {
        cursor.delete();
      }
      cursor.continue();
    };
    await transactionDone;
  }

  function arquivoParaBase64(arquivo) {
    return new Promise((resolve, reject) => {
      if (!global.FileReader) {
        reject(new Error("Leitura de arquivo não está disponível neste navegador."));
        return;
      }

      const reader = new global.FileReader();
      reader.onload = () =>
        resolve(String(reader.result || "").replace(/^data:[^;]+;base64,/, ""));
      reader.onerror = () =>
        reject(reader.error || new Error("Não foi possível ler o arquivo selecionado."));
      reader.readAsDataURL(arquivo);
    });
  }

  function criarViaCep(configuracao = {}) {
    const getRespostas =
      typeof configuracao.getRespostas === "function"
        ? configuracao.getRespostas
        : () => [];
    const viaCepCache = new Map();
    const viaCepRequests = new WeakMap();
    const bloqueiosEnderecoViaCep = new WeakMap();
    const camposCepPendentes = new Set();
    let bloqueioEnvioViaCepInicializado = false;
    const regioesPorPrefixoCep = Object.freeze({
      "01": Object.freeze({ nome: "Centro", valor: 937210004 }),
      "02": Object.freeze({
        nome: "Norte",
        valor: 937210000,
        valorTerritoryCode: 1,
      }),
      "03": Object.freeze({ nome: "Leste", valor: 937210002 }),
      "04": Object.freeze({ nome: "Sul", valor: 937210001 }),
      "05": Object.freeze({ nome: "Oeste", valor: 937210003 }),
      "08": Object.freeze({ nome: "Leste", valor: 937210002 }),
    });

    function normalizarTextoViaCep(valor) {
      return String(valor || "")
        .normalize("NFD")
        .replace(/[\u0300-\u036f]/g, "")
        .toLowerCase()
        .replace(/[^a-z0-9]+/g, " ")
        .trim();
    }

    function atualizarStatusViaCep(campoCep, mensagem, ehErro) {
      const container = campoCep.parentElement;
      if (!container) return;

      let status = container.querySelector(".viacep-status");
      if (!status) {
        status = document.createElement("small");
        status.className = "viacep-status";
        status.setAttribute("role", "status");
        status.setAttribute("aria-live", "polite");
        status.style.display = "block";
        status.style.marginTop = "4px";
        container.appendChild(status);
      }

      status.textContent = mensagem || "";
      status.style.color = ehErro ? "#b42318" : "";
    }

    function obterCampoDestinoViaCep(controle) {
      const campoDestinoDoHtml = controle.closest(".question-wrapper")?.dataset.campoDestino;
      if (campoDestinoDoHtml) return normalizarTextoViaCep(campoDestinoDoHtml);

      const respostas = getRespostas();
      const itens = Array.isArray(respostas) ? respostas : [];
      const nomeControle = normalizarTextoViaCep(controle.name);
      const item = itens.find(
        (respostaItem) => normalizarTextoViaCep(respostaItem?.Titulo) === nomeControle
      );
      return normalizarTextoViaCep(item?.CampoDestino);
    }

    function localizarControleViaCep(escopo, termosTitulo, termosDestino = [], exclusoes = []) {
      const form = document.querySelector("#formCustom") || escopo;
      const seletor =
        'input[name]:not([type="hidden"]):not([type="radio"]):not([type="checkbox"]), select[name], textarea[name]';
      const controlesFormulario = form.querySelectorAll(seletor);
      const termosCampoDestino = termosDestino.length
        ? termosDestino
        : termosTitulo;

      const controlesComDestino = Array.from(controlesFormulario).map((controle) => ({
        campoDestino: obterCampoDestinoViaCep(controle),
        controle,
      }));
      const controlePorDestinoExato = controlesComDestino.find(
        (item) =>
          item.campoDestino &&
          termosCampoDestino.some((termo) => item.campoDestino === termo)
      )?.controle;
      if (controlePorDestinoExato) return controlePorDestinoExato;

      const controlePorDestino = controlesComDestino.find((item) => {
        const campoDestino = item.campoDestino;
        return (
          campoDestino &&
          termosCampoDestino.some(
            (termo) =>
              campoDestino.startsWith(`${termo} `) ||
              campoDestino.endsWith(` ${termo}`) ||
              campoDestino.includes(` ${termo} `)
          )
        );
      })?.controle;
      if (controlePorDestino) return controlePorDestino;

      const controlesEscopo = escopo.querySelectorAll(seletor);
      return Array.from(controlesEscopo).find((controle) => {
        const nome = normalizarTextoViaCep(controle.name);
        if (!nome || exclusoes.some((termo) => nome.includes(termo))) return false;

        return termosTitulo.some(
          (termo) =>
            nome === termo ||
            nome.startsWith(`${termo} `) ||
            nome.endsWith(` ${termo}`) ||
            nome.includes(` ${termo} `)
        );
      });
    }

    function preencherControleViaCep(controle, valores, sobrescrever = false) {
      if (!controle) return false;

      const valorAnterior = controle.dataset.viacepValor || "";
      if (
        !sobrescrever &&
        String(controle.value || "").trim() &&
        controle.value !== valorAnterior
      ) {
        return false;
      }

      const candidatos = valores.filter(Boolean).map(String);
      if (!candidatos.length) return false;

      if (controle.tagName === "SELECT") {
        const candidatosNormalizados = candidatos.map(normalizarTextoViaCep);
        const opcao = Array.from(controle.options).find((item) => {
          const texto = normalizarTextoViaCep(item.textContent);
          const valor = normalizarTextoViaCep(item.value);
          return candidatosNormalizados.includes(texto) || candidatosNormalizados.includes(valor);
        });
        if (!opcao) return false;
        controle.value = opcao.value;
      } else {
        controle.value = candidatos[0];
      }

      controle.dataset.viacepValor = controle.value;
      controle.dispatchEvent(new Event("input", { bubbles: true }));
      controle.dispatchEvent(new Event("change", { bubbles: true }));
      return true;
    }

    function limparControleViaCep(controle) {
      if (!controle) return false;

      const tinhaValor =
        String(controle.value || "").trim() ||
        String(controle.dataset.viacepValor || "").trim();
      controle.value = "";
      delete controle.dataset.viacepValor;
      if (!tinhaValor) return false;

      controle.dispatchEvent(new Event("input", { bubbles: true }));
      controle.dispatchEvent(new Event("change", { bubbles: true }));
      return true;
    }

    function obterContextoEnderecoViaCep(campoCep) {
      const escopo = campoCep.closest(".form-section") || document.querySelector("#formCustom");
      const ehEnderecoAtelie =
        obterCampoDestinoViaCep(campoCep) === "address2 postalcode";
      const campos = ehEnderecoAtelie
        ? {
            tipoLogradouro: "smdet tipo logradouro atelie",
            logradouro: "address2 line1",
            complemento: "address2 line2",
            bairro: "address2 line3",
            cidade: "smdet cidade atelie",
            estado: "smdet estado atelie",
            pais: "smdet pais atelie",
            regiao: "smdet regiao atelie",
          }
        : {
            tipoLogradouro: "smdet endereco 1 tipo logradouro",
            logradouro: "address1 line1",
            complemento: "address1 line2",
            bairro: "address1 line3",
            cidade: "smdet municipio",
            estado: "smdet estado",
            pais: "smdet pais",
            regiao: "territorycode",
          };

      return { escopo, ehEnderecoAtelie, campos };
    }

    function obterControlesEnderecoViaCep(campoCep) {
      const { escopo, campos } = obterContextoEnderecoViaCep(campoCep);
      if (!escopo) return [];

      const controles = [
        localizarControleViaCep(
          escopo,
          ["tipo de logradouro"],
          [campos.tipoLogradouro]
        ),
        localizarControleViaCep(
          escopo,
          ["logradouro", "rua", "endereco"],
          [campos.logradouro, "smdet endereco"],
          ["email", "eletronico"]
        ),
        localizarControleViaCep(escopo, ["complemento"], [campos.complemento]),
        localizarControleViaCep(escopo, ["bairro"], [campos.bairro]),
        localizarControleViaCep(
          escopo,
          ["cidade", "municipio"],
          [campos.cidade]
        ),
        localizarControleViaCep(
          escopo,
          ["estado", "uf"],
          [campos.estado],
          ["civil"]
        ),
        localizarControleViaCep(escopo, ["pais"], [campos.pais]),
        localizarControleViaCep(escopo, ["regiao"], [campos.regiao]),
      ].filter((controle) => controle && controle !== campoCep);

      return Array.from(new Set(controles));
    }

    function bloquearEnderecoViaCep(campoCep) {
      if (bloqueiosEnderecoViaCep.has(campoCep)) return;

      const estados = obterControlesEnderecoViaCep(campoCep).map((controle) => ({
        controle,
        disabled: controle.disabled,
        readOnly: controle.readOnly,
        ariaDisabled: controle.getAttribute("aria-disabled"),
      }));

      estados.forEach(({ controle }) => {
        if (controle.tagName === "SELECT") {
          controle.disabled = true;
        } else {
          controle.readOnly = true;
        }
        controle.setAttribute("aria-disabled", "true");
      });

      bloqueiosEnderecoViaCep.set(campoCep, estados);
      camposCepPendentes.add(campoCep);
    }

    function desbloquearEnderecoViaCep(campoCep) {
      const estados = bloqueiosEnderecoViaCep.get(campoCep) || [];
      estados.forEach(({ controle, disabled, readOnly, ariaDisabled }) => {
        controle.disabled = disabled;
        controle.readOnly = readOnly;
        if (ariaDisabled == null) {
          controle.removeAttribute("aria-disabled");
        } else {
          controle.setAttribute("aria-disabled", ariaDisabled);
        }
      });

      bloqueiosEnderecoViaCep.delete(campoCep);
      camposCepPendentes.delete(campoCep);
    }

    function cancelarConsultaViaCep(campoCep, limparStatus = false) {
      const requisicao = viaCepRequests.get(campoCep);
      if (!requisicao) return false;

      viaCepRequests.delete(campoCep);
      clearTimeout(requisicao.timeout);
      requisicao.controller.abort();
      desbloquearEnderecoViaCep(campoCep);
      campoCep.removeAttribute("aria-busy");
      if (limparStatus) atualizarStatusViaCep(campoCep, "", false);
      return true;
    }

    function inicializarBloqueioEnvioViaCep() {
      if (bloqueioEnvioViaCepInicializado) return;

      const form = document.querySelector("#formCustom");
      if (!form) return;
      bloqueioEnvioViaCepInicializado = true;

      const impedirEnvio = (event) => {
        if (!camposCepPendentes.size) return;

        event.preventDefault();
        event.stopImmediatePropagation();
        const campoCep = camposCepPendentes.values().next().value;
        atualizarStatusViaCep(
          campoCep,
          "Aguarde a conclusão da consulta do CEP.",
          false
        );
        campoCep.focus();
      };

      form.addEventListener("submit", impedirEnvio, true);
      form.addEventListener(
        "click",
        (event) => {
          const botaoEnviar = event.target?.closest?.("#btnEnviarFormulario");
          if (botaoEnviar) impedirEnvio(event);
        },
        true
      );
    }

    function resolverRegiaoViaCep(cep, localidade, uf, campoDestinoRegiao) {
      const cidadeNormalizada = normalizarTextoViaCep(localidade);
      const ufNormalizada = normalizarTextoViaCep(uf);
      if (
        cidadeNormalizada !== "sao paulo" ||
        (ufNormalizada !== "sp" && ufNormalizada !== "sao paulo")
      ) {
        return null;
      }

      const prefixo = String(cep || "").replace(/\D/g, "").substring(0, 2);
      const regiao = regioesPorPrefixoCep[prefixo];
      if (!regiao) return null;

      const ehTerritoryCode =
        normalizarTextoViaCep(campoDestinoRegiao) === "territorycode";
      return {
        nome: regiao.nome,
        valor:
          ehTerritoryCode && regiao.valorTerritoryCode != null
            ? regiao.valorTerritoryCode
            : regiao.valor,
      };
    }

    function obterTextoControleViaCep(controle) {
      if (!controle) return "";
      if (controle.tagName === "SELECT") {
        const opcao = controle.options[controle.selectedIndex];
        return String(opcao?.textContent || controle.value || "").trim();
      }
      return String(controle.value || "").trim();
    }

    function atualizarRegiaoViaCep(campoCep, dados = {}) {
      const { escopo, campos } = obterContextoEnderecoViaCep(campoCep);
      if (!escopo) return false;

      const controleRegiao = localizarControleViaCep(
        escopo,
        ["regiao"],
        [campos.regiao]
      );
      const regiao = resolverRegiaoViaCep(
        dados.cep || campoCep.value,
        dados.localidade,
        dados.uf || dados.estado,
        campos.regiao
      );

      if (!regiao) return limparControleViaCep(controleRegiao);
      return preencherControleViaCep(
        controleRegiao,
        [regiao.valor, regiao.nome],
        true
      );
    }

    function preencherEnderecoViaCep(campoCep, dados) {
      const { escopo, campos } = obterContextoEnderecoViaCep(campoCep);
      if (!escopo) return;

      const logradouroCompleto = String(dados.logradouro || "").trim();
      const partesLogradouro = logradouroCompleto.match(/^(\S+)\s+(.+)$/);
      const tipoLogradouro = partesLogradouro?.[1] || "";
      const controleTipoLogradouro = localizarControleViaCep(
        escopo,
        ["tipo de logradouro"],
        [campos.tipoLogradouro]
      );
      const tipoPreenchido = preencherControleViaCep(
        controleTipoLogradouro,
        [tipoLogradouro],
        true
      );

      preencherControleViaCep(
        localizarControleViaCep(
          escopo,
          ["logradouro", "rua", "endereco"],
          [campos.logradouro, "smdet endereco"],
          ["email", "eletronico"]
        ),
        [tipoPreenchido && partesLogradouro ? partesLogradouro[2] : logradouroCompleto],
        true
      );
      preencherControleViaCep(
        localizarControleViaCep(escopo, ["bairro"], [campos.bairro]),
        [dados.bairro],
        true
      );
      preencherControleViaCep(
        localizarControleViaCep(escopo, ["cidade", "municipio"], [campos.cidade]),
        [dados.localidade],
        true
      );
      preencherControleViaCep(
        localizarControleViaCep(
          escopo,
          ["estado", "uf"],
          [campos.estado],
          ["civil"]
        ),
        [dados.estado, dados.uf],
        true
      );
      preencherControleViaCep(
        localizarControleViaCep(escopo, ["complemento"], [campos.complemento]),
        [dados.complemento]
      );
      preencherControleViaCep(
        localizarControleViaCep(escopo, ["pais"], [campos.pais]),
        ["Brasil"],
        true
      );
      atualizarRegiaoViaCep(campoCep, dados);
    }

    async function consultarViaCep(campoCep) {
      const cep = String(campoCep.value || "").replace(/\D/g, "");
      cancelarConsultaViaCep(campoCep);
      campoCep.setCustomValidity("");
      atualizarRegiaoViaCep(campoCep);

      if (!cep) {
        atualizarStatusViaCep(campoCep, "", false);
        return;
      }

      if (!/^\d{8}$/.test(cep)) {
        campoCep.setCustomValidity("Informe um CEP com 8 dígitos.");
        atualizarStatusViaCep(campoCep, "Informe um CEP com 8 dígitos.", true);
        campoCep.reportValidity();
        return;
      }

      const controller = new AbortController();
      let expirou = false;
      const requisicao = { cep, controller, timeout: null };
      viaCepRequests.set(campoCep, requisicao);
      requisicao.timeout = setTimeout(() => {
        expirou = true;
        controller.abort();
      }, 8000);

      bloquearEnderecoViaCep(campoCep);
      campoCep.setAttribute("aria-busy", "true");
      atualizarStatusViaCep(campoCep, "Consultando CEP...", false);

      try {
        let dados = viaCepCache.get(cep);
        if (!dados) {
          const response = await fetch(`https://viacep.com.br/ws/${cep}/json/`, {
            headers: { Accept: "application/json" },
            referrerPolicy: "no-referrer",
            signal: controller.signal,
          });
          if (!response.ok) throw new Error("Falha na consulta do CEP.");
          dados = await response.json();
          viaCepCache.set(cep, dados);
        }

        if (String(campoCep.value || "").replace(/\D/g, "") !== cep) return;

        if (dados.erro) {
          campoCep.setCustomValidity("CEP não encontrado.");
          atualizarStatusViaCep(campoCep, "CEP não encontrado.", true);
          campoCep.reportValidity();
          return;
        }

        campoCep.value = dados.cep || campoCep.value;
        campoCep.dispatchEvent(new Event("input", { bubbles: true }));
        campoCep.dispatchEvent(new Event("change", { bubbles: true }));
        preencherEnderecoViaCep(campoCep, dados);
        atualizarStatusViaCep(campoCep, "CEP localizado.", false);
      } catch (error) {
        if (viaCepRequests.get(campoCep) !== requisicao) return;

        campoCep.setCustomValidity("");
        atualizarStatusViaCep(
          campoCep,
          expirou
            ? "A consulta demorou mais que o esperado. Preencha o endereço manualmente."
            : "Não foi possível consultar o CEP. Preencha o endereço manualmente.",
          true
        );
      } finally {
        clearTimeout(requisicao.timeout);
        if (viaCepRequests.get(campoCep) === requisicao) {
          viaCepRequests.delete(campoCep);
          desbloquearEnderecoViaCep(campoCep);
          campoCep.removeAttribute("aria-busy");
        }
      }
    }

    function inicializarConsultaViaCep() {
      document
        .querySelectorAll('#formCustom input[oninput*="MascaraDeCEP"]')
        .forEach((campoCep) => {
          if (campoCep.dataset.viacepInicializado === "1") return;
          campoCep.dataset.viacepInicializado = "1";
          const { escopo, campos } = obterContextoEnderecoViaCep(campoCep);
          const controleCidade = escopo
            ? localizarControleViaCep(
                escopo,
                ["cidade", "municipio"],
                [campos.cidade]
              )
            : null;
          const controleEstado = escopo
            ? localizarControleViaCep(
                escopo,
                ["estado", "uf"],
                [campos.estado],
                ["civil"]
              )
            : null;
          const reavaliarRegiao = () =>
            atualizarRegiaoViaCep(campoCep, {
              cep: campoCep.value,
              localidade: obterTextoControleViaCep(controleCidade),
              uf: obterTextoControleViaCep(controleEstado),
            });

          campoCep.addEventListener("input", () => {
            atualizarRegiaoViaCep(campoCep);
            const requisicao = viaCepRequests.get(campoCep);
            const cepAtual = String(campoCep.value || "").replace(/\D/g, "");
            if (requisicao && cepAtual !== requisicao.cep) {
              cancelarConsultaViaCep(campoCep, true);
            }
          });
          campoCep.addEventListener("blur", () => consultarViaCep(campoCep));
          [controleCidade, controleEstado].forEach((controle) => {
            if (!controle || controle.dataset.viacepRegiaoInicializada === "1") return;
            controle.dataset.viacepRegiaoInicializada = "1";
            controle.addEventListener("input", reavaliarRegiao);
            controle.addEventListener("change", reavaliarRegiao);
          });
        });
      inicializarBloqueioEnvioViaCep();
    }

    return Object.freeze({
      normalizarTextoViaCep,
      atualizarStatusViaCep,
      obterCampoDestinoViaCep,
      localizarControleViaCep,
      preencherControleViaCep,
      limparControleViaCep,
      resolverRegiaoViaCep,
      atualizarRegiaoViaCep,
      preencherEnderecoViaCep,
      consultarViaCep,
      inicializarConsultaViaCep,
    });
  }

  global.FormularioInscricaoCore = Object.freeze({
    validarCpf,
    validarEmail,
    formatFileSize,
    updateFileInfo,
    validarArquivo,
    criarGuidAnexo,
    persistirAnexos,
    listarAnexos,
    marcarAnexoEnviado,
    removerAnexos,
    removerAnexosExpirados,
    arquivoParaBase64,
    criarViaCep,
  });
})(window);