void-install.old

#!/usr/bin/env bash
#shellcheck disable=SC2145,SC2001,SC2188,SC2015,SC2155,SC2317,SC2320,SC2291,SC2034,SC2120,SC2086,SC2319
#shellcheck disable=SC2016,SC2154,SC2207,SC2166,SC2128,SC2059,SC2140,SC2031,SC2030,SC2036,SC2119,SC2027
#
#  void-install
#  Created: 2022/12/24
#  Updated: dom 30 ago 2026 04:57:54 -04
#
#  Copyright (c) 2022-2026, Vilmar Catafesta <vcatafesta@gmail.com>
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions
#  are met:
#  1. Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
#  2. Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
#  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
#  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
#  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
#  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
#  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
##############################################################################
export LANGUAGE="${LANGUAGE:-pt_BR}"
export TEXTDOMAINDIR=/usr/share/locale
export TEXTDOMAIN=void-install

#todo
#usermod -a -G bluetooth $USER

#debug
red="$(tput bold)$(tput setaf 196)"
green="$(tput bold)$(tput setaf 2)"
pink="$(tput setaf 5)"
cyan="$(tput setaf 6)"
reset="$(tput sgr0)"
rst="$(tput sgr0)"
export PS4='${red}${0##*/}${green}[${FUNCNAME[0]:-MAIN}]${pink}[$LINENO]${reset} '
#set -x
#set -eo pipefail
shopt -s extglob

#system
readonly APP="${0##*/}"
readonly _VERSION_='3.8.30-20260830'
declare -g DEPENDENCIES=(dialog rsync awk tar sed cat grep sort tr
	chroot blkid fdisk parted lsblk curl xz tee
	mkfs.vfat mkfs.xfs mkfs.ntfs mkfs.jfs mkfs.btrfs mkfs.f2fs mkfs.nilfs2
	lvm cryptsetup gettext tput gdisk
)
declare -gA PACKAGEDEP=(
	['tput']='ncurses'
	['qemu-system-x86_64']='qemu-full'
	['spice-vdagent']='spice-vdagent'
	['remote-viewer']='virt-viewer'
	['python3']='python'
	['virsh']='libvirt'
	['find']='findutils'
	['awk']='gawk'
	['brctl']='bridge-utils'
	['gdisk']='gptfdisk'
)
readonly LOCKFILE="/tmp/void-install.lock"
declare -gA DISTRO_PKGS=(
	["voidbr"]="dialog gettext rsync parted curl xz lvm2 xfsprogs ntfs-3g jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["void"]="dialog gettext rsync parted curl xz lvm2 xfsprogs ntfs-3g jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["void-live"]="dialog gettext rsync parted curl xz lvm2 xfsprogs ntfs-3g jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["voidlinux"]="dialog gettext rsync parted curl xz lvm2 xfsprogs ntfs-3g jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["chili"]="dialog gettext rsync parted curl xz lvm2 xfsprogs libntfs-3g ntfs-3g ntfsprogs jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["chililinux"]="dialog gettext rsync parted curl xz lvm2 xfsprogs libntfs-3g ntfs-3g ntfsprogs jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["arch"]="dialog gettext rsync parted curl xz lvm2 xfsprogs libntfs-3g ntfs-3g ntfsprogs jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["manjaro"]="dialog gettext rsync parted curl xz lvm2 xfsprogs libntfs-3g ntfs-3g ntfsprogs jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
	["debian"]="dialog gettext-base rsync parted curl xz-utils lvm2 xfsprogs ntfs-3g jfsutils gptfdisk btrfs-progs f2fs-tools nilfs-utils"
)
declare -gA DISTRO_MGR=(
	["voidbr"]="xbps-install -Syu --ignore-file-conflicts"
	["void"]="xbps-install -Syu --ignore-file-conflicts"
	["void-live"]="xbps-install -Syu --ignore-file-conflicts"
	["voidlinux"]="xbps-install -Syu --ignore-file-conflicts"
	["chili"]="pacman -Sy --needed --noconfirm"
	["chililinux"]="pacman -Sy --needed --noconfirm"
	["arch"]="pacman -Sy --needed --noconfirm"
	["manjaro"]="pacman -Sy --needed --noconfirm"
	["debian"]="apt-get install -y"
)

declare LCUSTOM=false
declare LAUTOLOGIN=false
declare LEFI=false
declare LGRUB=false
declare LLOADER=true
declare LDISK=false
declare LMIRROR=true
declare LSOURCE=true
declare LKEYMAP=true
declare LTIMEZONE=true
declare LKERNEL=true
declare LWM=true
declare LDM=true
declare LAUTO=true
declare LMKPARTED=false
declare LFSREVISED=false
declare LFS=false
declare LPARTITION=false
declare LBIND=false
declare LBIOS=true
declare LOSPROBER=false
declare LCHROOT=false
declare LINSTALL=false
declare LVM=false
declare LFDE=false
declare LONLY_TTY=true
declare LAUDIO=false
declare LSERVER=false
declare LDHCP=false
declare LEXTRA=false
declare LLOCALE=true
declare LXORG=false
declare LSWAY=false
declare LMANGO=false
declare LHYPRLAND=false
#
declare DEFITEM
#
declare -gi njobs=73
declare -gi ncounter=0
declare -gi quiet=0
declare -gi grafico=1
#
declare -ga aCustomPackages=()
declare -gA Amkfs
declare -gA Amntpoint
declare -gA AmntpointFDE
declare -gA AARRAY_DSK_DEVICES
declare -gA AARRAY_PART_DEVICES
declare -gA AARRAY_VG_DEVICES
#
declare chostname_base='voidbr'
declare -gA AsUser=(
	[cpass]='voidlinux'
	[cpassroot]='voidlinux'
	[chostname]='voidbr'
	[cgroups]='wheel,audio,video,tty,floppy,cdrom,optical,kvm,xbuilder'
)
#
declare -gA AConfFde=(
	[partition]=''
	[vg]='voidvm'
	[passphrase]='voidlinux'
	[verifypassphrase]='voidlinux'
	[lvroot]='25%'
	[lvswap]='2%'
	[lvvar]=''
	[lvhome]='100%'
)
declare -gA AConfDisk=(
	[_DEVICE]='/dev/sdX'
	[_FILESYSTEM]='ext4'
	[_DISKTABLE]=''
	[_BOOTLOADER]='/dev/sdX'
	[_OSPROBER]=false
	[_HEALTH]='/dev/sdX'
)
declare -gA AConfLocale=(
	[_TIMEZONE]='America/Sao_Paulo'
	[_KEYMAP]='br-abnt2'
	[_CLOCK]='UTC'
	[_FONT]='Uni3-TerminusBold24x12'
	[_LOCALE]='pt_BR.utf8'
	[_REGION]='Portuguese Brazil'
)
declare -gA AConfMirror=(
	[_SOURCE]='network'
	#	[_MIRROR]='repo.fastly.voidlinux.org'
	#	[url_mirror]='https://repo-fastly.voidlinux.org'
	#	[location]='Fastly Global CDN'
	[_MIRROR]='void.voidbr.org'
	[url_mirror]='https://void.voidbr.org/voidlinux/'
	[location]='M. do Paranapanema, Brazil'
)
declare -gA AConfAudio=(
	[_AUDIOSERVER]='None'
)
declare -gA AConfKernel=(
	[_KERNEL]='linux'
)
declare -gA AConfBootLoader=(
	[_LOADER]='grub'
)
declare -gA AConfWifi=(
	[_NETWORK]='wifi_ssid'
	[_PASSWORD]='wifi_password'
)
declare -gA Alanguage=(
	[pt_BR]=0
	[en_US]=1
	[de_DE]=2
	[fr_FR]=3
	[es_ES]=4
	[it_IT]=5
)
declare -gA Alocale=(
	[0]=pt_BR
	[1]=en_US
	[2]=de_DE
	[3]=fr_FR
	[4]=es_ES
	[5]=it_IT
)
declare -gA AsDhcp=(
	AsDhcp [IFACE]="${Asdhcp[IFACE]:-eth0}"
	AsDhcp [IP]="${AsDhcp[IP]:-192.168.1.100}"
	AsDhcp [CIDR]="${AsDhcp[CIDR]:-24}"
	AsDhcp [GATEWAY]="${AsDhcp[GATEWAY]:-192.168.1.1}"
	AsDhcp [DNS1]="${AsDhcp[DNS1]:-1.1.1.1}"
	AsDhcp [DNS2]="${AsDhcp[DNS2]:-8.8.8.8}"
)
declare -gA AsDiskPercent=(
	[_DISKTABLE]="EFI"
	[root]="100"
	[boot]="0"
	[home]="0"
	[swap]="0"
)
declare -gA AsDiskSize=(
	[root]="0"
	[boot]="0"
	[home]="0"
	[swap]="0"
)
declare -gA AsFs=(
	[_DEVICE]='/dev/sdX'
	[root]="ext4"
	[boot]="ext4"
	[home]="ext4"
	[swap]="swap"
)

declare dialogRcFile="$HOME/.dialogrc"
declare _DISPLAYMANAGER='None'
declare _WINDOWMANAGER=('tty')
declare _WM='tty'
declare _WIFI_NETWORK="wifi_ssid"
declare _WIFI_PASSWORD="wifi_password"
declare Interrupted="$(gettext "Interrompido! Saindo...")"
trap 'printf "\n${red}$Interrupted\n"; cleanup; exit 0' INT TERM HUP

cleanup() {
	# Silencia erros no cleanup para evitar loops de erro na saída
	exec 2>/dev/null
	info_msg "$(gettext 'Removendo arquivos temporários')..."
	[[ -f "$BOOTLOG" ]] && rm -f "$BOOTLOG"
	# Só tenta desmontar se o diretório de instalação existir e estiver montado
	mountpoint -q "$dir_install" && sh_umount_fs
	exit 1
}

detect_distro() {
	local id=""

	if [[ -r /etc/os-release ]]; then
		# Lê ID=void|arch|debian|... exatamente como a distro declara
		id=$(grep -E '^ID=' /etc/os-release | cut -d= -f2 | tr -d '"')
	elif [[ -r /usr/lib/os-release ]]; then
		id=$(grep -E '^ID=' /usr/lib/os-release | cut -d= -f2 | tr -d '"')
	else
		echo "unknown"
		return
	fi
	echo "$id"
}

readconf() {
	if [[ $LC_DEFAULT -eq 0 ]]; then
		read -r -p "$@ [S/n]"
	else
		read -r -p "$@ [Y/n]"
	fi
	[[ ${REPLY^} == "" ]] && return 0
	[[ ${REPLY^} == N ]] && return 1 || return 0
}

check_gettext() {
	# 1. Se o gettext já estiver disponível, não faz nada e retorna sucesso
	if command -v gettext >/dev/null; then
		return 0
	fi
	# 2. Segurança: Operações de pacotes exigem root
	if ((EUID != 0)); then
		echo -e "${red}erro: você não pode realizar esta operação a menos que seja root.${reset}"
		exit 1
	fi
	echo -e "Distro detectada: ${green}${DISTRO}${reset}"

	# 3. Extração dos dados dos mapas que você definiu
	local pkgs="${DISTRO_PKGS[$DISTRO]}"
	local cmd="${DISTRO_MGR[$DISTRO]}"

	# Se a distro atual não existir no mapa, precisamos avisar e parar
	if [[ -z "$cmd" ]]; then
		echo -e "${red}Erro: Nenhuma configuração de pacotes encontrada para a distro: '$DISTRO'${reset}"
		exit 1
	fi

	# 4. Prompt ao usuário (usando sua função readconf)
	# Se gettext não existe, as mensagens ainda precisam ser via echo/printf
	if readconf "${red}FALHA:${reset} ${cyan}Pacote/Comando 'gettext' não encontrado. Instalar dependências base agora?${reset}"; then
		echo -e "${blue}::${reset} Preparando ambiente para ${green}${DISTRO}${reset}..."
		# Execução dinâmica: $cmd (gerenciador) + $pkgs (lista de pacotes)
		if ! $cmd $pkgs; then
			echo -e "${red}Erro Crítico:${reset} A instalação dos pacotes básicos falhou."
			exit 1
		fi
		echo -e "${green}Sucesso:${reset} Dependências instaladas."
	else
		# Se o usuário negar a instalação de ferramentas básicas, o instalador não tem como seguir
		echo -e "${yellow}Aviso:${reset} O gettext é indispensável para as traduções. Saindo..."
		exit 1
	fi
}

check_dependencies() {
	local TMP_FILE="/tmp/$(basename "$0").restarted"
	local d
	local errorFound=false
	local aCmdNotFound=()

	clear
	reset
	for d in "${DEPENDENCIES[@]}"; do
		if [[ -z $(command -v "$d") ]]; then
			if has_command dialog; then
				sh_info_msg "${RED} ✗ ${RST} ${cmsg_CommandNotFound} ${CYAN}'$d'${RST}"
			else
				printf '%s\n' "${red} ✗ ${rst} ${cmsg_CommandNotFound} ${cyan}'$d'${reset}"
			fi
			aCmdNotFound+=("$d")
			errorFound=true
		fi
	done

	if ! $errorFound; then
		return 0
	fi

	if has_command dialog; then
		sh_info_msg "Distro detectada: ${GREEN}${DISTRO}${RST}"
	else
		echo -e "Distro detectada: ${green}${DISTRO}${rst}"
	fi

	# 3. Extração dos dados dos mapas que você definiu
	local pkgs="${DISTRO_PKGS[$DISTRO]}"
	local cmd="${DISTRO_MGR[$DISTRO]}"

	# Se a distro atual não existir no mapa, precisamos avisar e parar
	if [[ -z "$cmd" ]]; then
		if has_command dialog; then
			alerta "${APP}" "${RED}Erro: Nenhuma configuração de pacotes encontrada para a distro: '$DISTRO'${RST}"
		else
			echo -e "${red}Erro: Nenhuma configuração de pacotes encontrada para a distro: '$DISTRO'${rst}"
		fi
		exit 1
	fi

	lprossiga=false
	if has_command dialog; then
		if conf "${APP}" \
			"\n${BOLD}${RED} ✗ ${RST} ${cmsg_CommandNotFound} ${CYAN}'${aCmdNotFound[*]}'${RST}" \
			"\n\n${YELLOW}Instalar dependências base agora ?"; then
			lprossiga=true
		fi
	else
		echo
		if readconf "${cyan}Instalar dependências base agora?${rst}"; then
			lprossiga=true
		fi
	fi

	if $lprossiga; then
		if has_command dialog; then
			sh_info_msg "${BLUE}::${RST} Preparando ambiente para ${GREEN}${DISTRO}${RST}..."
		else
			echo -e "${blue}::${reset} Preparando ambiente para ${green}${DISTRO}${rst}..."
		fi
		# Execução dinâmica: $cmd (gerenciador) + $pkgs (lista de pacotes)
		if ! $cmd $pkgs; then
			if has_command dialog; then
				alerta "${APP}" "${RED}Erro Crítico:${RST} A instalação dos pacotes básicos falhou."
			else
				echo -e "${red}Erro Crítico:${reset} A instalação dos pacotes básicos falhou."
			fi
			exit 1
		fi
		echo -e "${green}Sucesso:${reset} Dependências instaladas."
		touch "$TMP_FILE"
		exec "$0" "$@"
	else
		# Se o usuário negar a instalação de ferramentas básicas, o instalador não tem como seguir
		if has_command dialog; then
			alerta "${APP}" "${YELLOW}Aviso:${RST} Os comandos são indispensáveis. Saindo..."
		else
			echo -e "${yellow}Aviso:${rst} Os comandos são indispensáveis. Saindo..."
		fi
		exit 1
	fi
}

has_command() {
	command -v "$1" >/dev/null && return 0 || return 1
}

###########################################################################################################
# Corte para teste do gettext
DISTRO="$(detect_distro)"
check_gettext
###########################################################################################################

sh_enablePrintk() {
	if [[ -w /proc/sys/kernel/printk ]]; then
		echo 4 >/proc/sys/kernel/printk
	fi
}

get_option() {
	echo $(grep -E "^${1}.*" $app_conf | sed -e "s|${1}||")
}

die() {
	local msg=$1
	local erros
	local tmp

	if test $# -ge 2; then
		evaluate_retval 1
	fi

	#  mapfile -t erros < <(
	#    tail -n 30 "$BOOTLOG" | grep -Ei 'ERRO:|ERROR:|FAIL|FAILED'
	#  )
	#  if [[ "${#erros[@]}" -eq 0 ]]; then
	#    mapfile -t erros < <(
	#      tail -n 20 "$BOOTLOG"
	#    )
	#  fi

	tmp="$(mktemp)"
	# tail -n 40 "$BOOTLOG" | grep -Ei 'ERRO:|ERROR:|FAIL|FAILED' > "$tmp"
	tail -n 13 "$BOOTLOG" >"$tmp"
	printf '\n%s\n' "$msg" >>"$tmp"

	shift

	if has_command dialog; then
		#alerta_die "DIE" "\n${BOLD}${RED}$msg${RST}" erros
		${DIALOG} --title "ERRO - $msg" --textbox "$tmp" 20 120
		rm -f "$tmp"
	else
		printf "%-75s\n" "$(DOT)${bold}${red}$msg${reset}" >&2
	fi
	sh_enablePrintk
	exit 1
}

DOT() {
	printf "%s" "${blue}:: ${reset}"
}

sh_create_dialogrc() {
	cat >"$dialogRcFile" <<-'EOF'
		screen_color = (white,black,off)
		dialog_color = (white,black,off)
		title_color = (green,black,on)
		border_color = dialog_color
		shadow_color = (black,black,on)
		button_inactive_color = dialog_color
		button_key_inactive_color = dialog_color
		button_label_inactive_color = dialog_color
		button_active_color = (black,green,on)
		button_key_active_color = button_active_color
		button_label_active_color = (white,green,on)
		tag_key_selected_color = (white,green,on)
		item_selected_color = tag_key_selected_color
		form_text_color = (green,black,on)
		form_item_readonly_color = (cyan,black,on)
		itemhelp_color = (white,green,off)
		inputbox_color = dialog_color
		inputbox_border_color = dialog_color
		searchbox_color = dialog_color
		searchbox_title_color = title_color
		searchbox_border_color = border_color
		position_indicator_color = title_color
		menubox_color = dialog_color
		menubox_border_color = border_color
		item_color = dialog_color
		tag_color = title_color
		tag_selected_color = button_label_active_color
		tag_key_color = button_key_inactive_color
		check_color = dialog_color
		check_selected_color = button_active_color
		uarrow_color = screen_color
		darrow_color = screen_color
		form_active_text_color = button_active_color
		gauge_color = title_color
		border2_color = dialog_color
		searchbox_border2_color = dialog_color
		menubox_border2_color = dialog_color
		separate_widget = ''
		tab_len = 0
		visit_items = off
		use_shadow = off
		use_colors = on
	EOF
	export DIALOGRC="$dialogRcFile"
}

sh_cmd_job() {
	local cmsg="$1"
	local cjob="$2"
	local erro_fatal="$3"
	local lretval=0
  local disk="${AConfDisk[_DEVICE]}"

#	cmsg+=" ${cmsg_Em} ${yellow}${disk}"
	last_msg="$cmsg"
	msg "INFO" "$last_msg" "$(log_info_msg "$last_msg")"

	if ((grafico)); then
		read LINES COLUMNS <<<"$(stty size)"
		cmsg=$(strip_ansi "$cmsg")
		eval "$cjob" 2>&1 | tee -i -a "$BOOTLOG" |
			${DIALOG} \
				--colors \
				--backtitle "$ccabec" \
				--title "\Zb\Z3[$ufmt] ${WHITE}[$cmsg] ${CYAN}[$(sh_time_elapsed)]${RST}" \
				--progressbox $((MAXROW / 2)) $((MAXCOL - 20))
	else
		eval "$cjob" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	fi

	lretval="${PIPESTATUS[0]}"
	evaluate_retval "$lretval" "$erro_fatal"
	shell='/bin/sh'

	return "$lretval"
}

sh_chroot_job() {
	local cmsg="$1"
	local cjob="$2"
	local erro_fatal="$3"
	local level="$4"
	local lretval=0
  local disk="${AConfDisk[_DEVICE]}"

#	cmsg+=" ${cmsg_Em} ${yellow}${disk}"
	last_msg="$cmsg"

	# CHAMADA DA MSG: Agora com "silent" para não cagar o progressbox abaixo
	if [[ -n "$level" ]]; then
		msg "INFO" "$last_msg" "$(log_info_msg_level "$last_msg")" "silent"
	else
		msg "INFO" "$last_msg" "$(log_info_msg "$last_msg")" "silent"
	fi

	if ((grafico)); then
		read LINES COLUMNS <<<"$(stty size)"
		clean_logmessage="$(strip_ansi "$logmessage")"
		# SEU CÓDIGO ORIGINAL ABAIXO
		chroot "$dir_install" "$shell" -c "$cjob" 2>&1 | tee -i -a "$BOOTLOG" |
			${DIALOG} \
				--colors \
				--backtitle "$ccabec" \
				--title "\Zb\Z3[$ufmt] \Z7[$clean_logmessage]\Zn \Z6[$(sh_time_elapsed)]\Zn" \
				--progressbox $((MAXROW / 2)) $((MAXCOL - 20))
	else
		chroot "$dir_install" "$shell" -c "$cjob" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	fi

	lretval="${PIPESTATUS[0]}"
	evaluate_retval "$lretval" "$erro_fatal" "" "$level"
	shell='/bin/sh'

	return "$lretval"
}

sh_update_sshd() {
	sh_chroot_job "$(gettext 'Atualizando config sshd')" '
   	mkdir -p /etc/ssh/sshd_config.d/
	   cat >/etc/ssh/sshd_config.d/10-custom.conf <<'EOF'
# Configurações gerais
PermitTTY yes
PrintMotd yes
PrintLastLog yes
Banner /etc/issue.net

# Autenticação
PermitRootLogin yes
PasswordAuthentication yes
KbdInteractiveAuthentication yes
ChallengeResponseAuthentication yes
PubkeyAuthentication yes
PubkeyAcceptedKeyTypes=+ssh-rsa
AuthorizedKeysFile .ssh/authorized_keys
UsePAM yes

# Recursos
X11Forwarding yes
Subsystem sftp internal-sftp
EOF

   ' $err_not_fatal

}

sh_update_locale() {
	local f="${dir_install}/etc/default/libc-locales"
	local cConf_file="${dir_install}/etc/locale.conf"
	local raw="${AConfLocale[_LOCALE]}"
	raw="${raw%%.*}"
	export base="${raw}.UTF-8"
	export locale="${raw}.UTF-8 UTF-8"

	sh_cmd_job "${cmsg_Ajustando} locales [/etc/default/libc-locales, /etc/locale.conf]" "
	sed -i '/^[^#]/ s/^/#/' \"$f\"
	printf '%s\n' \"$locale\" >>\"$f\"

	touch "$cConf_file"
	cat >"$cConf_file" <<EOF
LANG=$base
LANGUAGE=$base
LC_COLLATE=C
LC_ALL=$base
EOF
	" $err_not_fatal

	#   sh_chroot_job "${cmsg_Configurando} locales" "
	#      xbps-reconfigure --force glibc-locales
	#   "

}

sh_update_self() {
	local repo_url="https://raw.githubusercontent.com/voidlinuxbr/void-install/main/void-install"
	local local_script="$0"
	local temp_file
	local remote_hash
	local local_hash

	# Cria um arquivo temporário para armazenar a versão remota
	temp_file=$(mktemp)
	log_msg "$(gettext 'Verificando por atualizações do script')..."

	# Baixa a versão mais recente do repositório
	if command -v curl >/dev/null 2>&1; then
		curl -sSfL "$repo_url" -o "$temp_file"
	elif command -v wget >/dev/null 2>&1; then
		wget -q "$repo_url" -O "$temp_file"
	else
		log_msg "$(gettext 'Erro: nem curl nem wget estão instalados. Atualização não pode ser realizada.')"
		rm -f "$temp_file"
		return 1
	fi

	# Calcula os hashes das versões local e remota
	remote_hash=$(sha256sum "$temp_file" | awk '{print $1}')
	local_hash=$(sha256sum "$local_script" | awk '{print $1}')

	# Compara os hashes para detectar mudanças
	if [[ "$remote_hash" != "$local_hash" ]]; then
		log_msg "$(gettext 'Nova versão encontrada. Atualizando o script...')"
		mv "$temp_file" "$local_script"
		chmod +x "$local_script"
		log_msg "$(gettext 'Atualização concluída. Recarregando o script...')"
		exec "$local_script" "$@" # Recarrega o script com os mesmos argumentos
	else
		log_msg "$(gettext 'O script já está atualizado.')"
		rm -f "$temp_file"
	fi
}

sh_configure_display_manager() {
	if ! $LONLY_TTY; then
		case $_DISPLAYMANAGER in
		lxdm)
			aDisplaymanager=(lxdm)
			custom=(lxdm-theme-vdojo)
			;;

		sddm)
			aDisplaymanager=(
				sddm
				weston # Reference implementation of a Wayland compositor
			)
			custom=(voidbr-sddm-themes)
			;;

		gdm)
			aDisplaymanager=(gdm)
			;;

		lightdm)
			aDisplaymanager=(
				lightdm
				lightdm-gtk-greeter
				lightdm-gtk-greeter-settings
				arc-theme
				papirus-icon-theme
			)
			custom=(voidbr-lightdm-themes)
			;;

		*)
			aDisplaymanager=()
			custom=()
			;;
		esac

		# aplica config custom somente se LCUSTOM for true
		#		if $LCUSTOM && ((${#custom[@]})); then
		if $LCUSTOM; then
			aDisplaymanagerConfig=("${custom[@]}")
		fi
	fi
}

sh_choose_common_packages() {
	declare -ga aDisplaymanager=()
	declare -ga aDisplaymanagerConfig=()
	declare -ga custom=()
	declare -ga aExtra=(
		bash-completion
		fzf
		dialog
		pv
		tree
		duf
		parted
		rsync
		nvme-cli
		curl
		wget
		nano
	)

	if $LCUSTOM; then
		declare -ga aMicrocode=(
			intel-ucode
			linux-firmware-amd
		)

		declare -ga aSuplemento=(
			voidbr-utils
			voidbr-nano-config
			voidbr-webapps
			chili-utils
			chili-clonedisk
		)

		aExtra+=(
			parallel
		)
	fi

	sh_configure_display_manager

	if $LSERVER; then
		aPackageDaemons+=(iptables)
		aServicesTTY+=(dhcpcd iptables)
		return
	fi

	#common
	aPackageDaemons+=(NetworkManager dhcpcd)
	aServicesTTY+=(NetworkManager)

	if $LSWAY; then
		return
	fi

	if $LMANGO; then
		return
	fi

	if $LHYPRLAND; then
		return
	fi

	if $LXORG; then
		return
	fi

	if ! $LONLY_TTY; then
		declare -ga aXorg=(xorg xinit xterm xorg-fonts dbus-x11 elogind dbus-elogind polkit-elogind xdg-user-dirs xrdb xorg-server-xwayland)
		declare -ga aVideo=(mesa-dri linux-firmware-intel xf86-video-amdgpu xf86-video-ati mesa-nouveau-dri libavif libheif gdk-pixbuf libheif-pixbuf-loader)
		declare -ga aPulseaudio=(pulseaudio pavucontrol pasystray gst-plugins-bad1 gst-plugins-good1 gst-plugins-ugly1 gst-plugins-base1 alsa-plugins-pulseaudio alsa-utils)
		declare -ga aPipewire=(pipewire wireplumber alsa-pipewire pulseaudio-utils pavucontrol libspa-bluetooth libjack-pipewire alsa-plugins-pulseaudio alsa-utils)

		if $LCUSTOM; then
			declare -ga aIconsAndThemes=()
			declare -ga aArchiverX=()
			declare -ga aBrowser=()
			declare -ga aFilemanager=()
			declare -ga aBluetooth=(bluez bluez-alsa bluedevil blueman bluez-deprecated gnome-bluetooth1 blueberry)
			declare -ga aFonts=()
			declare -ga aPerfumery=()
			declare -ga aPrinter=()
			declare -ga aTerminal=(rxvt-unicode)
			declare -ga aEditorX=()
			declare -ga aNetworkX=(gvfs gvfs-smb gvfs-mtp gvfs-afc gvfs-cdda gvfs-gphoto2 udisks2)
			declare -ga aUtilityX=(xkill lm_sensors)
			declare -ga aArchiverTty=()
			declare -ga aDownloader=()
			#			declare -ga aUtility=(binutils dfc btop parallel bubblewrap cmatrix pfetch bc bat xtools geoip geoipupdate)
			declare -ga aUtility=(binutils bc)
			aServicesX+=(bluetoothd)
		else
			declare -ga aIconsAndThemes=()
			declare -ga aTerminal=()
			declare -ga aBrowser=()
			declare -ga aFilemanager=()
			declare -ga aUtilityX=()
		fi

		aFonts+=(noto-fonts-emoji)
		aFonts+=(
			noto-fonts-cjk
			dejavu-fonts-ttf
			font-fira-ttf
			font-firacode
			font-hack-ttf
			ttf-jetbrains-mono-nerd
			#nerd-fonts
		)
		aIconsAndThemes+=(Adapta adwaita-icon-theme arc-theme)
		aTerminal+=(xfce4-terminal)
		aBrowser+=(firefox firefox-i18n-$(sh_get_language_without_utf8))
		aFilemanager+=(octoxbps)
		aUtilityX+=(chili-iso2usb voidbr-iso-writer)
		aNetworkX+=(network-manager-applet)
	fi

}

errorbeep() {
	printf '\a' # beep
}

info_msg() {
	#	notify-send "$ccabec" "$@"
	printf "\033[1m$@\n\033[m"
}

sh_setEnvironment() {
	[[ ! -e "$dialogRcFile" ]] && sh_create_dialogrc

	declare url_mirror='https://repo-fastly.voidlinux.org/'
	declare -g app_conf='/tmp/void-install.conf'
	declare -g dir_install='/mnt/voidbr'
	readonly cnickefi='Void_install'
	readonly _TARBALL_ROOTFS=void-x86_64-base-custom-current.tar.xz
	readonly url_tarball="https://raw.githubusercontent.com/voidlinuxbr/void-install/refs/heads/main/${_TARBALL_ROOTFS}"
	readonly url_tarball_md5="https://raw.githubusercontent.com/voidlinuxbr/void-install/refs/heads/main/${_TARBALL_ROOTFS}.md5"
	#
	readonly zero=0
	readonly one=1
	readonly err_not_fatal=0
	readonly err_fatal=1
	#
	readonly BOOTLOG="/tmp/void-install-$(sh_diahora).log"
	readonly LOGGER='/dev/tty8'
	shell='/bin/sh'

	# flag disk info
	: "${DSK_NAME=1}"
	: "${DSK_SIZE=2}"
	: "${DSK_TRAN=3}"
	: "${DSK_MODEL=4}"
	: "${DSK_LABEL=5}"
	: "${DSK_SERIAL=6}"
	: "${DSK_PTTYPE=7}"
	: "${DSK_FSTYPE=8}"
	: "${DSK_PARTTYPENAME=9}"

	# flag languages
	: "${pt_BR=0}"
	: "${PT_BR=0}"
	: "${EN_US=1}"
	: "${DE_DE=2}"
	: "${FR_FR=3}"
	: "${LC_DEFAULT=$(sh_get_Locale)}"

	# flag dialog exit status codes
	: "${D_OK=0}"
	: "${D_DONE=0}"
	: "${D_NO=1}"
	: "${D_CANCEL=1}"
	: "${D_AJUDA=2}"
	: "${D_HELP=2}"
	: "${D_EXTRA=3}"
	: "${D_CONFIG=3}"
	: "${D_ITEM_HELP=4}"
	: "${D_ESC=255}"

	# flag dialog menu
	: "${LDISK=}"
	: "${LFS=}"
	: "${LPARTITION=}"
	: "${LGRUB=}"
	: "${LLOADER=}"
	: "${LKEYMAP=}"
	: "${LWM=}"
	: "${LDM=}"
	: "${LWIFI=}"
	: "${LMIRROR=}"
	: "${LSOURCE=}"
	: "${LEXTRA=}"
	: "${LAUDIO=}"
	: "${LTIMEZONE=}"
	: "${LKERNEL=}"
	: "${LFILE=}"
	: "${LCUSTOM=}"

	# dialog colors
	RESET="\Zn"
	RST='\Zn'
	BOLD="\Zb"
	RED='\Z1'
	GREEN="\Z2"
	YELLOW="\Z3"
	BLUE="\Z4"
  MAGENTA="\Z5"
	CYAN="\Z6"
	WHITE="\Z7"
	BLACK="\Z0"
	REVERSE="\Zr"
	UNDERLINE="\Zu"
	: echo "$err_fatal"

	size=$(stty size)
	read -r MAXROW MAXCOL <<<"$size"
	COLUMNS=$(stty size)
	COLUMNS=${COLUMNS##* }
	if [[ "${COLUMNS}" = "0" ]]; then
		COLUMNS=80
	fi
	COL=$((COLUMNS - 8))
	SET_COL="\\033[${COL}G" # at the $COL char
	CURS_ZERO="\\033[0G"

	: "${ccabec="${BOLD}${WHITE}${REVERSE}${APP} ${YELLOW}v$_VERSION_ ${BLUE}https://github.com/voidlinuxbr/void-install "}"
	: "${baseccabec="${BOLD}${WHITE}${REVERSE}${APP} ${YELLOW}v$_VERSION_ ${BLUE}https://github.com/voidlinuxbr/void-install "}"
	: "${ccabecmin="$APP v${_VERSION_}"}"
	: "${DIALOG=${DIALOG:-dialog}}"
	: "${ARCH:=x86_64}"
	: "${CACHEDIR:="$(pwd -P)"/xbps-cachedir-${ARCH}}"
	: "${XBPS_INSTALL_CMD:=xbps-install}"
	: "${XBPS_INSTALL_UNPACK_ONLY:=xbps-install --unpack-only --yes --ignore-file-conflicts}"
	: "${XBPS_REMOVE_CMD:=xbps-remove}"
	: "${XBPS_QUERY_CMD:=xbps-query}"
	: "${XBPS_RINDEX_CMD:=xbps-rindex}"
	: "${XBPS_UHELPER_CMD:=xbps-uhelper}"
	: "${XBPS_RECONFIGURE_CMD:=xbps-reconfigure}"

}

sh_touchConf() {
	#		_WINDOWMANAGER=(${_WINDOWMANAGER[*]})
	cat >"$app_conf" <<-EOF
		######################################################################
		# void-install.conf
		# Gerado por void-install
		######################################################################
		WIFI_NETWORK=$_WIFI_NETWORK
		WIFI_PASSWORD=$_WIFI_PASSWORD
	EOF
	{
		declare -p _WM
		declare -p LEXTRA
		declare -p aCustomPackages
		declare -p LONLY_TTY
		declare -p LSWAY
		declare -p LMANGO
		declare -p LHYPRLAND
		declare -p LDHCP
		declare -p LCUSTOM
		declare -p LCUSTOM
		declare -p LDISK
		declare -p LEFI
		declare -p LAUDIO
		declare -p LGRUB
		declare -p LLOADER
		declare -p LBIOS
		declare -p LKERNEL
		declare -p LMKPARTED
		declare -p LFSREVISED
		#		declare -p _WIFI_NETWORK
		#		declare -p _WIFI_PASSWORD
		declare -p _DISPLAYMANAGER
		declare -p _WINDOWMANAGER
		declare -p AsUser
		declare -p Amkfs
		declare -p AsDhcp
		declare -p AsDiskPercent
		declare -p AsFs
		declare -p Amntpoint
		declare -p AmntpointFDE
		declare -p AConfDisk
		declare -p AConfAudio
		declare -p AConfKernel
    declare -p AConfBootLoader
		declare -p AConfLocale
		declare -p AConfMirror
		declare -p AConfWifi
		declare -p AConfFde
		declare -p LCUSTOM
		declare -p LAUTOLOGIN
		declare -p HYPRLAND
		#	declare -p AARRAY_DSK_DEVICES
		#	declare -p AARRAY_PART_DEVICES
		#	} | sed 's/declare -/&g/' >>"$app_conf"
		#	} | sed -E 's/^declare (--|-g|-x)* //g' >>"$app_conf"
		#	} | sed 's/declare -/&g/' | sed -E 's/^declare -g-* /declare -g /g' >>"$app_conf"
	} | sed -E 's/declare -/&g/; s/^declare -g-* /declare -g /' >>"$app_conf"
}

sh_checkDisplay() {
	local cmsg1="$(gettext "Antes de continuar, redimensione o terminal")"
	local cmsg2="$(gettext "para que ele meça pelo menos 80 x 24 caracteres.")"
	local cmsg3="$(gettext "Caso contrário, ")"
	local cmsg4="$(gettext "você não poderá usar as ferramentas de partição de Disco.")"

	if [ "$(tput cols)" -lt 80 ] || [ "$(tput lines)" -lt 24 ]; then
		${DIALOG} --backtitle "$ccabec" \
			--title "$(gettext "TERMINAL MUITO PEQUENO")" \
			--msgbox "\
Antes de continuar, redimensione a janela do terminal\n\
ou diminua o tamanho da fonte até obter pelo menos\n\
80 colunas por 24 linhas.\n\
\n\
Caso contrário, o instalador não conseguirá exibir\n\
corretamente todas as informações e opções\n\
necessárias." 0 0
	fi
}

sh_lang_he() {
	grep ^he <<<"$LANG"
	return "$?"
}

sh_get_Locale() {
	# Verifica se o usuário forçou uma variável (LC_ALL, LANG, etc)
	local current=${LC_ALL:-${LC_MESSAGES:-${LANG:-}}}

	# Se não houver variável, usa o fallback do sistema
	if [[ -z "$current" ]]; then
		grep _ <(locale -a) | head -1 | cut -c1-5
	else
		# Retorna apenas o código (ex: es_AR) sem o .UTF-8
		echo "${current%%.*}"
	fi
}

sh_get_code_lang() {
	local LangFilter="${LANG%%.*}"
	local LangFilterLowercase="${LangFilter,,}"
	local LangClean="${LangFilterLowercase%%_*}"
	local LangCountry="${LangFilterLowercase#*_}"
	local LangFilterLowercaseModified="${LangFilterLowercase//_/-}"
	echo "$LangFilterLowercaseModified"
}

sh_get_lang() {
	echo "$LANG"
}

sh_get_language_without_utf8() {
	#	local LangFilter="${LANG%%.*}"
	local LangFilter="${AConfLocale[_LOCALE]%%.*}"
	local LangFilterModified="${LangFilter//_/-}"
	echo "$LangFilterModified"
}

sh_get_code_language() {
	local LangFilter="${LANGUAGE%%.*}"
	local LangFilterLowercase="${LangFilter,,}"
	local LangClean="${LangFilterLowercase%%_*}"
	local LangCountry="${LangFilterLowercase#*_}"
	local LangFilterLowercaseModified="${LangFilterLowercase//_/-}"
	echo "$LangFilterLowercaseModified"
}

sh_get_language() {
	echo "$LANGUAGE"
}

sh_catecho() {
	echo "$(<"$1")"
}

sh_disablePrintk() {
	if [[ -w /proc/sys/kernel/printk ]]; then
		echo 0 >/proc/sys/kernel/printk
	fi
}

sh_loadSavedConfig() {
	[[ -s "$app_conf" ]] || sh_touchConf
	if [ -f "$app_conf" ] && [ -r "$app_conf" ]; then
		# shellcheck source=/dev/null
		source "$app_conf"
	else
		die "${cmsg_falhaAbertura} $app_conf!"
	fi
	sh_setUser
	sh_setAsDhcp
	#debug $(declare -p LCUSTOM)
}

get_default_iface() {
	ip route | awk '/default/ {print $5; exit}'
}

sh_setAsDhcp() {
	AsDhcp[IFACE]=${AsDhcp[IFACE]:-$(get_default_iface)}
	AsDhcp[IP]=${AsDhcp[IP]:-192.168.1.100}
	AsDhcp[CIDR]=${AsDhcp[CIDR]:-24}
	AsDhcp[GATEWAY]=${AsDhcp[GATEWAY]:-192.168.1.1}
	AsDhcp[DNS1]=${AsDhcp[DNS1]:-1.1.1.1}
	AsDhcp[DNS2]=${AsDhcp[DNS2]:-8.8.8.8}
}

sh_setUser() {
	AsUser[cuser]=${AsUser[cuser]:-$(sh_getusernameloggeduserbyid)}
	AsUser[cfullname]=${AsUser[cfullname]:-$(sh_getfullusernameloggeduserbyGetent)}
	AsUser[cpass]=${AsUser[cpass]:-voidlinux}
	AsUser[cpassroot]=${AsUser[cpassroot]:-voidlinux}
	AsUser[chostname]=${AsUser[chostname]:-voidbr}
	AsUser[cgroups]=${AsUser[cgroups]:-"wheel,audio,video,floppy,cdrom,optical,kvm,xbuilder"}
}

# Testa se o terminal suporta caracteres gráficos estendidos
sh_setAsciiLines() {
	#Isso força o dialog a usar caracteres ASCII básicos para as bordas.
	#if [[ "$LANG" =~ 'UTF-8' ]]; then
	if [[ "$(printf '\u250C')" =~ "┌" ]]; then
		export NCURSES_NO_UTF8_ACS=1 # Terminal suporta ACS
	else
		export NCURSES_NO_UTF8_ACS=0 # Terminal NÃO suporta ACS
	fi
}

sh_checkRoot() {
	if [[ "$(id -u)" != "0" ]]; then
		die "${red} ${cmsg_operNotRoot}"
	fi
}

sh_checkRepo() {
	local url_repo="$1"
	local response

	sh_info_msg "${cmsg_ChecandoRota} ${url_repo}"
	response=$(curl -o /dev/null -s -w "%{http_code}\n" -L "$url_repo")
	retval=$?
	if [[ "$response" -eq 200 ]]; then
		evaluate_retval 0 "$err_not_fatal" "${green}response: $response ($url_repo)${rst}"
		return 0
	fi
	evaluate_retval 1 "$err_not_fatal" "response: $response: ${cmsg_SemRota} ($url_repo) - ${cmsg_CheckNet}"
	return 1
}

sh_checkNet() {
	xurl="$1"
	local retval

	# have internet?
	sh_info_msg "${cmsg_ChecandoRota} ${xurl}"
	response=$(curl --compressed -s -w "%{http_code}\n" -o /dev/null -k --url "${xurl}")
	retval=$?
	if [[ "$response" -eq 000 || "$response" -eq 404 ]]; then
		evaluate_retval "$err_fatal" "$err_fatal" "reponse: $response - ${cmsg_SemRota} ($xurl) - ${cmsg_CheckNet}"
		return 1
	fi
	evaluate_retval 0 "$err_not_fatal" "response: $response ($xurl)"
	return 0
}

sh_downloadTarball() {
	sh_checkNet "$url_tarball" || return 1
	sh_info_msg "${cmsg_IniciandoDownload} $url_tarball"
	curl -L -C - --insecure --silent --remote-name "$url_tarball" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	if [[ "${PIPESTATUS[0]}" -eq 1 ]]; then
		evaluate_retval 1 "$err_fatal" "${cmsg_SemRota} ($url_mirror) - ${cmsg_CheckNet}"
	fi
	evaluate_retval 0
	return 0
}

sh_checkTarball() {
	sh_info_msg "${cmsg_ChecandoTarball} rootfs $_TARBALL_ROOTFS"

	if ! [[ -e "$_TARBALL_ROOTFS" ]]; then
		evaluate_retval 1 "$err_not_fatal"
		rm -f "$_TARBALL_ROOTFS"
		sh_downloadTarball
	else
		evaluate_retval 0
		return 0
	fi
	return "$?"
}

sh_checkIntegrityTarball() {
	sh_checkTarball || return 1

	sh_info_msg "${cmsg_VerificandoIntegridadeTarball} rootfs $_TARBALL_ROOTFS"
	tar -tf "$_TARBALL_ROOTFS" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	if ! [[ "${PIPESTATUS[0]}" -eq 0 ]]; then
		evaluate_retval 1 "$err_not_fatal"
		rm -f "$_TARBALL_ROOTFS"
		sh_downloadTarball
	else
		evaluate_retval 0
		return 0
	fi
	return "${PIPESTATUS[0]}"
}

#dom 03 mar 2024 17:00:23 -04
sh_checkcommand() {
	local cmd="$1"
	command -v "$1" >/dev/null 2>&-
	return $?
}

sh_setVarColors() {
	#tput setaf 127 | cat -v  #capturar saida
	# Se o reset já estiver definido, não precisamos processar novamente (Cache de execução)
	[[ -n "$reset" ]] && return

	# Verifica se o tput existe
	if ! command -v tput >/dev/null 2>&1; then
		sh_unsetVarColors
		return
	fi

	# 1. Agrupamos todos os pedidos em uma única chamada de sistema.
	# A ordem aqui deve ser rigorosamente a mesma do bloco de leitura abaixo.
	local cache
	cache=$(tput -S <<<$'sgr0\nbold\nsmul\nrmul\nrev\nsetaf 0\nsetaf 196\nsetaf 2\nsetaf 3\nsetaf 4\nsetaf 5\nsetaf 6\nsetaf 7\nsetaf 8\nsetaf 202\nsetaf 125\nsetaf 61\nsetaf 9\nsetaf 10\nsetaf 11\nsetaf 12\nsetaf 13\nsetaf 14\nsetaf 15')

	# 2. Leitura em lote para as variáveis (Performance instantânea)
	{
		read -r reset
		read -r bold
		read -r underline
		read -r nounderline
		read -r reverse
		read -r c0
		read -r c196
		read -r c2
		read -r c3
		read -r c4
		read -r c5
		read -r c6
		read -r c7
		read -r c8
		read -r c202
		read -r c125
		read -r c61
		read -r c9
		read -r c10
		read -r c11
		read -r c12
		read -r c13
		read -r c14
		read -r c15
	} <<<"$cache"

	# 3. Montagem das variáveis finais (mantendo sua lógica de negrito e nomes)
	black="${bold}${c0}"
	red="${bold}${c196}"
	green="${bold}${c2}"
	yellow="${bold}${c3}"
	blue="$c4"
	pink="$c5"
	magenta="$c5"
	cyan="$c6"
	white="$c7"
	gray="$c8"
	orange="$c202"
	purple="$c125"
	violet="$c61"
	light_red="$c9"
	light_green="$c10"
	light_yellow="$c11"
	light_blue="$c12"
	light_magenta="$c13"
	light_cyan="$c14"
	bright_white="$c15"
}

sh_unsetVarColors() {
	unset reset green red bold blue cyan
	unset orange pink white yellow violet purple
	sh_setLogPrefix
}

sh_setLogPrefix() {
	COL_NC='\e[0m' # No Color
	COL_LIGHT_GREEN='\e[1;32m'
	COL_LIGHT_RED='\e[1;31m'
	TICK="${white}[${COL_LIGHT_GREEN}✓${COL_NC}${white}]"
	CROSS="${white}[${COL_LIGHT_RED}✗${COL_NC}$white]"
	INFO="[i]"
	# shellcheck disable=SC2034
	DONE="${COL_LIGHT_GREEN} done!${COL_NC}"
	OVER="\\r\\033[K"
	NORMAL="${reset}"
	SUCCESS="${green}"
	WARNING="${yellow}"
	FAILURE="${red}"
	INFO="${cyan}"
	BRACKET="${blue}"
	BMPREFIX=""
	DOTPREFIX="  ${blue}::${reset} "
	#  SUCCESS_PREFIX="${SUCCESS}  ↑  ${NORMAL}"
	SUCCESS_PREFIX=" $TICK "
	SUCCESS_SUFFIX="${BRACKET}[${SUCCESS}  OK  ${BRACKET}]${NORMAL}"
	#  FAILURE_PREFIX="${FAILURE}  ↓  ${NORMAL}"
	FAILURE_PREFIX=" $CROSS "
	FAILURE_SUFFIX="${BRACKET}[${FAILURE} FAIL ${BRACKET}]${NORMAL}"
	WARNING_PREFIX="${WARNING}  W  ${NORMAL}"
	WARNING_SUFFIX="${BRACKET}[${WARNING} WARN ${BRACKET}]${NORMAL}"
	SKIP_PREFIX="${INFO}  S  ${NORMAL}"
	SKIP_SUFFIX="${BRACKET}[${INFO} SKIP ${BRACKET}]${NORMAL}"
	WAIT_PREFIX="${WARNING}  R  ${NORMAL}"
	WAIT_SUFFIX="${BRACKET}[${WARNING} WAIT ${BRACKET}]${NORMAL}"
}

replicate() {
	local Var
	printf -v Var %"$2s" " "
	echo "${Var// /$1}"
}

padr() {
	text=$1
	COLS=$2
	char=$3
	if test $# -eq 1; then
		COLS=$(tput cols)
		char='='
	fi
	printf "%*s\n" "$COLS" "$text" | sed "s/ /$char/g"
}

sh_info_msg() {
	local _msg="$1"
	last_msg="$_msg"
	msg "INFO" "$last_msg" "$(log_info_msg "$last_msg")"
}

msg() {
	((++ncounter))
	cinfo="$1"
	cfmt="$(fmt)"
	ufmt=$(unfmt "$cfmt")
	last_msg="$2"
	logmessage="$ufmt $last_msg"
	logmessage=${logmessage/INFO /}
	clean_logmessage="$(strip_ansi "$logmessage")"
	printf "%s\n" "$(timespec) [ $cinfo ]$ufmt ${clean_logmessage}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER

	if ((grafico)); then
		logmessage="$(strip_ansi "$last_msg")"
		${DIALOG} \
			--no-collapse \
			--colors \
			--title "$cinfo" \
			--backtitle "$ccabec" \
			--infobox "\n[${BOLD}${YELLOW}${ufmt}] ${RESET}${BOLD}$logmessage" \
			6 100
	else
		log_info_msg "$(fmt) ${logmessage}"
	fi
}

fmt() {
	printf "${bold}${yellow}%03d/%03d${reset}" "$ncounter" "$njobs"
	return $?
}

mensagem() {
	cinfo="$1"
	last_msg="$2"
	${DIALOG} \
		--no-collapse \
		--colors \
		--title "$cinfo" \
		--backtitle "$ccabec" \
		--infobox "$last_msg" \
		8 100
}

unfmt() {
	local last_msg="$*"
	logmessage="${last_msg/${bold}${yellow}/}"
	logmessage="${logmessage/${reset}/}"
	echo "$logmessage"
}

log_info_msg() {
	last_msg="$*"

	if ! ((quiet)); then
		echo -n -e "${BMPREFIX}${*}"
	fi
	return 0
}

log_info_msg_level() {
	last_msg="$*"

	if ! ((quiet)); then
		echo -n -e "   ${BMPREFIX}${*}"
	fi
	return 0
}

log_error() {
	if ! ((quiet)); then
		echo -e "   ${FAILURE_PREFIX}${*}"
	fi
	return 0
}

log_msg_tab() {
	if ! ((quiet)); then
		echo -e "   ${DOTPREFIX}${*}"
	fi
	return 0
}

log_msg() {
	if ! ((quiet)); then
		echo -e "${DOTPREFIX}${*}"
	fi
	return 0
}

evaluate_retval() {
	local error_value=$? # captura retorno anterior
	local error_fatal=${2:-$one}
	local cmsgdie="$3"
	local level="$4"

	if [[ $# -gt 0 ]]; then
		error_value="$1"
	fi

	if [[ "${error_value}" = 0 ]]; then
		if [[ -n "${level}" ]]; then
			log_success_msg_level ''
		else
			log_success_msg ''
		fi
	else
		if [[ -n "${level}" ]]; then
			log_failure_msg_level ''
		else
			log_failure_msg ''
		fi
	fi

	if ((error_value)); then
		if ((error_fatal)); then
			[[ -z "$cmsgdie" ]] && die "${cmsg_InstalacaoAbortada}..." || die "$cmsgdie"
		else
			[[ -n "$cmsgdie" ]] && log_failure_msg_level "${cmsgdie}"
			log_error "${cmsg_Error_not_fatal} $BOOTLOG"
		fi
	fi
	[[ -n "$cmsgdie" ]] && log_success_msg_level "${cmsgdie}"
	return "${error_value}"
}

log_failure_msg_level() {
	if ! ((quiet)) && ! ((grafico)); then
		echo -n -e "     ${BMPREFIX}${@}"
		echo -e "   ${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}"
	fi
	logmessage=${last_msg/$bold$red$green$yellow/}
	printf "%s\n" "$(timespec) [ FAIL ]${logmessage}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	replicate "#" "100" | tee -i -a "$BOOTLOG" >$LOGGER
	return 0
}

log_success_msg_level() {
	if ! ((quiet)) && ! ((grafico)); then
		echo -n -e "     ${BMPREFIX}${green}=>${reset} ${*}"
		echo -e "   ${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}"
	fi

	logmessage=$(unfmt "$last_msg")
	printf "%s\n" "$(timespec) [  OK  ]${logmessage}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	replicate "#" "100" | tee -i -a "$BOOTLOG" >$LOGGER
	return 0
}

log_failure_msg() {
	if ! ((quiet)) && ! ((grafico)); then
		echo -n -e "${BMPREFIX}${@}"
		echo -e "${CURS_ZERO}${FAILURE_PREFIX}${SET_COL}${FAILURE_SUFFIX}"
	fi
	logmessage=${last_msg/$bold$red$green$yellow/}
	printf "%s\n" "$(timespec) [ FAIL ]${logmessage}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	replicate "#" "100" | tee -i -a "$BOOTLOG" >$LOGGER
	return 0
}

log_success_msg() {
	if ! ((quiet)) && ! ((grafico)); then
		echo -n -e "${BMPREFIX}${@}"
		echo -e "${CURS_ZERO}${SUCCESS_PREFIX}${SET_COL}${SUCCESS_SUFFIX}"
	fi
	logmessage=$(unfmt "$last_msg")
	printf "%s\n" "$(timespec) [  OK  ]${logmessage}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	replicate "#" "100" | tee -i -a "$BOOTLOG" >$LOGGER
	return 0
}

timespec() {
	STAMP="$(date +"%b %d %T %:z") $(hostname)"
	echo "$STAMP"
	return 0
}

function debug() {
	whiptail \
		--fb \
		--clear \
		--backtitle "[debug]$0" \
		--title "[debug]$0" \
		--yesno "${*}\n" \
		0 40
	result=$?
	if ((result)); then
		exit
	fi
	return $result
}

info() {
	msg "${fmt} $@"
	evaluate_retval 0

	${DIALOG} \
		--colors \
		--title "$1" \
		--backtitle "$ccabec" \
		--ok-label "${cmsg_ok}" \
		--msgbox "$2\n$3\n$4\n$5\n$6\n$7\n$8\n$9\n${10}" \
		0 0
}

infoextended() {
	xtitle="$1"
	shift
	msg "${fmt} $@"
	evaluate_retval 0

	${DIALOG} \
		--colors \
		--title "${xtitle}" \
		--backtitle "$ccabec" \
		--ok-label "${cmsg_ok}" \
		--msgbox "$*" \
		0 0
}

infobox() {
	${DIALOG} \
		--colors \
		--no-shadow \
		--no-mouse \
		--backtitle "${BOLD}${WHITE}${ccabec}${RESET}" \
		--title "${TITLE}" \
		--aspect 20 \
		--infobox "$@"
}

alerta() {
	msg "${fmt} $@"
	evaluate_retval 0

	${DIALOG} \
		--colors \
		--clear \
		--no-collapse \
		--no-cr-wrap \
		--title "$1" \
		--backtitle "$ccabec" \
		--ok-label "${cmsg_ok}" \
		--msgbox "\n$2\n$3\n$4\n$5\n$6" \
		10 81
}

alerta_end() {
	msg "${fmt} $@"
	evaluate_retval 0

	${DIALOG} \
		--colors \
		--clear \
		--no-collapse \
		--no-cr-wrap \
		--title "$1" \
		--backtitle "$ccabec" \
		--extra-button --extra-label "$(gettext 'Reboot')" \
		--no-label "$(gettext 'Desligar')" \
		--yesno "\n$2\n$3\n$4\n$5\n$6" \
		10 81
}

alerta_die() {
	local xtitle="$1"
	local cmsg="$2"
	local -n linhas="$3"
	local texto=""
	local linha

	for linha in "${linhas[@]}"; do
		texto+="$linha"$'\n'
	done

	texto+=$'\n'"${RED}$cmsg"
	texto="$(strip_ansi "${texto}")"

	${DIALOG} \
		--colors \
		--title "$xtitle" \
		--no-collapse \
		--no-cr-wrap \
		--backtitle "$ccabec" \
		--ok-label "${cmsg_ok}" \
		--msgbox "$texto" \
		20 120
}

conf() {
	xtitle="$1"
	shift
	${DIALOG} \
		--colors \
		--title "$xtitle" \
		--backtitle "$ccabec" \
		--no-collapse \
		--no-cr-wrap \
		--clear \
		--yes-label "${cmsg_yeslabel}" \
		--no-label "${cmsg_nolabel}" \
		--yesno "$*" \
		0 0
	nchoice=$?
	return "$nchoice"
}

confRevisar() {
	xtitle="$1"
	shift
	${DIALOG} \
		--colors \
		--title "$xtitle" \
		--backtitle "$ccabec" \
		--no-collapse \
		--no-cr-wrap \
		--clear \
		--yes-label "${cmsg_ButtonProsseguir}" \
		--no-label "${cmsg_ButtonRevisar}" \
		--yesno "$*" \
		0 0
	nchoice=$?
	return "$nchoice"
}

infoconf() {
	infotitle=$1
	inforesult=$2
	conftitle=$3
	shift 3
	${DIALOG} --title "$infotitle" \
		--begin 03 10 --infobox "$inforesult" 14 75 \
		--and-widget \
		--begin 17 10 \
		--colors \
		--no-collapse \
		--no-cr-wrap \
		--title "$conftitle" \
		--backtitle "$ccabec" \
		--yes-label "${cmsg_yeslabel}" \
		--no-label "${cmsg_nolabel}" \
		--yesno "$*" \
		10 75
	nchoice=$?
	return "$nchoice"
}

sh_cmd_job_infobox() {
	local cmsg="$1"
	local cjob="$2"
	local erro_fatal="$3"
	local lretval=0

	# Cria um log temporário exclusivo
	local tmp_log=$(mktemp)

	# Executa o comando localmente e captura o código de saída
	eval "$cjob" >"$tmp_log" 2>&1 &
	local pid_job=$!

	# Exibe o log em tempo real usando dialog --infobox
	if ((grafico)); then
		while kill -0 "$pid_job" 2>/dev/null; do
			${DIALOG} \
				--no-collapse \
				--colors \
				--title "$cmsg - (log realtime)" \
				--backtitle "$ctitle" \
				--infobox "$(tail -n 13 "$tmp_log")" \
				15 100
			sleep 0.3
		done
	fi

	# Aguarda o término do comando e captura o código de saída
	wait "$pid_job"
	lretval=$?

	# Remove o log temporário
	rm -f "$tmp_log"

	# Avalia o resultado da execução
	[[ -z "$erro_fatal" ]] && return "$lretval" || return "$erro_fatal"
}

sh_msg_job() {
	local cmsg="$1"
	local cjob="$2"
	local erro_fatal="$3"
	local lretval=0

	last_msg="$cmsg"
	msg "INFO" "$last_msg" "$(log_info_msg "$last_msg")"
	lretval=0
	evaluate_retval "$lretval" "$erro_fatal"
	return "$lretval"
}

display_result() {
	${DIALOG} \
		--colors \
		--title "$2" \
		--backtitle "$ccabec" \
		--no-collapse \
		--no-cr-wrap \
		--no-nl-expand \
		--ok-label "${cmsg_ok}" \
		--msgbox "$1" \
		0 0
}

#			15 100

notconf() {
	xtitle="$1"
	shift
	${DIALOG} \
		--colors \
		--title "$xtitle" \
		--backtitle "$ccabec" \
		--yes-label "${cmsg_nolabel}" \
		--no-label "${cmsg_yeslabel}" \
		--yesno "$*" \
		10 100
	return $?
}

sh_testDisk() {
	local result=0

	fdisk -l "${AConfDisk[_DEVICE]}" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	result="${PIPESTATUS[0]}"
	if ! ((quiet)); then
		evaluate_retval "$result"
	fi
	return "$result"
}

sh_get_part_size() {
	local tam="$1"
	local percentual="$2"

	# part_size_MB=$(awk "BEGIN { printf \"%.0f\n\", (${tam%G} * 1024 * ${percentual/,/.} / 100) }")
	part_size_GB=$(awk "BEGIN { printf \"%.2f\n\", (${tam%G} * $percentual / 100) }")

	echo "${part_size_GB}"
}

is_valid_fs() {
	local cFs="$1"
	local cPath="$2"
	local xtitle

	case "$cPath" in
	"/")
		case "$cFs" in
		xfs | f2fs | ext2 | ext3 | ext4 | btrfs | jfs | nilfs2)
			return 0
			;;
		*)
			xtitle="${RED}FILESYSTEM ERROR${RST}\
\n$(gettext 'Filesystem inválido para') ${CYAN}'${cPath}' ${RST}=> ${cFs} \
\n${YELLOW}$(gettext 'Válidos:') ${CYAN}xfs|f2fs|ext2|ext3|ext4|btrfs|jfs"

			if sh_choose_fstype "${AsFs[root]}" "$xtitle"; then
				AsFs[root]="${AConfDisk[_FILESYSTEM]}"
				return 1
			fi
			return 1
			;;
		esac
		;;

	"/home")
		case "$cFs" in
		xfs | f2fs | ext2 | ext3 | ext4 | vfat | ntfs | btrfs | jfs | nilfs2)
			return 0
			;;
		*)
			xtitle="${RED}FILESYSTEM ERROR${RST} \
\n$(gettext 'Filesystem inválido para') ${CYAN}'${cPath}' ${RST}=> ${cFs} \
\n${YELLOW}$(gettext 'Válidos:') ${CYAN}xfs|f2fs|ext2|ext3|ext4|vfat|ntfs|btrfs|jfs"

			if sh_choose_fstype "${AsFs[home]}" "$xtitle"; then
				AsFs[home]="${AConfDisk[_FILESYSTEM]}"
				return 1
			fi
			return 1
			;;
		esac
		;;

	"/boot")
		case "$cFs" in
		xfs | f2fs | ext2 | ext3 | ext4 | vfat | btrfs | jfs)
			return 0
			;;
		*)
			xtitle="${RED}FILESYSTEM ERROR${RST} \
\n$(gettext 'Filesystem inválido para') ${CYAN}'${cPath}' ${RST}=> ${cFs} \
\n${YELLOW}$(gettext 'Válidos:') ${CYAN}xfs|f2fs|ext2|ext3|ext4|vfat|btrfs|jfs"

			if sh_choose_fstype "${AsFs[boot]}" "$xtitle"; then
				AsFs[boot]="${AConfDisk[_FILESYSTEM]}"
				return 1
			fi
			return 1
			;;
		esac
		;;
	esac

	return 1
}

sh_getPartitionsPercent() {
	local -a aPercent=()
	local percent_text
	local disk_size="${SIZE_ORIGEM}"
	AsDiskPercent[_DISKTABLE]="${AConfDisk[_DISKTABLE]}"
	xtitle="${AConfDisk[_DEVICE]} - $(gettext "Configuração de Partições")"

	AsDiskSize[root]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[root]})G"
	AsDiskSize[boot]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[boot]})G"
	AsDiskSize[home]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[home]})G"
	AsDiskSize[swap]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[swap]})G"

	total=$((AsDiskPercent[root] + AsDiskPercent[boot] + AsDiskPercent[home] + AsDiskPercent[swap]))

	# loop principal
	while :; do
		percent_text=$(
			"${DIALOG}" \
				--stdout \
				--colors \
				--backtitle "$ccabec" \
				--title "${xtitle}" \
				--ok-label "${cmsg_Aceitar}" \
				--cancel-label "${cmsg_ButtonCancelar}" \
				--extra-button \
				--extra-label "Recalcular" \
				--help-button \
				--help-label "Ajuda" \
				--mixedform "\
\n➡   ${YELLOW}$(gettext "Configure os percentuais desejados.")${RST} \
\n➡   ${CYAN}$(gettext "Use o botao ajuda para informações.")${RST}" \
				15 100 0 \
				\
				"Mode" 1 01 "${AsDiskPercent[_DISKTABLE]}" 1 24 15 15 2 \
				"root (/) (%)" 2 01 "${AsDiskPercent[root]}" 2 24 05 05 0 \
				"" 2 14 "${AsDiskSize[root]}" 2 14 10 10 2 \
				"FS" 2 32 "${AsFs[root]:-ext4}" 2 37 10 10 0 \
				"/boot    (%)" 3 01 "${AsDiskPercent[boot]}" 3 24 05 05 0 \
				"" 3 14 "${AsDiskSize[boot]}" 3 14 10 10 2 \
				"FS" 3 32 "${AsFs[boot]:-ext4}" 3 37 10 10 0 \
				"/home    (%)" 4 01 "${AsDiskPercent[home]}" 4 24 05 05 0 \
				"" 4 14 "${AsDiskSize[home]}" 4 14 10 10 2 \
				"FS" 4 32 "${AsFs[home]:-ext4}" 4 37 10 10 0 \
				"swap     (%)" 5 01 "${AsDiskPercent[swap]}" 5 24 05 10 0 \
				"" 5 14 "${AsDiskSize[swap]}" 5 14 10 10 2 \
				"FS" 5 32 "${AsFs[swap]:-swap}" 5 37 10 10 2 \
				"TOTAL    (%)" 6 01 "${total}" 6 24 05 10 2
		)

		exit_status=$?

		# cancelar / esc
		case "$exit_status" in
		"$D_ESC" | "$D_CANCEL")
			return 1
			;;
		"$D_EXTRA")
			sh_recalculate
			continue
			;;
		"$D_AJUDA")
			infoextended "${YELLOW}$(gettext "Configure os percentuais desejados.")${RST}" \
				"⚠   ROOT + BOOT + SWAP + HOME $(gettext "não pode ultrapassar") ${RED}100% ${RST}
\n➡   $(gettext "Você também pode utilizar menos de 100% do disco")" \
				"\n\n${GREEN}$(gettext "Exemplos válidos:")${RST} \
\nroot(/)=${RED}100 ${RST} /boot=${RED}0 ${RST}/home=${RED}0  ${RST}swap=${RED}0 ${RST} \
\nroot(/)=${RED}35  ${RST} /boot=${RED}5 ${RST}/home=${RED}55 ${RST}swap=${RED}5 ${RST} \
\nroot(/)=${RED}50  ${RST} /boot=${RED}0 ${RST}/home=${RED}0  ${RST}swap=${RED}0 ${RST}" \
				"\n\n➡   $(gettext 'Informe') BOOT $(gettext 'como') ${YELLOW}0${RST} $(gettext 'para não criar partição') BOOT $(gettext 'separada.') \
\n➡   $(gettext 'Informe') HOME $(gettext 'como') ${YELLOW}0${RST} $(gettext 'para não criar partição') HOME $(gettext 'separada.') \
\n➡   $(gettext 'Informe') SWAP $(gettext 'como') ${YELLOW}0${RST} $(gettext 'para não criar partição') SWAP"
			continue
			;;
		esac

		sh_recalculate() {
			# captura retorno
			mapfile -t aPercent <<<"$percent_text"
			AsDiskPercent[root]="${aPercent[1]}"
			AsDiskPercent[boot]="${aPercent[4]}"
			AsDiskPercent[home]="${aPercent[7]}"
			AsDiskPercent[swap]="${aPercent[10]}"

			AsFs[root]="${aPercent[3]}"
			AsFs[boot]="${aPercent[6]}"
			AsFs[home]="${aPercent[9]}"

			AsDiskSize[root]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[root]})G"
			AsDiskSize[boot]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[boot]})G"
			AsDiskSize[home]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[home]})G"
			AsDiskSize[swap]="$(sh_get_part_size ${SIZE_ORIGEM} ${AsDiskPercent[swap]})G"

			total=$((AsDiskPercent[root] + AsDiskPercent[boot] + AsDiskPercent[home] + AsDiskPercent[swap]))
		}

		sh_recalculate

		if [ "${AsDiskPercent[root]}" -gt 0 ]; then
			if ! is_valid_fs "${AsFs[root]}" "/"; then
				continue
			fi
		fi

		if [ "${AsDiskPercent[boot]}" -gt 0 ]; then
			if ! is_valid_fs "${AsFs[boot]}" "/boot"; then
				continue
			fi
		fi

		if [ "${AsDiskPercent[home]}" -gt 0 ]; then
			if ! is_valid_fs "${AsFs[home]}" "/home"; then
				continue
			fi
		fi

		# valida ROOT
		case "${AsDiskPercent[root]}" in
		'' | *[!0-9]*)
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "Valor inválido para ROOT.")" \
				"\n$(gettext "ROOT deve estar entre 1 e 100.")"
			continue
			;;
		esac

		# valida BOOT
		case "${AsDiskPercent[boot]}" in
		'' | *[!0-9]*)
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "Valor inválido para BOOT.")" \
				"\n$(gettext "BOOT deve estar entre 0 e 99.")"
			continue
			;;
		esac

		# valida HOME
		case "${AsDiskPercent[home]}" in
		'' | *[!0-9]*)
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "Valor inválido para HOME.")" \
				"\n$(gettext "HOME deve estar entre 0 e 99.")"
			continue
			;;
		esac

		# valida SWAP
		case "${AsDiskPercent[swap]}" in
		'' | *[!0-9]*)
			info "${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "Valor inválido para SWAP.")" \
				"\n$(gettext "SWAP deve estar entre 0 e 99.")"
			continue
			;;
		esac

		# faixa ROOT
		if [ "${AsDiskPercent[root]}" -lt 1 ] || [ "${AsDiskPercent[root]}" -gt 100 ]; then
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "ROOT deve estar entre 1 e 100.")"
			continue
		fi

		# faixa BOOT
		if [ "${AsDiskPercent[boot]}" -lt 0 ] || [ "${AsDiskPercent[boot]}" -gt 99 ]; then
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "BOOT deve estar entre 0 e 99.")"
			continue
		fi

		# faixa HOME
		if [ "${AsDiskPercent[home]}" -lt 0 ] || [ "${AsDiskPercent[home]}" -gt 99 ]; then
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "HOME deve estar entre 0 e 99.")"
			continue
		fi

		# faixa SWAP
		if [ "${AsDiskPercent[swap]}" -lt 0 ] || [ "${AsDiskPercent[swap]}" -gt 99 ]; then
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\n$(gettext "SWAP deve estar entre 0 e 99.")"
			continue
		fi

		# soma
		total=$((AsDiskPercent[root] + AsDiskPercent[boot] + AsDiskPercent[home] + AsDiskPercent[swap]))

		if [ "$total" -gt 100 ]; then
			info \
				"${AConfDisk[_DEVICE]} - ${RED}${cmsg_ERRO}${RST}" \
				"\nROOT + BOOT + HOME + SWAP $(gettext "não pode ultrapassar") ${RED}100% ${RST}" \
				"$(gettext "Valor atual:") ${RED}${total}%${RST}"
			continue
		fi

		# tudo OK
		#    if conf "${xtitle}" \
		#             "\n${BOLD}${RED}$(gettext 'Deseja reviser o particionamento ?')" \
		#             "\n$(gettext 'Não para aceitar!')"; then
		#      sh_recalculate
		#    else
		#      break
		#    fi

		if ! confRevisar "${YELLOW}${cwarning}" \
			"DEVICE  : ${RED}${AConfDisk[_DEVICE]}${RESET}\n" \
			"MODEL   : ${RED}${MODEL_ORIGEM}${RST}\n\n" \
			"/       : ${CYAN}${AsDiskSize[root]} ${YELLOW}${AsFs[root]} ${RST}\n" \
			"/boot   : $([ "${AsDiskPercent[boot]}" -eq 0 ] && echo "${YELLOW}sem /boot separado${RST}" || echo "${CYAN}${AsDiskSize[boot]} ${YELLOW}${AsFs[boot]}${RST}")\n" \
			"swap    : $([ "${AsDiskPercent[swap]}" -eq 0 ] && echo "${YELLOW}sem partição swap${RST}" || echo "${CYAN}${AsDiskSize[swap]} ${YELLOW}${AsFs[swap]}${RST}")\n" \
			"/home   : $([ "${AsDiskPercent[home]}" -eq 0 ] && echo "${YELLOW}sem /home separado${RST}" || echo "${CYAN}${AsDiskSize[home]} ${YELLOW}${AsFs[home]}${RST}")\n" \
			"\n${RED}${cmsg_todos_os_dados_serao_perdidos}${RESET}" \
			"\n\n${BOLD}${CYAN}$(gettext 'Deseja prosseguir ou revisar com o particionamento ?')"; then
			sh_recalculate
		else
			break
		fi
	done

  [[ ${AsFs[boot]} == vfat ]] && AsFs[boot]="fat32"
	withhome=true
	withboot=true
	withswap=true
	[[ "${AsDiskPercent[boot]}" -eq 0 ]] && withboot=false
	[[ "${AsDiskPercent[home]}" -eq 0 ]] && withhome=false
	[[ "${AsDiskPercent[swap]}" -eq 0 ]] && withswap=false
	#info "${cmsg_Disco}" "BOOT separado: ${withboot}" "HOME separado: ${withhome}" "SWAP separado: ${withswap}"
	return 0

}

sh_checkSpaceToSwap() {
	if [[ $(sh_toBytes "$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" 2)") -lt $(sh_toBytes "4G") ]]; then
		if ! infoconf "${cmsg_Disco}" "$(fdisk -l "${AConfDisk[_DEVICE]}")" \
			"${YELLOW}${AConfDisk[_DEVICE]} - ${cmsg_CriandoPartSwap}" \
			"\n${cmsg_TamanhoInsuficiente}\n${cmsg_DesejaProsseguir}"; then
			return 1
		fi
		withswap=false
	else
		if ! infoconf "${AConfDisk[_DEVICE]} - ${cmsg_Disco}" "$(fdisk -l "${AConfDisk[_DEVICE]}")" \
			"${AConfDisk[_DEVICE]} - ${YELLOW}${cmsg_CriandoPartSwap}" \
			"\n${cmsg_DesejaCriarParticaoSwap}"; then
			withswap=false
			return 1
		fi
	fi
	return 0
}

sh_mkparted() {
	local nchoice=false
	local withboot=true
	local withhome=true
	local withswap=true
	local label_type='gpt'
	local ext=$(sh_getNvme)
	local cini=''
	local cnextpart=''
	local CSCRIPT=''

	sh_info_msg "${cmsg_TestandoDisco} ${AConfDisk[_DEVICE]}"
	if ! sh_testDisk; then
		die "${cmsg_ErroLeituraDisco}: ${AConfDisk[_DEVICE]}."
	fi

	if ! ((grafico)); then
		if ! ((quiet)); then
			replicate "=" "$COLUMNS"
			if ! fdisk -l "${AConfDisk[_DEVICE]}"; then
				die "${cmsg_ErroLeituraDisco}: ${AConfDisk[_DEVICE]}."
			fi
			replicate "=" "$COLUMNS"
			if ! $LMKPARTED; then
				echo "${yellow}${cwarning} ${red}${cmsg_todos_os_dados_serao_perdidos}${reset}"
			fi
		fi
	fi

	#	if $LMKPARTED; then
	#		return 0
	#	fi

	if ! ((grafico)); then
		if readconf "${red}${cmsg_ContinuarParticionamento} ${yellow}${AConfDisk[_DEVICE]} ${reset}?"; then
			nchoice=true
		fi
	else
		#		if [[ $(sh_toBytes "$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" 2)") -lt $(sh_toBytes "4G") ]]; then
		#			if ! infoconf "${cmsg_Disco}" "$(fdisk -l "${AConfDisk[_DEVICE]}")" \
		#				"${YELLOW}${AConfDisk[_DEVICE]} - ${cmsg_CriandoPartSwap}" \
		#				"\n${cmsg_TamanhoInsuficiente}\n${cmsg_DesejaProsseguir}"; then
		#				return 1
		#			fi
		#			withswap=false
		#		else
		#			if ! infoconf "${AConfDisk[_DEVICE]} - ${cmsg_Disco}" "$(fdisk -l "${AConfDisk[_DEVICE]}")" \
		#				"${AConfDisk[_DEVICE]} - ${YELLOW}${cmsg_CriandoPartSwap}" \
		#				"\n${cmsg_DesejaCriarParticaoSwap}"; then
		#				withswap=false
		#			fi
		#		fi

		#   sh_checkSpaceToSwap
		if ! sh_getPartitionsPercent; then
			info "${AConfDisk[_DEVICE]} - ${cmsg_Disco^^} - AUTOMATIC" \
				"\n$(gettext '✗ Particionamento e formatação automatica cancelado pelo usuário')"
			return 1
		fi

		#		if ! conf "${YELLOW}${cwarning}" \
		#			"DEVICE  : ${RED}${AConfDisk[_DEVICE]}${RESET}\n" \
		#			"MODEL  : ${RED}$MODEL_ORIGEM${RESET}\n" \
		#			"\n${RED}${cmsg_todos_os_dados_serao_perdidos}${RESET}" \
		#			"\n${cmsg_ContinuarParticionamento} ${AConfDisk[_DEVICE]} ?\n"; then
		#      info "${cmsg_Disco} - AUTOMATIC" "\n$(gettext 'Particionamento e formatação automatica cancelado')"
		#			return 1
		#		fi
		#		nchoice=true

		#		if ! infoconf "${AConfDisk[_DEVICE]} - ${cmsg_Disco}" \
		#		  "$(fdisk -l "${AConfDisk[_DEVICE]}")" \
		#			"${YELLOW}${cwarning}" \
		#  		"DEVICE  : ${RED}${AConfDisk[_DEVICE]}${RESET}\n" \
		#	 		"MODEL  : ${RED}$MODEL_ORIGEM${RESET}\n" \
		#	  	"\n${RED}${cmsg_todos_os_dados_serao_perdidos}${RESET}" \
		#  		"\n${cmsg_ContinuarParticionamento} ${AConfDisk[_DEVICE]} ?\n"; then
		#      info "${AConfDisk[_DEVICE]} - ${cmsg_Disco^^} - AUTOMATIC" \
		#           "\n$(gettext '✗ Particionamento e formatação automatica cancelado pelo usuário')"
		#	 		return 1
		#  	fi
		#		nchoice=true
		nchoice=true
	fi

	if $nchoice; then
		sh_info_msg "${cmsg_CriandoParticoes} ${AConfDisk[_DEVICE]}"
		if [[ "${AConfDisk[_DISKTABLE]}" = "EFI" || "${AConfDisk[_DISKTABLE]}" = "GPT_BIOS" ]]; then
			label_type='gpt'
		else
			label_type='msdos'
		fi

		Amntpoint=()
		AsFs+=([_DEVICE]="${AConfDisk[_DEVICE]}")
		CSCRIPT+="mklabel $label_type "

		if [[ "$label_type" = "gpt" ]]; then
			#bios
			cnextpart=0
			cini="2MiB"
			cnextini="4MiB"
			((++cnextpart))
			CSCRIPT+="mkpart primary fat32 ${cini} ${cnextini} set 1 bios_grub on name 1 BIOS "

			#efi
			((++cnextpart))
			cini="${cnextini}"
			cnextini="512MiB"
			CSCRIPT+="mkpart primary fat32 ${cini} ${cnextini} set 2 esp       on name 2 EFI  "
			Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}2"]="/boot/efi|vfat|1")
			cini="${cnextini}"

			#boot
			if $withboot; then
				((++cnextpart))
				cnextpercent=$((AsDiskPercent[boot]))
				CSCRIPT+="mkpart primary ${AsFs[boot]:-ext4} ${cini} ${cnextpercent}% name ${cnextpart} BOOT "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="/boot|${AsFs[boot]:-ext4}|1")
				cini="${cnextpercent}%"
			fi

			#swap
			if $withswap; then
				((++cnextpart))
				cnextpercent=$((AsDiskPercent[boot] + AsDiskPercent[swap]))
				CSCRIPT+="mkpart primary linux-swap ${cini} ${cnextpercent}% name ${cnextpart} SWAP "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="none|swap|1")
				cini="${cnextpercent}%"
			fi

			#root
			((++cnextpart))
			cnextpercent=$((AsDiskPercent[boot] + AsDiskPercent[swap] + AsDiskPercent[root]))
			CSCRIPT+="mkpart primary ${AsFs[root]:-ext4} ${cini} ${cnextpercent}% name ${cnextpart} ROOT "
			Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="/|${AsFs[root]:-ext4}|1")
			cini="${cnextpercent}%"

			#home
			if $withhome; then
				((++cnextpart))
				((cnextpercent = cnextpercent + AsDiskPercent[home], cnextpercent = cnextpercent >= 99 ? 100 : cnextpercent))
				CSCRIPT+="mkpart primary ${AsFs[home]:-ext4} ${cini} ${cnextpercent}% name ${cnextpart} HOME "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="/home|${AsFs[home]:-ext4}|1")
			fi

		else
			cnextpart=0
			cini="2MiB"

			#boot
			if $withboot; then
				((++cnextpart))
				cnextpercent=$((AsDiskPercent[boot]))
				CSCRIPT+="mkpart primary ${AsFs[boot]:-ext4} ${cini} ${cnextpercent}% "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="/boot|${AsFs[boot]:-ext4}|1")
				cini="${cnextpercent}%"
			fi

			#swap
			if $withswap; then
				((++cnextpart))
				cnextpercent=$((AsDiskPercent[boot] + AsDiskPercent[swap]))
				CSCRIPT+="mkpart primary linux-swap ${cini} ${cnextpercent}% "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="none|swap|1")
				cini="${cnextpercent}%"
			fi

			#root
			((++cnextpart))
			cnextpercent=$((AsDiskPercent[boot] + AsDiskPercent[swap] + AsDiskPercent[root]))
			CSCRIPT+="mkpart primary ${AsFs[root]:-ext4} ${cini} ${cnextpercent}% set ${cnextpart} boot on "
			Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}$cnextpart"]="/|ext4|1")
			cini="${cnextpercent}%"

			#home
			if $withhome; then
				((++cnextpart))
				((cnextpercent = cnextpercent + AsDiskPercent[home], cnextpercent = cnextpercent >= 99 ? 100 : cnextpercent))
				CSCRIPT+="mkpart primary ${AsFs[home]:-ext4} ${cini} ${cnextpercent}% "
				Amntpoint+=(["${AConfDisk[_DEVICE]}${ext}${cnextpart}"]="/home|${AsFs[home]:-ext4}|1")
			fi

		fi

		parted --align=opt --script "${AConfDisk[_DEVICE]}" -- "$CSCRIPT" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		evaluate_retval "${PIPESTATUS[0]}"
		parted --align=opt --script "${AConfDisk[_DEVICE]}" -- print 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		Amkfs+=(["vfat"]="mkfs.vfat")
		Amkfs+=(["swap"]="mkswap")
		Amkfs+=(["ext4"]="mkfs.ext4")
		LMKPARTED=true
		LFS=true
		LPARTITION=true
		LFSREVISED=true
		sync 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		partprobe 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		sh_check_disk_health "${AConfDisk[_DEVICE]}"
	else
		die "${cmsg_InstalacaoAbortada}..."
	fi
}

sh_update_mirror() {
	sh_cmd_job "${cmsg_Configurando} ${cmsg_Mirror,,}" "
    conf=\"${dir_install}/etc/xbps.d/00-repository-main.conf\"
    {
      # default global
      echo \"repository=https://repo-fastly.voidlinux.org/current\"
      echo \"repository=https://repo-fastly.voidlinux.org/current/nonfree\"
      echo \"repository=https://repo-fastly.voidlinux.org/current/multilib\"
      echo \"repository=https://repo-fastly.voidlinux.org/current/multilib/nonfree\"
      echo

      # mirror escolhido
      echo \"repository=${url_mirror}/current\"
      if grep -qiE 'voidbr\\.org|chililinux|voidlinux\\.com\\.br' <<<\"${url_mirror}\"; then
        echo \"repository=${url_mirror}/extra\"
      fi
      echo \"repository=${url_mirror}/current/nonfree\"
      echo \"repository=${url_mirror}/current/multilib\"
      echo \"repository=${url_mirror}/current/multilib/nonfree\"

      # chililinux.com
      if ! grep -qi 'chililinux' <<<\"${url_mirror}\"; then
        echo
        echo \"repository=https://void.chililinux.com/voidlinux/extra\"
      fi

      # voidbr.org
      if ! grep -qi 'voidbr\\.org' <<<\"${url_mirror}\"; then
        echo
        echo \"repository=https://void.voidbr.org/voidlinux/current\"
        echo \"repository=https://void.voidbr.org/voidlinux/extra\"
        echo \"repository=https://void.voidbr.org/voidlinux/current/nonfree\"
        echo \"repository=https://void.voidbr.org/voidlinux/current/multilib\"
        echo \"repository=https://void.voidbr.org/voidlinux/current/multilib/nonfree\"
      fi

      # voidlinux.com.br
      if ! grep -qi 'voidlinux\\.com.\\br' <<<\"${url_mirror}\"; then
        echo
        echo \"repository=https://void.voidlinux.com.br/voidlinux/current\"
        echo \"repository=https://void.voidlinux.com.br/voidlinux/extra\"
        echo \"repository=https://void.voidlinux.com.br/voidlinux/current/nonfree\"
        echo \"repository=https://void.voidlinux.com.br/voidlinux/current/multilib\"
        echo \"repository=https://void.voidlinux.com.br/voidlinux/current/multilib/nonfree\"
      fi

    } > \"\$conf\"
  " $err_not_fatal
}

sh_update_rc_conf() {
	local cfile_rc="$dir_install/etc/rc.conf"
	local cpath_font="$dir_install/usr/share/kbd/consolefonts"

	sh_cmd_job "${cmsg_Ajustando} rc.conf" '
    if [[ ! -e $cfile_rc ]]; then
      touch $cfile_rc
    fi
    if [[ -e $cfile_rc ]]; then
      sed -i -e "s|HOSTNAME=.*|HOSTNAME=${AsUser[chostname]}|g" $cfile_rc
      sed -i -e "s|#\?HOSTNAME=.*|HOSTNAME=${AsUser[chostname]}|g" $cfile_rc
      sed -i -e "s|HARDWARECLOCK=.*|HARDWARECLOCK=${AConfLocale[_CLOCK]}|g" $cfile_rc
      sed -i -e "s|#\?HARDWARECLOCK=.*|HARDWARECLOCK=${AConfLocale[_CLOCK]}|g" $cfile_rc
      sed -i -e "s|FONT=.*|FONT=${AConfLocale[_FONT]}|g" $cfile_rc
      sed -i -e "s|#\?FONT=.*|FONT=${AConfLocale[_FONT]}|g" $cfile_rc
      sed -i -e "s|KEYMAP=.*|KEYMAP=${AConfLocale[_KEYMAP]}|g" $cfile_rc
      sed -i -e "s|#\?KEYMAP=.*|KEYMAP=${AConfLocale[_KEYMAP]}|g" $cfile_rc
      sed -i -e "s|TIMEZONE=.*|TIMEZONE=${AConfLocale[_TIMEZONE]}|g" $cfile_rc
      sed -i -e "s|#\?TIMEZONE=.*|TIMEZONE=${AConfLocale[_TIMEZONE]}|g" $cfile_rc
    fi
  ' $err_not_fatal

	sh_cmd_job "${cmsg_Ajustando} fonts" '
    cp -f $cpath_font/Uni3-TerminusBold32x16.psf.gz $cpath_font/default8x16.psfu.gz
  ' $err_not_fatal

	sh_chroot_job "${cmsg_Ajustando} timezone pass2" "
    ln -sf /usr/share/zoneinfo/${AConfLocale[_TIMEZONE]} /etc/localtime
  " $err_not_fatal
}

sh_update_hostname() {
	sh_cmd_job "${cmsg_Ajustando} hostname" "
      echo ${AsUser[chostname]} > ${dir_install}/etc/hostname
   " $err_not_fatal
}

sh_update_rc_local() {
	sh_cmd_job "${cmsg_Ajustando} rc.local" "
      cat > ${dir_install}/etc/rc.local <<-EOF
#HOSTNAME="${AsUser[chostname]}"
#HARDWARECLOCK="${AConfLocale[_CLOCK]}"
#TIMEZONE="${AConfLocale[_TIMEZONE]}"
#KEYMAP="${AConfLocale[_KEYMAP]}"
#hwclock --systohc
EOF
   " $err_not_fatal
}

sh_update_wpa_suplicant() {
	sh_cmd_job "${cmsg_Ajustando} wpa_supplicant.conf" "
      cat >"$dir_install/etc/wpa_supplicant/wpa_supplicant.conf" <<-EOF
ctrl_interface=/run/wpa_supplicant
ctrl_interface_group=wheel
update_config=1
fast_reauth=1

network={
   ssid=P"$_WIFI_NETWORK"
   psk="$_WIFI_PASSWORD"
   mesh_fwding=1
}
EOF
   " $err_not_fatal
}

sh_update_console() {
	local cfile="etc/default/grub"

	sh_cmd_job "${cmsg_Ajustando} console grub" "
      if [[ -e "$dir_install/$cfile" ]]; then
		   sed -i "$dir_install/$cfile" \
			   -e 's|#\(GRUB_TERMINAL_INPUT\).*|\1=console|' \
   			-e 's|#\(GRUB_TERMINAL_OUTPUT\).*|\1=console|'
	   fi
   " $err_not_fatal
}

sh_update_Xkeymap() {
	if [[ "${AConfLocale[_KEYMAP]}" != 'br-abnt2' ]]; then
		return 0
	fi

	sh_info_msg "${cmsg_Ajustando} ${cmsg_Teclado,,} ${AConfLocale[_KEYMAP]} (X11)"
	if [[ ! -d "$dir_install/etc/X11/xorg.conf.d" ]]; then
		mkdir -p "$dir_install/etc/X11/xorg.conf.d"
	fi

	if [[ ! -e "$dir_install/etc/X11/xorg.conf.d/10-keyboard.conf" ]]; then
		cat >"$dir_install/etc/X11/xorg.conf.d/10-keyboard.conf" <<EOF
Section "InputClass"
   Identifier "Keyboard Br Abnt2"
   MatchIsKeyboard "on"
   Option "XkbModel" "pc105"
   Option "XkbLayout" "br"
   Option "XkbVariant" "abnt2"
   Option "XKbOptions" ""
EndSection
EOF
	fi
}

sh_check_util_fs() {
	for i in "${!Amkfs[@]}"; do
		cmdsearch="${Amkfs[$i]}"
		if [[ -z $(command -v "$cmdsearch") ]]; then
			result="\n${RED}${cmsg_ERRO}${RESET}: ${cmsg_CommandNotFound} ${BOLD}${CYAN}'$cmdsearch'${RESET}"
			result+="\n--------------${cmsg_ImpossivelContinuar}-------------"
			result+="\n${cmsg_ImpossivelContinuar1}"
			result+="\n${cmsg_ImpossivelContinuar2} \$PATH"
			result+="\n-----------------------------------------------"
			display_result "$result" "${cmsg_CommandNotFound}"
			die "${cmsg_ERRO}: ${cmsg_InstalacaoAbortada}... ${cmsg_CommandNotFound} ${bold}${cyan}'$cmdsearch'${reset}"
			return 1
		fi
	done
	return 0
}

sh_make_fs() {
	local i
	local _PART
	local format
	local fstype

	declare -A fsparms=(
		[ext2]="-F -L VOIDBR"
		[ext3]="-F -L VOIDBR"
		[ext4]="-F -L VOIDBR"
		[btrfs]="-f -L VOIDBR"
		[f2fs]="-f -l VOIDR"
		[xfs]="-m crc=0 -f -L VOIDBR"
		[jfs]="-f -L VOIDBR"
		[vfat]="-F32 -n EFI"
		[ntfs]="-F -L NTFS"
		[nilfs2]="-f -L NILFS2"
		#		[reiserfs]="-f -l VOIDBR"
	)

	sh_check_util_fs
	for i in "${!Amntpoint[@]}"; do
		_PART="$i"
		fstype="$(sh_splitarray "${Amntpoint[$i]}" 2)"
		format="$(sh_splitarray "${Amntpoint[$i]}" 3)"

		if [[ "$format" = "1" ]]; then
			sh_cmd_job "${cmsg_FormatandoParticao} ${_PART} FS ${fstype,,}" "
   			if [[ "$fstype" = "swap" ]]; then
	   			wipefs -a "${_PART}"
		   		mkswap "${_PART}"
   			else
	   			wipefs -a "${_PART}"
		   		mkfs.$fstype ${fsparms[$fstype]} ${_PART}
   			fi
         "
		fi
	done

	if $LVM; then
		sh_make_fsLvm
	fi
}

sh_umount_fs() {
	sh_info_msg "${cmsg_DismountFileSystem}\n"
	if umount -rfl "$dir_install" >/dev/null 2>&1; then
		LBIND=false
	fi
}

sh_stop_mount() {
	local nchoice

	sh_cmd_job "${cmsg_umount_partition}" "
      umount -rl "$dir_install"
      nchoice="${PIPESTATUS[0]}"
      evaluate_retval 0
   	[[ $nchoice -eq 0 || $nchoice -eq 32 ]] && LMOUNT=0
	   [[ $LMOUNT -eq 0 ]] && return 0 || return 1
   " $err_not_fatal
}

sh_ignore_error() {
	"$@" 2>/dev/null
	return 0
}

sh_chroot_maybe_add_mount() {
	local cond=$1
	shift
	if eval "$cond"; then
		sh_mount_bind "$@"
	fi
}

sh_mount_bind() {
	mount "$@" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
}

sh_init_bind() {
	local nchoice

	if ! $LBIND; then
		sh_info_msg "${cmsg_MontandoAmbiente} chroot ${cyan}=> ${yellow}${dir_install}"
		for i in /proc /sys /dev /dev/pts /dev/shm /run /tmp; do
			mkdir -p "$dir_install$i" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		done

		sh_mount_bind proc "${dir_install}/proc" -t proc -o nosuid,noexec,nodev &&
			sh_mount_bind sys "${dir_install}/sys" -t sysfs -o nosuid,noexec,nodev,ro &&
			sh_ignore_error sh_chroot_maybe_add_mount "[[ -d '$dir_install/sys/firmware/efi/efivars' ]]" \
				efivarfs "$dir_install/sys/firmware/efi/efivars" -t efivarfs -o nosuid,noexec,nodev &&
			sh_mount_bind udev "${dir_install}/dev" -t devtmpfs -o mode=0755,nosuid &&
			sh_mount_bind devpts "${dir_install}/dev/pts" -t devpts -o mode=0620,gid=5,nosuid,noexec &&
			sh_mount_bind shm "${dir_install}/dev/shm" -t tmpfs -o mode=1777,nosuid,nodev &&
			sh_mount_bind /run "${dir_install}/run" -t tmpfs -o nosuid,nodev,mode=0755 &&
			sh_mount_bind tmp "${dir_install}/tmp" -t tmpfs -o mode=1777,strictatime,nodev,nosuid
		evaluate_retval
		nchoice=$?
		[[ $nchoice -eq 0 ]] && LBIND=true
	fi
	$LBIND && return 0 || return 1
}

sh_run_clean() {
	local ret

	eval "$1" 2>&1 |
		strip_ansi |
		tee -i -a "$BOOTLOG" \
			>"$LOGGER"
	ret="${PIPESTATUS[0]}"

	return "$ret"
}

sh_stop_bind() {
	local nchoice

	sh_info_msg "${cmsg_DesMontandoAmbiente} chroot"
	sh_run_clean "
      umount -r "${dir_install}/proc" \
      umount -r "${dir_install}/sys" \
      umount -r "$dir_install/sys/firmware/efi/efivars" \
      umount -r "${dir_install}/dev/shm" \
      umount -r "${dir_install}/dev/pts" \
      umount -r "${dir_install}/dev" \
      umount -r "${dir_install}/run" \
      umount -r "${dir_install}/tmp"
   "
	nchoice="$?"
	evaluate_retval 0

	[[ $nchoice -eq 0 ]] && LBIND=false
	$LBIND && return 1 || return 0

}

strip_ansi() {
	printf '%s' "$1" |
		sed -E '
      s/\x1B\[[0-9;]*m//g;      # Remove SGR (Cores, negrito, etc: 1m, 38;5;196m)
      s/\x1B\[[0-9;?]*[@-~]//g; # Remove outros CSI (Movimento de cursor, etc)
      s/\x1B\([a-zA-Z]//g;      # Remove Charset (O ^[(B que apareceu antes)
      s/\x1B[@-Z\\-_]//g;       # Remove escapes de 2 caracteres
    '
}

sh_make_user() {
	local user="${AsUser[cuser]}"

	if [[ -n "${AsUser[cuser]}" ]]; then
		if [[ -n "${AsUser[cfullname]}" ]]; then
			sh_chroot_job "${cmsg_CriandoUsuario}: ${AsUser[cuser]} - ${AsUser[cfullname]}" "useradd -m ${AsUser[cuser]} -G ${AsUser[cgroups]} -p ${AsUser[cpass]} -c '${AsUser[cfullname]}'"
		else
			sh_chroot_job "${cmsg_CriandoUsuario}: ${AsUser[cuser]} - ${AsUser[cfullname]}" "useradd -m ${AsUser[cuser]} -G ${AsUser[cgroups]} -p ${AsUser[cpass]}"
		fi
		sh_chroot_job "${cmsg_AjustandoSenhaUsuario}: ${AsUser[cuser]}" "(echo ${AsUser[cuser]}:${AsUser[cpass]}) | chpasswd -m > /dev/null 2>&1"
	fi

	if [[ -n "${AsUser[cpassroot]}" ]]; then
		sh_chroot_job "${cmsg_AjustandoSenhaUsuario}: root" "(echo root:${AsUser[cpassroot]}) | chpasswd -m > /dev/null 2>&1"
		sh_chroot_job "${cmsg_AtivandoBashUsuario}: root" "chsh -s /bin/bash root"
	fi

	sh_cmd_job "$(gettext 'Copiando skel para root')" "
      cp -Rpva $dir_install/etc/skel/.bash* $dir_install/root/
      cp -Rpva $dir_install/etc/skel/.dircolors $dir_install/root/
      cp -Rpva $dir_install/etc/skel/.git-prompt.sh $dir_install/root/
   " $err_not_fatal

	sh_cmd_job "$(gettext 'Removendo link do instalador')" "
        rm -f $dir_install/home/$user/'Área de trabalho'/void-install.desktop
        rm -f $dir_install/home/$user/Área\ de\ trabalho/void-install.desktop
        rm -f $dir_install//usr/share/applications/void-install.desktop
   " $err_not_fatal

	sh_update_sudoers
}

sh_update_sudoers() {
	local user="${AsUser[cuser]}"

	sh_info_msg "$(gettext 'Atualizando sudoers')"
	if [ -d "$dir_install/etc/sudoers.d" ]; then
		# USER
		echo "# Enable sudo for login '$user'" >"$dir_install/etc/sudoers.d/$user"
		[ "$LSERVER" = true ] && echo 'Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/opt/samba/bin:/opt/samba/sbin"' >>"$dir_install/etc/sudoers.d/$user"
		echo "$user ALL=(ALL:ALL) NOPASSWD: ALL" >>"$dir_install/etc/sudoers.d/$user"

		# WHEEL
		echo "# enable the sudoers entry for members of group wheel" >"$dir_install/etc/sudoers.d/wheel"
		[ "$LSERVER" = true ] && echo 'Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/opt/samba/bin:/opt/samba/sbin"' >>"$dir_install/etc/sudoers.d/wheel"
		echo "%wheel ALL=(ALL:ALL) NOPASSWD: ALL" >>"$dir_install/etc/sudoers.d/wheel"

		unset user
	fi
}

sh_make_fstab() {
	local i
	local _part
	local label
	local fstype
	local format
	local size
	local mntpoint
	local fsorder=1

	if ! $LVM; then
		sh_info_msg "${cmsg_Gerando} fstab pass1"
		echo "tmpfs /tmp tmpfs defaults,nosuid,nodev,noatime,mode=1777 0 0" >"$dir_install/etc/fstab"
		#		echo "tmpfs /var/log tmpfs defaults,noatime,mode=0755 0 0" >>"$dir_install/etc/fstab"
		echo "proc /proc proc nodev,noexec,nosuid 0 0" >>"$dir_install/etc/fstab"

		for i in "${!Amntpoint[@]}"; do
			_part="$i"
			mntpoint="$(sh_splitarray "${Amntpoint[$i]}" 1)"
			fstype="$(sh_splitarray "${Amntpoint[$i]}" 2)"
			format="$(sh_splitarray "${Amntpoint[$i]}" 3)"

			if [ "$fstype" = "f2fs" -o "$fstype" = "btrfs" -o "$fstype" = "xfs" -o "$fstype" = "reiserfs" ]; then
				fsorder=0
			fi

			if [ "$fstype" = "swap" ]; then
				echo "UUID=$(blkid -o value -s UUID "${_part}") none swap none,nofail 0 0" >>"$dir_install/etc/fstab"
				continue
			fi

			if [ -n "$mntpoint" ]; then
				if [ "$mntpoint" = '/boot/efi' ]; then
					echo "UUID=$(blkid -o value -s UUID "${_part}") ${mntpoint} ${fstype,,} defaults 0 2" >>"$dir_install/etc/fstab"
				else
					if [ "$format" = 0 ]; then
						if [ "$mntpoint" = 'none' ]; then
							((++Npoint))
							mntpoint="/mnt/none${Npoint}"
							mkdir -p "$dir_install/${mntpoint}"
						fi
						echo "UUID=$(blkid -o value -s UUID "${_part}") ${mntpoint} ${fstype,,} defaults,nofail,noatime,discard,lazytime 0 $fsorder" >>"$dir_install/etc/fstab"
					else
						echo "UUID=$(blkid -o value -s UUID "${_part}") ${mntpoint} ${fstype,,} defaults,noatime,discard,lazytime 0 $fsorder" >>"$dir_install/etc/fstab"
					fi
				fi
			fi
		done
		#		evaluate_retval "$?"
	else
		sh_info_msb "${cmsg_Gerando} fstab pass1"
		for i in "${!Amntpoint[@]}"; do
			_part="$i"
			mntpoint="$(sh_splitarray "${Amntpoint[$i]}" 1)"
			fstype="$(sh_splitarray "${Amntpoint[$i]}" 2)"
			format="$(sh_splitarray "${Amntpoint[$i]}" 3)"

			if [[ "$mntpoint" = "/boot/efi" ]]; then
				echo "UUID=$(blkid -o value -s UUID "${_part}") ${mntpoint} ${fstype,,} defaults 0 $fsorder" >>"$dir_install/etc/fstab"
				break
			fi
		done

		for i in "${!AmntpointFDE[@]}"; do
			_part="$i"
			label="$(sh_splitarray "${AmntpointFDE[$i]}" 1)"
			fstype="$(sh_splitarray "${AmntpointFDE[$i]}" 2)"
			format="$(sh_splitarray "${AmntpointFDE[$i]}" 3)"
			size="$(sh_splitarray "${AmntpointFDE[$i]}" 4)"
			mntpoint="$(sh_splitarray "${AmntpointFDE[$i]}" 5)"
			#			echo "UUID=$(blkid -o value -s UUID "${_part}") $mntpoint ${fstype,,} defaults 0 0" >>"$dir_install/etc/fstab"
			echo "UUID=$(blkid -o value -s UUID "${_part}") $mntpoint ${fstype,,} defaults,noatime,discard,lazytime 0 0" >>"$dir_install/etc/fstab"
		done
		#		evaluate_retval "$?"
	fi

	sh_chroot_job "${cmsg_Gerando} fstab pass2" \
		"sed 's/#.*//' /etc/fstab | column --table --table-columns SOURCES,DIR,TYPE,OPTIONS,DUMP,PASS --table-hide - >/tmp/fstab" "$err_not_fatal"
	sh_chroot_job "${cmsg_Gerando} fstab pass3" \
		"sed -i 's/SOURCES/#SOURCE/' /tmp/fstab" "$err_not_fatal"
	sh_chroot_job "${cmsg_Gerando} fstab pass4" \
		"cp /tmp/fstab /etc/fstab" "$err_not_fatal"
}

sh_activating_services() {
	#dica: No Void, com dbus ativo, o elogind e o polkitd sobem automaticamente.
	#      Você não precisa ativar os serviços deles no runit.
	local service
	local level=2
	aServicesTTY+=(dbus sshd chronyd udevd uuidd dmeventd socklog-unix)
	aServicesX+=()

	if ! $LSERVER && ! $ONLY_TTY; then aServicesX+=(bluetoothd); fi

	for x in "${aDE[@]}"; do
		case $x in
		tty | server) continue ;;
		*)
			aServicesX+=($_DISPLAYMANAGER)
			break
			;;
		esac
	done

	for service in "${aServicesTTY[@]}"; do
		sh_chroot_job "${cmsg_AtivandoServico} $service" \
			"ln -sf /etc/sv/$service /etc/runit/runsvdir/current/" \
			"$err_not_fatal" \
			"$level"
	done

	if ! $LONLY_TTY; then
		for service in "${aServicesX[@]}"; do
			sh_chroot_job "${cmsg_AtivandoServico} $service" \
				"ln -sf /etc/sv/$service /etc/runit/runsvdir/current/" \
				"$err_not_fatal" \
				"$level"
		done
	fi
}

sh_hack_hyprland_lib() {
	local cpath="$dir_install/usr/lib"
	local lib

	sh_info_msg "${cmsg_Ajustando} libs"
	pushd "$cpath" >/dev/null || return
	for lib in libjxl libjxl_cms libjxl_threads; do
		[ -e "${lib}.so.0.12" ] && ln -sf "${lib}.so.0.12" "${lib}.so.0.11"
	done
	popd >/dev/null || return
}

sh_configure_hyprland_audio() {
	local cuser="${AsUser[cuser]}"
	local cfile_home="$dir_install/home/$cuser/.config/hypr/hyprland.lua"
	local cfile_skel="$dir_install/etc/skel/.config/hypr/hyprland.lua"

	sh_info_msg "${cmsg_Ajustando} hyprland.lua"
	case "${AConfAudio[_AUDIOSERVER]:-Pipewire}" in
	Pulseaudio)
		# Remove qualquer comentário das duas linhas
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_home"
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_skel"
		sed -i '/hl\.exec_cmd("pipewire")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_home"
		sed -i '/hl\.exec_cmd("pipewire")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_skel"

		# Comenta apenas o pipewire
		sed -i '/hl\.exec_cmd("pipewire")/s/^/--   /' "$cfile_home"
		sed -i '/hl\.exec_cmd("pipewire")/s/^/--   /' "$cfile_skel"
		;;
	Pipewire)
		# Remove qualquer comentário das duas linhas
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_home"
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_skel"
		sed -i '/hl\.exec_cmd("pipewire")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_home"
		sed -i '/hl\.exec_cmd("pipewire")/s/^[[:space:]]*--[[:space:]]*//' "$cfile_skel"

		# Comenta apenas o pulseaudio
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^/--   /' "$cfile_home"
		sed -i '/hl\.exec_cmd("pulseaudio --start")/s/^/--   /' "$cfile_skel"
		;;
	esac
}

sh_global_audio_cleaning() {
	local cuser="${AsUser[cuser]}"

	# LIMPEZA GLOBAL — remover qualquer autostart do sistema
	# (evita conflito com configuração do usuário)
	sh_chroot_job "${cmsg_Ajustando} sound global" "
    # remover PipeWire global
    sudo rm -f /etc/xdg/autostart/pipewire.desktop
    sudo rm -f /etc/xdg/autostart/pipewire-pulse.desktop
    sudo rm -f /etc/xdg/autostart/wireplumber.desktop

    # remover PulseAudio global
    sudo rm -f /etc/xdg/autostart/pulseaudio.desktop
    sudo rm -f /etc/xdg/autostart/pulseaudio-kde.desktop

    # remover qualquer config ALSA global que redirecione áudio
    sudo rm -f /etc/alsa/conf.d/50-pipewire.conf
    sudo rm -f /etc/alsa/conf.d/99-pipewire-default.conf
    sudo rm -f /etc/alsa/conf.d/50-pulseaudio.conf

    #limpar /etc/asound.conf residual
    sudo rm -f /etc/asound.conf

    # LIMPEZA DO USUÁRIO
    rm -f /home/$cuser/.config/autostart/pipewire.desktop
    rm -f /home/$cuser/.config/autostart/pipewire-pulse.desktop
    rm -f /home/$cuser/.config/autostart/wireplumber.desktop
    rm -f /home/$cuser/.config/autostart/pulseaudio.desktop
    rm -f /home/$cuser/.config/autostart/pulseaudio-kde.desktop

    rm -rf /home/$cuser/.config/pipewire
    rm -rf /home/$cuser/.config/wireplumber
    rm -rf /home/$cuser/.config/pulse
    rm -rf /home/$cuser/.config/alsa

  " $err_not_fatal
}

sh_activating_pipewire() {
	local cuser="${AsUser[cuser]}"

	sh_global_audio_cleaning
	sh_chroot_job "${cmsg_Ajustando} Pipewire (user autostart)" "

   # DESATIVAR AUTOSPAWN DO PULSEAUDIO (usuário)
   # impede PulseAudio iniciar automaticamente
   mkdir -p /home/${cuser}/.config/pulse

   cat > /home/${cuser}/.config/pulse/client.conf <<EOF
autospawn = no
daemon-binary = /bin/true
EOF

    #AUTOSTART CORRETO (SÓ USUÁRIO)
    mkdir -p /home/${cuser}/.config/autostart
    ln -sf /usr/share/applications/pipewire.desktop \
      /home/${cuser}/.config/autostart/pipewire.desktop

    mkdir -p /home/${cuser}/.config/pipewire/pipewire.conf.d
    ln -sf /usr/share/examples/wireplumber/10-wireplumber.conf \
      /home/${cuser}/.config/pipewire/pipewire.conf.d/10-wireplumber.conf
    ln -sf /usr/share/examples/pipewire/20-pipewire-pulse.conf \
      /home/${cuser}/.config/pipewire/pipewire.conf.d/20-pipewire-pulse.conf

    # ---- integração ALSA → PipeWire ----
    mkdir -p /etc/alsa/conf.d
    ln -sf /usr/share/alsa/alsa.conf.d/50-pipewire.conf /etc/alsa/conf.d/50-pipewire.conf
    ln -sf /usr/share/alsa/alsa.conf.d/99-pipewire-default.conf /etc/alsa/conf.d/99-pipewire-default.conf

    chown $cuser:$cuser /home/$cuser/ -R

  " $err_not_fatal
}

sh_activating_pulseaudio() {
	local cuser="${AsUser[cuser]}"

	sh_global_audio_cleaning
	sh_chroot_job "${cmsg_Ajustando} PulseAudio (user autostart)" "

    #AUTOSTART CORRETO (SÓ USUÁRIO)
    mkdir -p /home/$cuser/.config/autostart
    # ---- autostart do PulseAudio ----
    cat > ~/.config/autostart/pulseaudio.desktop <<EOF
[Desktop Entry]
Type=Application
Exec=pulseaudio --start
Hidden=false
NoDisplay=false
X-GNOME-Autostart-enabled=true
Name=PulseAudio
EOF

    # ---- integração ALSA → PulseAudio ----
    mkdir -p /etc/alsa/conf.d/
    ln -sf /usr/share/alsa/alsa.conf.d/50-pulseaudio.conf /etc/alsa/conf.d/50-pulseaudio.conf

    chown $cuser:$cuser /home/$cuser/ -R

    " $err_not_fatal
}

sh_mk_working_dir() {
	local cdir
	local adir=("$dir_install/boot"
		"$dir_install/boot/efi"
		"$dir_install/dev"
		"$dir_install/proc"
		"$dir_install/sys"
		"$dir_install/var/db/xbps/keys"
		"$dir_install/etc/xbps.d"
	)

	for cdir in "${adir[@]}"; do
		sh_cmd_job "${cmsg_CriandoDiretorio}: $cdir" "
		   [[ -d "$cdir" ]] || mkdir -p "$cdir"
      " $err_fatal
	done
}

sh_mount_fs() {
	local i
	local _part
	local mntpoint
	local fstype

	if ! $LVM; then
		for i in "${!Amntpoint[@]}"; do
			_part="$i"
			mntpoint="$(sh_splitarray "${Amntpoint[$i]}" 1)"
			if [[ -n "$mntpoint" && "$mntpoint" = "/" ]]; then
				sh_info_msg "${cmsg_MontandoParticao} ${_part} ${red}(${mntpoint})${rst} ${mntpoint}"
				mkdir -p "$dir_install"
				mount "$_part" "$dir_install"
				evaluate_retval "$?"
				break
			fi
		done
	else
		for i in "${!AmntpointFDE[@]}"; do
			_part="$i"
			label="$(sh_splitarray "${AmntpointFDE[$i]}" 1)"
			fstype="$(sh_splitarray "${AmntpointFDE[$i]}" 2)"
			format="$(sh_splitarray "${AmntpointFDE[$i]}" 3)"
			size="$(sh_splitarray "${AmntpointFDE[$i]}" 4)"
			mntpoint="$(sh_splitarray "${AmntpointFDE[$i]}" 5)"
			lvunit="${size: -1}"

			if [[ -n "$mntpoint" && "$mntpoint" = "/" ]]; then
				mkdir -p "$dir_install${mntpoint}"
				sh_info_msg "${cmsg_MontandoParticao} ${_part} ($dir_install)"
				mount "${_part}" "$dir_install${mntpoint}"
				evaluate_retval "$?"
				break
			fi
		done

		for i in "${!AmntpointFDE[@]}"; do
			_part="$i"
			label="$(sh_splitarray "${AmntpointFDE[$i]}" 1)"
			fstype="$(sh_splitarray "${AmntpointFDE[$i]}" 2)"
			format="$(sh_splitarray "${AmntpointFDE[$i]}" 3)"
			size="$(sh_splitarray "${AmntpointFDE[$i]}" 4)"
			mntpoint="$(sh_splitarray "${AmntpointFDE[$i]}" 5)"
			lvunit="${size: -1}"

			[[ -n "$mntpoint" && "$mntpoint" = "/" || "$fstype" = "swap" ]] && continue

			mkdir -p "$dir_install${mntpoint}"
			sh_info_msg "${cmsg_MontandoParticao} ${_part} ($dir_install) ${cmsg_Em} $dir_install${mntpoint}"
			mount "${_part}" "$dir_install${mntpoint}"
			evaluate_retval "$?"
		done
	fi

	for i in "${!Amntpoint[@]}"; do
		_part="$i"
		mntpoint="$(sh_splitarray "${Amntpoint[$i]}" 1)"
		fstype="$(sh_splitarray "${Amntpoint[$i]}" 2)"
		if [[ -n "$mntpoint" && "$mntpoint" = "/" ]]; then
			continue
		fi

		if [[ "$fstype" = "swap" ]]; then
			continue
		fi

		if [[ -n "$mntpoint" ]]; then
			sh_info_msg "${cmsg_MontandoParticao} ${_part} ${red}(${mntpoint})${rst} ${cmsg_Em} $dir_install${mntpoint}"
			mkdir -p "$dir_install${mntpoint}"
			mount "$_part" "$dir_install${mntpoint}"
			evaluate_retval "$?"
		fi
	done
}

sh_common_theme() {
	apkgs+=(
		voidbr-wallpapers
		voidbr-tokyo-theme
		voidbr-dracula-theme
		voidbr-professional-theme
		voidbr-xfwm-axiom-theme
		voidbr-beauty-icons
	)
}

sh_X11_minimal() {
	local apkgs=()
	local aMedia=()

	if ! $LHYPRLAND; then
		apkgs+=("${aXorg[@]}")
	fi

	apkgs+=("${aVideo[@]}")
	apkgs+=("${aFonts[@]}")
	apkgs+=("${aDisplaymanager[@]}")
	apkgs+=("${aDisplaymanagerConfig[@]}")
	apkgs+=("${aTerminal[@]}")
	apkgs+=("${aFilemanager[@]}")
	apkgs+=("${aBrowser[@]}")
	apkgs+=("${aBluetooth[@]}")
	apkgs+=("${aNetworkX[@]}")
	apkgs+=("${aUtilityX[@]}")
	apkgs+=("${aIconsAndThemes[@]}")

	if $LAUDIO; then
		apkgs+=("${aPulseaudio[@]}")
		apkgs+=("${aPipewire[@]}")
		aMedia+=("${aPulseaudio[@]}")
		aMedia+=("${aPipewire[@]}")
	fi

	apkgs+=("${aPrinter[@]}")
	apkgs+=("${aPerfumery[@]}")
	apkgs+=("${aMicrocode[@]}")
	apkgs+=("${aArchiverX[@]}")
	apkgs+=("${aEditorX[@]}")

	if ! $LHYPRLAND; then
		sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Xorg')" "${aXorg[*]}"
	fi

	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Microde')" "${aMicrocode[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Video')" "${aVideo[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Rede')" "${aNetworkX[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Fontes')" "${aFonts[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Icones')" "${aIconsAndThemes[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM')" "${aDisplaymanager[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM Config')" "${aDisplaymanagerConfig[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Terminais')" "${aTerminal[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote FileManager')" "${aFilemanager[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Navegadores')" "${aBrowser[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Bluetooth')" "${aBluetooth[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Utilitários')" "${aUtilityX[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Media')" "${aMedia[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Impressoras')" "${aPrinter[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Perfumarias')" "${aPerfumery[*]}"
	sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote Archivadores')" "${aArchiverX[*]}"
}

sh_fluxbox_meta_package() {
	local DE='fluxbox'
	local apkgs=(voidbr-fluxbox)
  apkgs+=(voidbr-base-config)
	apkgs+=(voidbr-fluxbox-config)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"

	if [[ -f "$dir_install/home/${AsUser[cuser]}/.fluxbox/startup" ]]; then
		sed -e "/xmodmap/s//# xmodmap/" -i "$dir_install/home/${AsUser[cuser]}/.fluxbox/startup" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		if [[ "${AConfLocale[_KEYMAP]}" = 'br-abnt2' ]]; then
			sed -e '/\# xmodmap/a setxkbmap br -variant abnt2' -i "$dir_install/home/${AsUser[cuser]}/.fluxbox/startup" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		fi
	fi
}

sh_openbox_minimal() {
	local apkgs=(openbox obconf)
	local DE='OpenBox'
	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_plasma_minimal() {
	local DE='Plasma Desktop'
	local apkgs=(
		kde5
		plasma-desktop
		plasma-nm
		plasma-pa
		plasma-disks
		kate
		konsole
		dolphin
	)

	if $LCUSTOM; then
		apkgs+=(
			kf6-kaccounts-integration
			kaccounts-providers
			signon-kwallet-extension
			ark
			kwalletmanager
			spectacle
		)

		apkgs+=(
			voidbr-plasma-config
		)

		sh_common_theme

	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_cinnamon_minimal() {
	local DE='cinnamon'
	local apkgs=(cinnamon cinnamon-all)

	if $LCUSTOM; then
		apkgs+=(
			plank
			voidbr-cinnamon-config
		)

		sh_common_theme

	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_enlightenment_minimal() {
	local DE='Enlightenment'
	local apkgs=(
		enlightenment
		efl
		exquisite
		connman
	)

	if $LCUSTOM; then
		apkgs+=(
			voidbr-enlightenment-config
		)

		sh_common_theme

	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_xfce_minimal() {
	local DE='Xfce'
	local apkgs=(
		xfce4
		xfce4-plugins
		xfce4-screenshooter
		xfce4-dict
		xfce4-datetime-plugin
		xfce4-pulseaudio-plugin
	)

	if $LCUSTOM; then
		apkgs+=(
			thunar-archive-plugin
			ristretto
			engrampa
			file-roller
			mate-calc
			umc
			plank
			voidbr-xfce-config
		)

		sh_common_theme
	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_server_minimal() {
	local DE='Void server'
	declare apkgs=(
		bind-utils
		ldns
	)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_xorg_minimal() {
	local DE='Xorg Minimal'
	declare apkgs=(
		xorg-minimal
		xinit
		xterm
		xorg-fonts
		xorg-video-drivers
		mesa-dri
	)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_gnome_minimal() {
	local DE='Gnome'
	local apkgs=(
		"bluez"                    # Pilha de protocolos Bluetooth
		"cantarell-fonts"          # Fonte oficial da interface GNOME
		"colord"                   # Gerenciador de perfis de cores
		"extension-manager"        # App para gerenciar extensões sem navegador
		"gdm"                      # Gerenciador de login (Display Manager)
		"gnome"                    # Meta-pacote Core (Shell, Nautilus, Control Center)
		"gnome-apps"               # Suite de aplicativos padrão (Calculadora, Mapas, etc.)
		"gnome-backgrounds"        # Papéis de parede oficiais do GNOME
		"gnome-bluetooth"          # Interface de controle do Bluetooth no GNOME
		"gnome-browser-connector"  # Integração do navegador com extensões do Shell
		"gnome-characters"         # Utilitário de mapa de caracteres e emojis
		"gnome-connections"        # Cliente nativo para conexões remotas RDP/VNC
		"gnome-disk-utility"       # Utilitário para gerenciamento de discos e partições
		"gnome-keyring"            # Gerenciador de senhas, chaves SSH e GPG
		"gnome-online-accounts"    # Configuração central de contas externas
		"gnome-session"            # Gerenciador de sessão do GNOME
		"gnome-shell-extensions"   # Extensões oficiais fornecidas pelo projeto GNOME
		"gnome-system-monitor"     # Monitor de processos e recursos do sistema
		"gnome-terminal"           # Emulador de terminal padrão do GNOME
		"gnome-themes-extra"       # Temas extras para compatibilidade GTK2 e GTK3
		"mime-types"               # Fornece o arquivo compartilhado /etc/mime.types
		"papirus-icon-theme"       # Conjunto de ícones Papirus
		"polkit"                   # Framework para definição de privilégios
		"simple-scan"              # Utilitário de digitalização de documentos
		"tracker3"                 # Motor de busca e indexação de arquivos
		"tracker3-miners"          # Extratores de metadados para busca do Tracker
		"xdg-desktop-portal-gnome" # Integração de interface e permissões para Wayland
		"xdg-user-dirs-gtk"        # Gerenciamento automático das pastas padrão de usuário
		"accountsservice"          # D-Bus interfaces for querying and manipulating user account information
	)

	if $LCUSTOM; then
		apkgs+=(dconf-editor devhelp Endeavour evolution five-or-more four-in-a-row geary
			gedit ghex glade3 gnome-boxes gnome-builder gnome-chess gnome-games-collection
			gnome-klotski gnome-mahjongg gnome-multi-writer gdm-settings
			gnome-nettool gnome-nibbles gnome-robots gnome-sound-recorder gnome-sudoku
			gnome-taquin gnome-tetravex gnome-tweaks gnome-usage hitori iagno lightsoff
			polari quadrapassel swell-foop sysprof tali
		)
		apkgs+=(
			voidbr-gnome-config
			voidbr-change-gnome-wallpaper
		)

		sh_common_theme
	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_i3_minimal() {
	local DE='I3'
	local apkgs=(
		i3
		i3status # Status bar generator for i3bar, dzen2, xmobar or similar programs
		dmenu    # Generic menu for X
		#   i3lock-color
		i3lock     # Improved screenlocker based upon XCB and PAM
		volumeicon # Lightweight volume control that sits in your systray
		mc         # User-friendly file manager and visual shell
		scrot      # Simple command-line screenshot utility for X
		mpv        # Video player based on MPlayer/mplayer2
		cava       # Audio Visualizer for ALSA
		pcmanfm    # LXDE file manager
		alacritty
		mate-themes
		gnome-themes-standard
		voidbr-i3wm-config
		autotiling
		azote
		bumblebee-status
		i3-gaps
		i3blocks
		xss-lock
		j4-dmenu-desktop
		nitrogen
		dex
		xfce4-screenshooter
		font-awesome
		Thunar
		rofi
		feh
		picom
		flameshot
		polybar
	)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_mango_meta_package() {
	local DE='Mango'
	local apkgs=(voidbr-mango)
	apkgs+=(voidbr-base-config)
	apkgs+=(voidbr-mango-config)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_sway_meta_package() {
	local DE='Sway'
	local apkgs=(voidbr-sway)
	apkgs+=(voidbr-base-config)
	apkgs+=(voidbr-sway-config)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_hyprland_meta_package() {
	local DE='hyprland'
	local apkgs=(voidbr-hyprland)
	apkgs+=(voidbr-base-config)
	apkgs+=(voidbr-hyprland-config)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_river_minimal() {
	local DE='river'
	local apkgs=(river yambar fuzzel voidbr-river-config)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_mate_minimal() {
	local DE='Mate'
	local apkgs=(mate
		mate-applets
		mate-common
		mate-extra
		mate-backgrounds
		mate-calc
		mate-icon-theme-faenza
		mate-media
		mate-netbook
		mate-power-manager
		mate-screensaver
		mate-sensors-applet
		mate-system-monitor
		mate-terminal
		mate-utils
		atril
		caja-image-converter
		caja-open-terminal
		caja-sendto
		caja-share
		caja-wallpaper
		caja-xattr-tags
		engrampa
		eom
		mozo
		pluma
	)

	if $LCUSTOM; then
		apkgs+=(
			plank
			brisk-menu
			voidbr-mate-config
		)

		sh_common_theme
	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_twm_minimal() {
	local DE='TWM'
	local apkgs=('twm')

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_awesome_minimal() {
	local DE='Awesome'
	local apkgs=(awesome polybar pcmanfm font-awesome)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_bspwm_minimal() {
	local DE='Bspwm'
	local apkgs=(bspwm
		polybar
		sxhkd
		dunst
		flameshot
		picom
		feh
		dmenu
		lua
		wmctrl
		compton
		mpd
		font-weather-icons
		font-awesome5
		hsetroot
		lxappearance
		rofi
		gtk-engine-murrine
		gtk2-engines
	)

	if $LCUSTOM; then
		apkgs+=(
			chili-void-bspwm-skel
		)
	fi

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_dwm_minimal() {
	local DE='Dwm'
	local apkgs=(dwm)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_lxde_minimal() {
	local DE='Lxde'
	local apkgs=(lxde lxterminal lxrandr lxtask lxinput lxappearance)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_lxqt_minimal() {
	local DE='Lxqt'
	local apkgs=(lxqt)

	sh_install_pkgs_in_chroot "Instalando ${DE}" "${apkgs[*]}"
}

sh_make_bspwm_conf() {
	local user="${AsUser[cuser]}"
	shell='/bin/bash'

	sh_chroot_job "${cmsg_Configurando} Bspwm" "
      mkdir -p /home/$user/.config/{bspwm,polybar,sxhkd} &&
		cp -R /usr/share/doc/bspwm/examples/* /home/$user/.config/bspwm/ &&
		cp /usr/share/examples/polybar/config.ini /home/$user/.config/polybar/ &&
		cp /usr/share/doc/bspwm/examples/sxhkdrc /home/$user/.config/sxhkd/ &&
		echo '#!/usr/bin/env bash'  >> /home/$user/.config/polybar/launch.sh &&
		echo 'polybar-msg cmd quit' >> /home/$user/.config/polybar/launch.sh &&
		echo 'echo "---" | tee -a /tmp/polybar1.log /tmp/polybar2.log' >> /home/$user/.config/polybar/launch.sh &&
		echo 'polybar example 2>&1 | tee -a /tmp/polybar1.log & disown' >> /home/$user/.config/polybar/launch.sh &&
   	echo '~/.config/polybar/launch.sh' >> /home/$user/.config/bspwm/bspwmrc &&
    chmod +x /home/$user/.config/polybar/launch.sh &&
   	chown $user:$user /home/$user/.config -R
   " "$err_not_fatal"
}

sh_backup_partitions() {
	if [ $# -ge 2 ]; then
		local disk="${1}"
		local device="${2}"
		local tmpdir="/tmp/$_APP_"
		local cdatetime
		local filetmp

		cdatetime=$(sh_diahora)
		filetmp="$tmpdir/${device}.$cdatetime.dump"
		mkdir -p "$tmpdir" 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
		sfdisk -d "$disk" >"$filetmp" 2>/dev/null
		#  info "BACKUP DA TABELA DE PARTICOES"    \
		#         "Dispositivo : $disk"              \
		#         "  Backup on : ${filetmp}"         \
		#        "$(replicate "=" 80)"               \
		#         "$(cat $filetmp)"
	fi
}

sh_diahora() {
	DIAHORA=$(date +"%d%m%Y-%T" | sed 's/://g')
	printf "%s\n" "$DIAHORA"
}

sh_rtrim() {
	local str="$1"
	echo "${str%%' '}"
}

sh_vg_info() {
	unset ARRAY_VG_{NAME,SIZE,FREE,ATTR}
	local {NAME,SIZE,FREE,ATTR}_

	mensagem "=== VG ===" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... coletando informações")"
	AARRAY_VG_DEVICES=()
	while read -r line; do
		eval "${line//=/_=}"
		ARRAY_VG_NAME+=("$NAME_")
		ARRAY_VG_SIZE+=("$SIZE_")
		ARRAY_VG_FREE+=("$FREE_")
		ARRAY_VG_ATTR+=("$ATTR_")
		AARRAY_VG_DEVICES+=(["$NAME_"]="$NAME_|$SIZE_|$FREE_|$ATTR_")
	done < <(vgs --noheadings --units G -o vg_name,vg_size,vg_free,vg_attr | awk '/^ *[[:alnum:]]+ / {print "NAME=\"" $1 "\"", "SIZE=\"" $2 "\"", "FREE=\"" $3 "\"", "ATTR=\"" $4 "\""}' | sort -k1,1 -k2,2)
}

sh_disk_info() {
	unset ARRAY_DSK_{DISKS,DEVICES,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE}
	local {TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE}_

	mensagem "$(gettext "=== DISCO ===")" "\n\n${BOLD}${WHITE}$(gettext 'Aguarde... coletando informações')"

	AARRAY_DSK_DEVICES=()

	while IFS= read -r line; do
		unset TYPE_ NAME_ PATH_ SIZE_ TRAN_ MODEL_ LABEL_ SERIAL_ PTTYPE_ FSTYPE_

		eval "${line//=/_=}"

		ARRAY_DSK_DISKS+=("$NAME_")
		ARRAY_DSK_DEVICES+=("$PATH_")
		ARRAY_DSK_SIZE+=("$SIZE_")
		ARRAY_DSK_TRAN+=("${TRAN_:-${TYPE_}}")
		ARRAY_DSK_MODEL+=("${MODEL_:-${TYPE_} device}")
		ARRAY_DSK_LABEL+=("${LABEL_:-""}")
		ARRAY_DSK_SERIAL+=("${SERIAL_:-""}")
		ARRAY_DSK_PTTYPE+=("${PTTYPE_:-""}")
		ARRAY_DSK_FSTYPE+=("${FSTYPE_:-none}")
		AARRAY_DSK_DEVICES["$PATH_"]="$NAME_|$SIZE_|${TRAN_:-${TYPE_}}|${MODEL_:-unknown}|${LABEL_:-""}|${SERIAL_:-""}|${PTTYPE_:-""}|${FSTYPE_:-none}"
	done < <(
		lsblk -PAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE |
			grep -P 'TYPE="(disk|loop|lvm)"' |
			grep -Pv 'NAME=".*(_tdata|-data|_tmeta|-tpool)"' |
			awk -F'"' '!seen[$6]++'
	)
	#	done < <(lsblk -PAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE | grep -P 'TYPE="(disk|loop|lvm)"' | sort -k5,5 -k2,2)
}

sh_disk_part_info() {
	unset ARRAY_DSK_{DISKS,DEVICES,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE}
	unset ARRAY_PART_{DISKS,DEVICES,SIZE,TRAN,MODEL,LABEL,SERIAL,FSTYPE,PARTTYPENAME}
	local {NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE,PARTTYPENAME}_

	mensagem "$(gettext "=== DISCO/PARTIÇÃO ===")" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... coletando informações")"
	AARRAY_DSK_DEVICES=()
	AARRAY_PART_DEVICES=()
	while read -r line; do
		eval "${line//=/_=}"
		if [[ "${TYPE_}" != "part" ]]; then
			ARRAY_DSK_DISKS+=("$NAME_")
			ARRAY_DSK_DEVICES+=("$PATH_")
			ARRAY_DSK_SIZE+=("$SIZE_")
			ARRAY_DSK_TRAN+=("${TRAN_:-${TYPE_}}")
			ARRAY_DSK_MODEL+=("${MODEL_:-${TYPE_} device}")
			ARRAY_DSK_LABEL+=("${LABEL_:-""}")
			ARRAY_DSK_SERIAL+=("${SERIAL_:-""}")
			ARRAY_DSK_PTTYPE+=("${PTTYPE_:-""}")
			ARRAY_DSK_FSTYPE+=("${FSTYPE_:-none}")
			ARRAY_DSK_PARTTYPENAME+=("${PARTTYPENAME_:-none}")
			AARRAY_DSK_DEVICES+=(["$PATH_"]="$NAME_|$SIZE_|${TRAN_:-${TYPE_}}|${MODEL_:-unknown}|${LABEL_:-""}|${SERIAL_:-""}|${PTTYPE_:-""}|${FSTYPE_:-"none"}|${PARTTYPENAME_:-none}")
		fi
		if [[ "${TYPE_}" = "part" ]]; then
			[[ "$FSTYPE_" = "iso9660" ]] && continue
			#		[[ "$FSTYPE_" = "crypto_LUKS" ]] && continue
			#		[[ "$FSTYPE_"  = "LVM2_member" ]] && continue
			ARRAY_PART_DISKS+=("$NAME_")
			ARRAY_PART_DEVICES+=("$PATH_")
			ARRAY_PART_SIZE+=("$SIZE_")
			ARRAY_PART_TRAN+=("${TRAN_:-${TYPE_}}")
			ARRAY_PART_MODEL+=("${MODEL_:-unknown}")
			ARRAY_PART_LABEL+=("${LABEL_:-""}")
			ARRAY_PART_SERIAL+=("${SERIAL_:-""}")
			ARRAY_PART_FSTYPE+=("${FSTYPE_:-none}")
			ARRAY_PART_PARTTYPENAME+=("${PARTTYPENAME_:-none}")
			AARRAY_PART_DEVICES+=(["$PATH_"]="$NAME_|$SIZE_|${TRAN_:-${TYPE_}}|${MODEL_:-unknown}|${LABEL_:-""}|${SERIAL_:-""}|${FSTYPE_:-"none"}|${PARTTYPENAME_:-none}")
		fi
	done < <(lsblk -PAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE,PARTTYPENAME |
		grep -P 'TYPE="(disk|loop|lvm|part)"' |
		grep -Pv 'NAME=".*(_tdata|-data|_tmeta|-tpool)"' |
		sort -u -t'"' -k6,6)
	#  	done < <(lsblk -PAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE,FSTYPE,PARTTYPENAME | grep -P 'TYPE="(disk|loop|lvm|part)"' | sort -k5,5 -k2,2)
}

sh_part_info() {
	unset ARRAY_PART_{DISKS,DEVICES,SIZE,TRAN,MODEL,LABEL,SERIAL,FSTYPE,PARTTYPENAME}
	local {NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,FSTYPE,PARTTYPENAME}_

	mensagem "$(gettext "=== PARTIÇÃO ===")" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... coletando informações")"
	AARRAY_PART_DEVICES=()
	while read -r line; do
		eval "${line//=/_=}"
		[[ "$FSTYPE_" = "iso9660" ]] && continue
		#		[[ "$FSTYPE_" = "crypto_LUKS" ]] && continue
		[[ "$FSTYPE_" = "LVM2_member" ]] && continue
		ARRAY_PART_DISKS+=("$NAME_")
		ARRAY_PART_DEVICES+=("$PATH_")
		ARRAY_PART_SIZE+=("$SIZE_")
		ARRAY_PART_TRAN+=("${TRAN_:-${TYPE_}}")
		ARRAY_PART_MODEL+=("${MODEL_:-unknown}")
		ARRAY_PART_LABEL+=("${LABEL_:-""}")
		ARRAY_PART_SERIAL+=("${SERIAL_:-""}")
		ARRAY_PART_FSTYPE+=("${FSTYPE_:-none}")
		ARRAY_PART_PARTTYPENAME+=("${PARTTYPENAME_:-none}")
		AARRAY_PART_DEVICES+=(["$PATH_"]="$NAME_|$SIZE_|${TRAN_:-${TYPE_}}|${MODEL_:-unknown}|${LABEL_:-""}|${SERIAL_:-""}|${FSTYPE_:-"none"}|${PARTTYPENAME_:-none}")
	done < <(
		lsblk -PAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,PTTYPE |
			grep -P 'TYPE="(part)"' |
			grep -Pv 'NAME=".*(_tdata|_tmeta|-tpool)"' |
			awk -F'"' '!seen[$6]++'
	)
	#	done < <(lsblk -fPAo TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,FSTYPE,PARTTYPENAME | grep -P 'TYPE="(part)"' | sort -k5,5 -k2,2)
}

sh_check_disk_health() {
	local disk="$1"
	local msg

	AConfDisk[_HEALTH]="$disk"
	[[ -b "$disk" ]] || {
		if [[ -z "$1" ]]; then
			msg="\n${BOLD}${RED}$(gettext 'Necessário escolher um dispositivo para TESTAR')${RESET}"
		else
			msg="\n${BOLD}${RED}$(gettext 'Dispositivo inválido'): ${CYAN}${disk}${RESET}"
		fi
		if conf "=== ERRO ===" \
			"${msg}\n\n${YELLOW}$(gettext 'Deseja escolher agora?')"; then
			if ! sh_choose_disk "${cmsg_DiskHealth}"; then
				return 1
			fi

			disk="${AConfDisk[_HEALTH]}"
		else
			return 2
		fi
	}

	sh_info_msg "$(gettext 'Testando saude do disco'): ${CYAN}${disk}${RESET}"

	local model serial size tran pttype=""
	# Dois status independentes em vez de um único: ESTRUTURA (tabela de
	# partição, GPT/MBR, blkid, wipefs) e HARDWARE (SMART, dmesg). Um
	# disco novo/zerado (sem tabela) é aviso de ESTRUTURA, nunca defeito
	# de HARDWARE — só SMART e dmesg indicam problema físico real. O
	# valor retornado pela função continua sendo o maior dos dois, para
	# preservar o contrato 0=ok/1=aviso/2=crítico já usado pelos
	# chamadores desta função.
	local st_estrutura=0 st_hardware=0
	local report=""
	local errors=""
	local smart="Não disponível"

	model=$(lsblk -dn -o MODEL "$disk" 2>/dev/null | xargs)
	serial=$(lsblk -dn -o SERIAL "$disk" 2>/dev/null | xargs)
	size=$(lsblk -dn -o SIZE "$disk" 2>/dev/null | xargs)
	tran=$(lsblk -dn -o TRAN "$disk" 2>/dev/null | xargs)
	pttype=$(lsblk -dn -o PTTYPE "$disk" 2>/dev/null | xargs)

	report+="Disco.............: ${CYAN}$disk${RESET}\n"
	report+="Modelo............: ${CYAN}${model:-Desconhecido}${RESET}\n"
	report+="Serial............: ${CYAN}${serial:-N/A}${RESET}\n"
	report+="Tamanho...........: ${CYAN}$size${RESET}\n"
	report+="Interface.........: ${CYAN}${tran:-N/A}${RESET}\n\n"

	# --------------------------------------------------------
	# Tabela de Partições (GPT / MBR / DOS)   [categoria: ESTRUTURA]
	# --------------------------------------------------------
	# LC_ALL=C força a saída do fdisk em inglês independente do locale
	# do sistema. O grep antigo procurava "Tipo de rótulo do disco: ..."
	# (pt_BR), mas o fdisk só imprime nesse idioma se o SISTEMA (não só
	# este script) estiver de fato em locale pt_BR instalado — em
	# qualquer outro caso (padrão de live-CD/ISO de instalação, que
	# tipicamente roda em locale C/POSIX) o grep nunca batia, e um disco
	# GPT/MBR perfeitamente saudável caía no "else" como "Não detectada"
	# -> status crítico (falso defeito).
	if [[ -z "$pttype" ]]; then
		if LC_ALL=C fdisk -l "$disk" 2>/dev/null | grep -qi "Disklabel type: gpt"; then
			pttype="gpt"
			report+="Tabela............: ${YELLOW}GPT (lsblk não detectou)${RESET}\n"
			report+="Aviso.............: ${YELLOW}libblkid falhou ao detectar GPT; usado fallback via fdisk.${RESET}\n"
			((st_estrutura < 1)) && st_estrutura=1
		elif LC_ALL=C fdisk -l "$disk" 2>/dev/null | grep -qi "Disklabel type: dos"; then
			pttype="dos"
			report+="Tabela............: ${GREEN}DOS/MBR${RESET}\n"
		else
			# Disco sem tabela nenhuma (novo ou recém-zerado) é um
			# ESTADO, não um defeito de hardware — não deve subir a
			# status crítico.
			report+="Tabela............: ${YELLOW}Não detectada (disco sem partições?)${RESET}\n"
			((st_estrutura < 1)) && st_estrutura=1
		fi
	else
		report+="Tabela............: ${GREEN}${pttype^^}${RESET}\n"
	fi

	# --------------------------------------------------------
	# Validação de Headers (GPT vs MBR/DOS)   [categoria: ESTRUTURA]
	# --------------------------------------------------------
	# Antes, o teste de assinatura GPT rodava incondicionalmente mesmo
	# em disco MBR saudável (a busca por "EFI PART" sempre falhava nesse
	# caso, marcando um disco perfeito como defeituoso). Agora só roda
	# se a tabela for GPT, e o MBR ganha uma checagem própria e real
	# (0x55AA), em vez de nenhuma verificação.
	case "${pttype,,}" in
	gpt)
		# Tamanho de setor lógico real via blockdev --getss (não fixo
		# em 512), para não dar falso-negativo em discos 4Kn. blockdev
		# --getsz sempre devolve em unidades de 512 bytes, por isso a
		# conversão para o número de setores lógicos antes de calcular
		# o offset do backup. A comparação "EFI PART" via head -c 8
		# elimina a dependência de "strings" (binutils, que não estava
		# nem em DEPENDENCIES): se ausente, os dois testes falhavam e
		# o disco virava "defeituoso" sem motivo real.
		local ss sectors512 logical_sectors sig
		ss=$(blockdev --getss "$disk" 2>/dev/null)
		ss="${ss:-512}"
		sectors512=$(blockdev --getsz "$disk" 2>/dev/null)
		logical_sectors=$((sectors512 * 512 / ss))

		sig=$(dd if="$disk" bs="$ss" skip=1 count=1 status=none 2>/dev/null | head -c 8)
		if [[ "$sig" == "EFI PART" ]]; then
			report+="GPT Primária......: ${GREEN}OK${RESET}\n"
		else
			report+="GPT Primária......: ${RED}FALHOU${RESET}\n"
			st_estrutura=2
		fi

		if ((logical_sectors > 0)); then
			sig=$(dd if="$disk" bs="$ss" skip=$((logical_sectors - 1)) count=1 status=none 2>/dev/null | head -c 8)
			if [[ "$sig" == "EFI PART" ]]; then
				report+="GPT Backup........: ${GREEN}OK${RESET}\n"
			else
				report+="GPT Backup........: ${RED}FALHOU${RESET}\n"
				((st_estrutura < 2)) && st_estrutura=1
			fi
		fi
		;;
	dos | mbr)
		local mbr_sig
		mbr_sig=$(dd if="$disk" bs=1 skip=510 count=2 status=none 2>/dev/null | od -An -tx1 | tr -d ' \n')
		if [[ "$mbr_sig" == "55aa" ]]; then
			report+="Assinatura MBR....: ${GREEN}OK (0x55AA)${RESET}\n"
		else
			report+="Assinatura MBR....: ${RED}FALHOU${RESET}\n"
			st_estrutura=2
		fi
		;;
	esac

	# --------------------------------------------------------
	# blkid — rc=2 significa "sem assinatura" (disco vazio), não é erro.
	# Só rc>2 é falha de verdade. LC_ALL=C evita o mesmo problema de
	# locale do fdisk acima, já que "Permission denied" também é
	# traduzido pela glibc via LC_MESSAGES quando o pacote de locale
	# está instalado.   [categoria: ESTRUTURA]
	# --------------------------------------------------------
	local blkid_rc blkid_err
	blkid_err=$(LC_ALL=C blkid -p "$disk" 2>&1 >/dev/null)
	blkid_rc=$?
	case "$blkid_rc" in
	0) report+="blkid.............: ${GREEN}OK${RESET}\n" ;;
	2) report+="blkid.............: ${GREEN}Sem assinatura detectada${RESET}\n" ;;
	*)
		if grep -qiE "permission denied|operation not permitted" <<<"$blkid_err"; then
			report+="blkid.............: ${YELLOW}Sem permissão para verificar (ambiente restrito?)${RESET}\n"
		else
			report+="blkid.............: ${RED}FALHOU (rc=$blkid_rc)${RESET}\n"
		fi
		((st_estrutura < 1)) && st_estrutura=1
		;;
	esac

	# --------------------------------------------------------
	# wipefs -n (somente consulta; sem -a ele já não apaga nada, mas -n
	# deixa a intenção explícita no código de um instalador rodando
	# como root).   [categoria: ESTRUTURA]
	# --------------------------------------------------------
	local wipefs_err
	wipefs_err=$(LC_ALL=C wipefs -n "$disk" 2>&1 >/dev/null)
	if [[ -z "$wipefs_err" ]]; then
		report+="wipefs (consulta).: ${GREEN}OK${RESET}\n"
	else
		if grep -qiE "permission denied|operation not permitted" <<<"$wipefs_err"; then
			report+="wipefs (consulta).: ${YELLOW}Sem permissão para verificar (ambiente restrito?)${RESET}\n"
		else
			report+="wipefs (consulta).: ${RED}FALHOU${RESET}\n"
		fi
		((st_estrutura < 1)) && st_estrutura=1
	fi

	# --------------------------------------------------------
	# SMART (opcional)   [categoria: HARDWARE]
	# --------------------------------------------------------
	# Tenta detecção automática, depois -d sat e -d scsi: em muitas
	# pontes USB o smartctl sem -d não retorna nada, mesmo com o disco
	# saudável.
	if command -v smartctl >/dev/null; then
		local smart_dtype="" smart_probe
		for smart_dtype in "" "-d sat" "-d scsi"; do
			smart_probe=$(smartctl -H $smart_dtype "$disk" 2>/dev/null | awk -F: '/overall-health|SMART overall-health|SMART Health Status/ {
				gsub(/^[ \t]+/, "", $2)
				print $2
			}' | xargs)
			[[ -n "$smart_probe" ]] && {
				smart="$smart_probe"
				break
			}
		done

		[[ -z "$smart" || "$smart" == "Não disponível" ]] && smart="Indisponível (USB pode exigir -d sat)"
		report+="SMART.............: $smart\n"

		if echo "$smart" | grep -qiE 'FAILED|BAD'; then
			st_hardware=2
		fi

		if [[ "${tran,,}" == "nvme" ]]; then
			# NVMe não usa a tabela de atributos numerados do ATA/SATA
			# — os IDs abaixo simplesmente não existem nesse formato.
			# smartctl -a em NVMe imprime um log de saúde com campos
			# próprios; estes são os equivalentes mais próximos de
			# "degradação real".
			local nvme_out crit_warn pct_used media_errors avail_spare avail_thresh
			nvme_out=$(smartctl -a "$disk" 2>/dev/null)

			crit_warn=$(awk -F: '/Critical Warning/ {gsub(/^[ \t]+/,"",$2); print $2}' <<<"$nvme_out" | head -1)
			pct_used=$(awk -F: '/Percentage Used/ {gsub(/[^0-9]/,"",$2); print $2}' <<<"$nvme_out" | head -1)
			media_errors=$(awk -F: '/Media and Data Integrity Errors/ {gsub(/[^0-9]/,"",$2); print $2}' <<<"$nvme_out" | head -1)
			avail_spare=$(awk -F: '/^Available Spare:/ {gsub(/[^0-9]/,"",$2); print $2}' <<<"$nvme_out" | head -1)
			avail_thresh=$(awk -F: '/Available Spare Threshold/ {gsub(/[^0-9]/,"",$2); print $2}' <<<"$nvme_out" | head -1)

			if [[ -n "$crit_warn" ]]; then
				if [[ "$crit_warn" != "0x00" && "$crit_warn" != "0" ]]; then
					report+="  Critical Warning..........: ${RED}${crit_warn}${RESET}\n"
					st_hardware=2
				else
					report+="  Critical Warning..........: ${GREEN}${crit_warn}${RESET}\n"
				fi
			fi

			if [[ "$pct_used" =~ ^[0-9]+$ ]]; then
				if ((pct_used >= 90)); then
					report+="  Percentage Used...........: ${RED}${pct_used}%${RESET}\n"
					((st_hardware < 2)) && st_hardware=2
				elif ((pct_used >= 70)); then
					report+="  Percentage Used...........: ${YELLOW}${pct_used}%${RESET}\n"
					((st_hardware < 1)) && st_hardware=1
				else
					report+="  Percentage Used...........: ${GREEN}${pct_used}%${RESET}\n"
				fi
			fi

			if [[ "$media_errors" =~ ^[0-9]+$ ]]; then
				if [[ "$media_errors" != "0" ]]; then
					report+="  Media/Integrity Errors....: ${RED}${media_errors}${RESET}\n"
					st_hardware=2
				else
					report+="  Media/Integrity Errors....: ${GREEN}0${RESET}\n"
				fi
			fi

			if [[ "$avail_spare" =~ ^[0-9]+$ && "$avail_thresh" =~ ^[0-9]+$ ]]; then
				if ((avail_spare <= avail_thresh)); then
					report+="  Available Spare...........: ${RED}${avail_spare}% (limite ${avail_thresh}%)${RESET}\n"
					((st_hardware < 2)) && st_hardware=2
				else
					report+="  Available Spare...........: ${GREEN}${avail_spare}%${RESET}\n"
				fi
			fi
		else
			# ATA/SATA: tabela de atributos numerados. Indicam
			# degradação real mesmo com -H "PASSED" — um disco pode ter
			# centenas de setores realocados e ainda "passar" no teste
			# de saúde geral, que só falha perto do fim da vida útil.
			local attr_id attr_name attr_raw attr_color
			for attr_id in 5 187 197 198; do
				case "$attr_id" in
				5) attr_name="Setores realocados......" ;;
				187) attr_name="Erros não corrigidos....." ;;
				197) attr_name="Setores pendentes........" ;;
				198) attr_name="Setores incorrig. offline" ;;
				esac
				attr_raw=$(smartctl -A $smart_dtype "$disk" 2>/dev/null | awk -v id="$attr_id" '$1==id {print $NF}')
				[[ -z "$attr_raw" ]] && continue
				if [[ "$attr_raw" != "0" ]]; then
					attr_color="${YELLOW}"
					((st_hardware < 1)) && st_hardware=1
				else
					attr_color="${GREEN}"
				fi
				report+="  ${attr_name}: ${attr_color}${attr_raw}${RESET}\n"
			done
		fi
	else
		report+="SMART.............: Não instalado\n"
	fi

	# --------------------------------------------------------
	# dmesg — regex ancorada (\b...\b) para "sda" não casar com "sda1"
	# ou "sdaa"; grep -q para não vazar o match bruto por cima da tela.
	#   [categoria: HARDWARE]
	# --------------------------------------------------------
	local dev
	dev=$(basename "$disk")
	errors=$(dmesg | grep -E "\b${dev}[0-9]*\b" | tail -5)

	if [[ -n "$errors" ]]; then
		report+="\n${CYAN}Erros recentes:${RESET}\n"
		report+="${YELLOW}$errors${RESET}\n"
		if grep -qiE "I/O error|Buffer I/O|blk_update_request|critical medium error|end_request" <<<"$errors"; then
			((st_hardware < 2)) && st_hardware=2
		fi
	fi

	# --------------------------------------------------------
	# Status Final — dois status independentes
	# --------------------------------------------------------
	local final_status=$st_estrutura
	((st_hardware > final_status)) && final_status=$st_hardware

	report+="\n"
	case "$st_estrutura" in
	0) report+="${GREEN}ESTRUTURA: OK${RESET}\n" ;;
	1) report+="${YELLOW}ESTRUTURA: AVISOS ENCONTRADOS${RESET}\n" ;;
	2) report+="${RED}ESTRUTURA: POSSÍVEIS DEFEITOS${RESET}\n" ;;
	esac
	case "$st_hardware" in
	0) report+="${GREEN}HARDWARE.: OK${RESET}" ;;
	1) report+="${YELLOW}HARDWARE.: AVISOS ENCONTRADOS${RESET}" ;;
	2) report+="${RED}HARDWARE.: POSSÍVEIS DEFEITOS${RESET}" ;;
	esac

	${DIALOG} \
		--colors \
		--scrollbar \
		--backtitle "$ccabec" \
		--title "Diagnóstico do Disco" \
		--msgbox "$report" \
		00 00

	return "$final_status"
}

set_custom_install() {
	local ctitle="$1"

	if conf "${ctitle}" \
		"\n${BOLD}${WHITE}$(gettext "Uma instalação customizada irá instalar pacotes extras e também")" \
		"\n$(gettext "fazer diversas configurações, evitando faze-las manualmente posteriormente.")\n" \
		"\n${BOLD}${RED}$(gettext "Customizar a instalação?")\n\n"; then
		LCUSTOM=true
		sh_choose_custom_packages
	else
		LCUSTOM=false
	fi
}

sh_getIso() {
	if test -e '/run/initramfs/live/LiveOS/squashfs.img'; then
		return 0
	fi
	return 1
}

sh_chooseSource() {
	local -A Asource
	local -A Aflag
	local cextra
	local exit_status
	local array=()
	local x
	local _src

	Asource["local"]="${cmsg_PacotesDaImagemIso}"
	Asource["network"]="${cmsg_BaixadoDoRepositorioOficial}"
	Asource["networkFull"]="${cmsg_BaixadoDoRepositorioOficialFull}"
	cextra="${cmsg_ExtraNotIso}"

	_src=${AConfMirror[_SOURCE]}
	for x in "${!Asource[@]}"; do
		if [[ $_src = $x ]]; then
			Aflag[$x]='on'
		else
			Aflag[$x]='off'
		fi
		if sh_getIso; then
			cextra="${cmsg_ExtraIso}"
		else
			if ! sh_checkcommand "${XBPS_INSTALL_CMD}"; then
				cextra="${cmsg_ExtraNotIso}\n${cmsg_ExtraNotHostVoid}"
			else
				cextra="${cmsg_ExtraNotIso}"
			fi
		fi
		array+=("$x" "${Asource[$x]}" "${Aflag[$x]}")
	done

	while true; do
		src=$(${DIALOG} --title "=== ${cmsg_Source^^} ===" \
			--default-item "${AConfMirror[_SOURCE]}" \
			--stdout \
			--colors \
			--cancel-label "${cmsg_ButtonBack}" \
			--ok-label "${cmsg_Aceitar}" \
			--radiolist "${cmsg_MENU}\n\n$cextra" \
			12 0 0 "${array[@]}")

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			return 1
			;;
		"$D_OK")
			#dom 03 mar 2024 17:00:23 -04
			if [[ "$src" = "networkFull" ]]; then
				if ! sh_checkcommand "${XBPS_INSTALL_CMD}"; then
					alerta "=== ${cmsg_Source^^} ===" \
						"\n${BOLD}$(gettext "Aparentemente, o VOID Linux NÃO está sendo usado como host.\nEscolha network ou ISO")"
					continue
				fi
			fi
			if [[ "$src" = "local" ]]; then
				if ! sh_getIso; then
					info "$ccabec" "\n\n$cextra"
					continue
				else
					alerta "=== ${cmsg_Source^^} ===" \
						"$(gettext "Ao escolher ${CYAN}local${RESET} e usar a ${YELLOW}ISO oficial do Void${RESET}, \ntenha em mente que a ISO ${RED}tem pacotes desatualizados${RESET}, \ne será necessário atualizar pela internet.\n\nTalvez seja melhor escolher network ou networkfull!\n")"
					LSOURCE=true
					AConfMirror[_SOURCE]=$src
					_WINDOWMANAGER=('tty' 'local')
					LONLY_TTY=false
					set_custom_install "=== ${cmsg_Source^^} ==="
				fi
			fi
			;;
		esac
		LSOURCE=true
		AConfMirror[_SOURCE]=$src
		return 0
	done
}

sh_choose_fstype() {
	local oldfstype="$1"
	local xtitle="$2"
	declare -A Afs
	declare -A Aflag
	local cextra
	local cnewmenu
	local exit_status
	local array=()
	local x

	Afs[xfs]="SGI's XFS"
	#	Afs[reiserfs]="Linux Reiserfs"
	Afs[jfs]="Linux Jfs"
	Afs[f2fs]="Flash-Friendly Filesystem"
	Afs[ext3]="Linux ext3 (journal)"
	Afs[ext2]="Linux ext2 (no journaling)"
	Afs[btrfs]="Oracle Btrfs"
	Afs[ext4]="Linux ext4 (journal)"
	Afs[vfat]="FAT32 (EFI)"
	Afs[swap]="Linux swap"
	Afs[ntfs]="Microsoft NTFS (ntfs-3g) (not for root '/')"
	Afs[nilfs2]="A log-structured file system supporting continuous snapshotting"

	if [[ -z "$oldfstype" ]]; then
		oldfstype=${AConfDisk[_FILESYSTEM]}
	fi

	for x in "${!Afs[@]}"; do
		[[ "$oldfstype" = "$x" ]] && Aflag[$x]='on' || Aflag[$x]='off'
		array+=("$x" "${Afs[$x]}" "${Aflag[$x]}")
	done

	cextra="${cmsg_mkfs}"
	cnewmenu="${xtitle:-${cmsg_MENU}}"
	mkfs=$(${DIALOG} \
		--title "${cmsg_TitleFileSystem}" \
		--default-item "$oldfstype" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cnewmenu}\n\n$cextra" \
		24 0 2 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	esac
	LFS=true
	AConfDisk[_FILESYSTEM]="$mkfs"
	return 0
}

sh_choose_audioserver() {
	local exit_status
	local array=()
	local x
	local caudio

	if ! $LONLY_TTY; then
		case "${AConfAudio[_AUDIOSERVER]:-Pipewire}" in
		Pulseaudio)
			array+=("Pulseaudio" "Pulseaudio" "on")
			array+=("Pipewire" "Pipewire" "off")
			array+=("None" "None" "off")
			;;
		Pipewire)
			array+=("Pulseaudio" "Pulseaudio" "off")
			array+=("Pipewire" "Pipewire" "on")
			array+=("None" "None" "off")
			;;
		None)
			array+=("Pulseaudio" "Pulseaudio" "off")
			array+=("Pipewire" "Pipewire" "off")
			array+=("None" "None" "on")
			;;
		esac
	else
		array+=("Pulseaudio" "Pulseaudio" "off")
		array+=("Pipewire" "Pipewire" "off")
		array+=("None" "None" "on")
	fi

	caudio=$(${DIALOG} \
		--title "${cmsg_DefinirAudioServer}" \
		--default-item "${AConfAudio[_AUDIOSERVER]}" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}\n\n$cextra" \
		12 70 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	esac
	if [[ "$caudio" == 'None' ]]; then
		LAUDIO=false
	else
		LAUDIO=true
	fi
	AConfAudio[_AUDIOSERVER]="$caudio"
	return 0
}

sh_choose_kernel() {
	local exit_status
	local array=()
	local x
	local ckernel
	local current_kernel="${AConfKernel[_KERNEL]:-linux}"

	array+=("linux" "Linux kernel and modules current default" "$([[ $current_kernel == linux ]] && echo on || echo off)")
	array+=("linux7.2" "Linux kernel and modules (7.2 series) stable" "$([[ $current_kernel == linux7.2 ]] && echo on || echo off)")
	array+=("linux7.1" "Linux kernel and modules (7.1 series) stable" "$([[ $current_kernel == linux7.1 ]] && echo on || echo off)")
	array+=("linux7.0" "Linux kernel and modules (7.0 series) stable" "$([[ $current_kernel == linux7.0 ]] && echo on || echo off)")
	array+=("linux6.19" "Linux kernel and modules (6.19 series) stable" "$([[ $current_kernel == linux6.19 ]] && echo on || echo off)")
	array+=("linux6.18" "Linux kernel and modules (6.18 series) LTS" "$([[ $current_kernel == linux6.18 ]] && echo on || echo off)")
	array+=("linux6.12" "Linux kernel and modules (6.12 series) LTS" "$([[ $current_kernel == linux6.12 ]] && echo on || echo off)")
	array+=("linux6.6" "Linux kernel and modules (6.6 series) LTS" "$([[ $current_kernel == linux6.6 ]] && echo on || echo off)")
	array+=("linux6.1" "Linux kernel and modules (6.1 series) LTS" "$([[ $current_kernel == linux6.1 ]] && echo on || echo off)")
	array+=("linux5.15" "Linux kernel and modules (5.15 series) LTS" "$([[ $current_kernel == linux5.15 ]] && echo on || echo off)")
	array+=("linux5.10" "Linux kernel and modules (5.10 series) LTS" "$([[ $current_kernel == linux5.10 ]] && echo on || echo off)")

	ckernel=$(${DIALOG} \
		--title "${cmsg_descKernel}" \
		--default-item "${current_kernel}" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}\n\n$cextra" \
		12 00 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?

	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	esac

	LKERNEL=true
	AConfKernel[_KERNEL]="$ckernel"
	return 0
}

sh_choose_bootloadernew() {
	local exit_status
	local array=()
	local x
	local cloader
	local current_loader="${AConfBootLoader[_LOADER]:-grub}"

	array+=("grub" "$(gettext 'GRand Unified Bootloader 2 (recomendado')" "$([[ $current_loader == grub ]] && echo on || echo off)")
	array+=("limine" "$(gettext 'Modern, secure, portable, multiprotocol bootloader and boot manager')" "$([[ $current_loader == limine ]] && echo on || echo off)")

	cloader=$(${DIALOG} \
		--title "${cmsg_descBootLoader}" \
		--default-item "${current_loader}" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}\n\n$cextra" \
		12 00 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?

	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	esac

	LLOADER=true
	AConfBootLoader[_LOADER]="$cloader"

  sh_chooseBootLoader

	return 0
}

sh_timedatectl() {
	local _localtime

	if [[ -n $(command -v timedatectl) ]]; then
		_localtime=$(awk '{print $3}' <(grep 'Time zone' <(timedatectl)))
		if [[ -n "$_localtime" ]]; then
			echo "$_localtime"
			return 0
		fi
	else
		_localtime=$(cut -d'"' -f2 <(grep TIMEZONE /etc/rc.conf))
		if [[ -n "$_localtime" ]]; then
			echo "$_localtime"
			return 0
		fi
	fi
	return 1
}

sh_chooseLocale() {
	local locale
	local selected
	local desc
	local exit_status

	DEFITEM="${AConfLocale[_LOCALE]}"

	declare -A ISO639=(
		[pt]="Portuguese"
		[en]="English"
		[es]="Spanish"
		[fr]="French"
		[de]="German"
		[it]="Italian"
		[ja]="Japanese"
		[zh]="Chinese"
		[ru]="Russian"
		[ko]="Korean"
		[ar]="Arabic"
		[nl]="Dutch"
		[sv]="Swedish"
		[pl]="Polish"
		[tr]="Turkish"
		[uk]="Ukrainian"
		[cs]="Czech"
		[hu]="Hungarian"
		[fi]="Finnish"
		[da]="Danish"
		[no]="Norwegian"
		[el]="Greek"
		[he]="Hebrew"
		[hi]="Hindi"
		[bn]="Bengali"
		[ta]="Tamil"
		[th]="Thai"
		[vi]="Vietnamese"
	)

	declare -A ISO3166=(
		[BR]="Brazil"
		[PT]="Portugal"
		[US]="United States"
		[GB]="United Kingdom"
		[AR]="Argentina"
		[ES]="Spain"
		[FR]="France"
		[DE]="Germany"
		[IT]="Italy"
		[JP]="Japan"
		[CN]="China"
		[TW]="Taiwan"
		[RU]="Russia"
		[KR]="South Korea"
		[SA]="Saudi Arabia"
		[NL]="Netherlands"
		[SE]="Sweden"
		[PL]="Poland"
		[TR]="Turkey"
		[UA]="Ukraine"
		[CZ]="Czech Republic"
		[HU]="Hungary"
		[FI]="Finland"
		[DK]="Denmark"
		[NO]="Norway"
		[GR]="Greece"
		[IL]="Israel"
		[IN]="India"
		[BD]="Bangladesh"
		[TH]="Thailand"
		[VN]="Vietnam"
	)

	local LOCALES=(
		"pt_BR.UTF-8"
		"pt_PT.UTF-8"
		"en_US.UTF-8"
		"en_GB.UTF-8"
		"es_ES.UTF-8"
		"es_AR.UTF-8"
		"fr_FR.UTF-8"
		"de_DE.UTF-8"
		"it_IT.UTF-8"
		"ja_JP.UTF-8"
		"zh_CN.UTF-8"
		"zh_TW.UTF-8"
		"ru_RU.UTF-8"
		"ko_KR.UTF-8"
		"ar_SA.UTF-8"
		"nl_NL.UTF-8"
		"sv_SE.UTF-8"
		"pl_PL.UTF-8"
		"tr_TR.UTF-8"
		"uk_UA.UTF-8"
		"cs_CZ.UTF-8"
		"hu_HU.UTF-8"
		"fi_FI.UTF-8"
		"da_DK.UTF-8"
		"no_NO.UTF-8"
		"el_GR.UTF-8"
		"he_IL.UTF-8"
		"hi_IN.UTF-8"
		"bn_BD.UTF-8"
		"ta_IN.UTF-8"
		"th_TH.UTF-8"
		"vi_VN.UTF-8"
	)

	local MENU_ITEMS=()
	local LOC
	local LANG
	local COUNTRY
	local LANGNAME
	local COUNTRYNAME

	for LOC in "${LOCALES[@]}"; do
		LANG="${LOC%%_*}"

		COUNTRY="${LOC#*_}"
		COUNTRY="${COUNTRY%%.*}"

		LANGNAME="${ISO639[$LANG]:-$LANG}"
		COUNTRYNAME="${ISO3166[$COUNTRY]:-$COUNTRY}"

		MENU_ITEMS+=(
			"$LOC"
			"$LANGNAME $COUNTRYNAME"
		)
	done

	locale=$(
		${DIALOG} \
			--title "$(gettext 'Selecionar locale')" \
			--default-item "$DEFITEM" \
			--menu "$(gettext 'Escolha seu locale')" \
			20 70 18 \
			"${MENU_ITEMS[@]}" \
			2>&1 >/dev/tty
	)

	exit_status=$?

	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac

	selected="$locale"

	for ((i = 0; i < ${#MENU_ITEMS[@]}; i += 2)); do
		if [[ "${MENU_ITEMS[i]}" == "$selected" ]]; then
			desc="${MENU_ITEMS[i + 1]}"
			break
		fi
	done

	AConfLocale[_LOCALE]="$selected"
	AConfLocale[_REGION]="$desc"

	LLOCALE=true
}

sh_chooseTimezone() {
	local -A Atimezone
	local -A Aflag
	local array=()
	local _localtime
	local defaultitem
	local fields
	local timezone
	local sorted_list
	local exit_status
	local areas=('Africa' 'America' 'Antarctica' 'Arctic' 'Asia' 'Atlantic' 'Australia' 'Europe' 'Pacific' 'Brazil' 'Canada' 'Chile' 'Indian' 'Mexico')
	local locations
	local area

	for area in "${areas[@]}"; do
		read -r -a locations -d '\n' < <(find /usr/share/zoneinfo/"$area" -type f -printf '%P\n')
		for key in "${locations[@]}"; do
			Atimezone+=([$key]="$area/$key")
		done
	done

	[[ -z "${AConfLocale[_TIMEZONE]}" ]] && AConfLocale[_TIMEZONE]='America/Sao_Paulo'
	defaultitem="${AConfLocale[_TIMEZONE]#*/}"

	if ! $LTIMEZONE; then
		_localtime=$(sh_timedatectl) && defaultitem="${_localtime#*/}"
		if [[ -z "${Atimezone[$defaultitem]}" ]]; then
			Atimezone["$defaultitem"]="$_localtime"
		fi
	fi

	sorted_list=$(for key in "${!Atimezone[@]}"; do echo "$key|${Atimezone[$key]}"; done | sort -t\| -k2 -k1)
	while IFS='|' LC_ALL=C read -r -a fields; do
		x="${fields[0]}"
		Aflag[$x]='off'
		Aflag[$defaultitem]='on'
		array+=("$x" "${Atimezone[$x]}" "${Aflag[$x]}")
	done <<<"${sorted_list[@]}"

	timezone=$(${DIALOG} \
		--title "$(gettext "=== FUSO HORÁRIO ===")" \
		--default-item "$defaultitem" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}" \
		25 70 24 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac
	AConfLocale[_TIMEZONE]="${Atimezone[$timezone]}"
	LTIMEZONE=true
}

sh_choose_mirror() {
	declare -A Aflag
	local exit_status
	local array
	local sep="\xe2\x94\x82"
	local fields
	local key
	local sorted_list
	local -i FLD_MIRROR=0
	local -i FLD_REPOSITORY=1
	local -i FLD_REGION=2
	local -i FLD_LOCATION=3
	local -i FLD_TIER=4

	declare -gA Amirror=(
		#tier 1
		['repo.fi.voidlinux.org']="https://repo-fi.voidlinux.org/|Europe|Helsinki, Finland|1"
		['repo.de.voidlinux.org']="https://repo-de.voidlinux.org/|Europe|Frankfurt, Germany|1"
		['repo.fastly.voidlinux.org']="https://repo-fastly.voidlinux.org/|Globally Available|Fastly Global CDN|1"
		['mirrors.summithq.com']="https://mirrors.summithq.com/voidlinux/|North America|Chicago, USA|1"
		#tier 2
		['mirrors.servercentral.com']="https://mirrors.servercentral.com/voidlinux/|North America|Chicago, USA|2"
		['mirrors.cicku.me']="https://mirrors.cicku.me/voidlinux/|Globally Available|Cloudflare Global CDN|2"
		['mirror.nju.edu.cn']="https://mirror.nju.edu.cn/voidlinux/|Asia|China|2"
		['mirrors.bfsu.edu.cn']="https://mirrors.bfsu.edu.cn/voidlinux/|Asia|Beijing, China|2"
		['mirrors.tuna.tsinghua.edu.cn']="https://mirrors.tuna.tsinghua.edu.cn/voidlinux/|Asia|Beijing, China|2"
		['mirror.mmdbalkhi.ir']="https://mirror.mmdbalkhi.ir/void/|Asia|Tehran, Iran|2"
		['mirrors.kubarcloud.net']="https://mirrors.kubarcloud.net/voidlinux/|Asia|Tehran, Iran|2"
		['repo.jing.rocks']="https://repo.jing.rocks/voidlinux/|Asia|Tokyo, Japan|2"
		['mirror.freedif.org']="https://mirror.freedif.org/voidlinux/|Asia|Singapore|2"
		['mirror.heigou.pe.kr']="https://mirror.heigou.pe.kr/voidlinux/|Asia|South Korea|2"
		['mirror.meowsmp.net']="https://mirror.meowsmp.net/voidlinux/|Asia|Hanoi, Vietnam|2"
		['ftp.dk.xemacs.org']="http://ftp.dk.xemacs.org/voidlinux/|Europe|Denmark|2"
		['mirrors.dotsrc.org']="https://mirrors.dotsrc.org/voidlinux/|Europe|Denmark|2"
		['ftp.cc.uoc.gr']="https://ftp.cc.uoc.gr/mirrors/linux/voidlinux/|Europe|Greece|2"
		['voidlinux.mirror.garr.it']="https://voidlinux.mirror.garr.it/|Europe|Italy|2"
		['void.sakamoto.pl']="https://void.sakamoto.pl/|Europe|Warsaw, Poland|2"
		['ftp.debian.ru']="http://ftp.debian.ru/mirrors/voidlinux/|Europe|Russia|2"
		['mirror.yandex.ru']="https://mirror.yandex.ru/mirrors/voidlinux/|Europe|Russia|2"
		['ftp.lysator.liu.se']="https://ftp.lysator.liu.se/pub/voidlinux/|Europe|Sweden|2"
		['mirror.accum.se']="https://mirror.accum.se/mirror/voidlinux/|Europe|Sweden|2"
		['mirror.puzzle.ch']="https://mirror.puzzle.ch/voidlinux/|Europe|Bern, Switzerland|2"
		['mirror.vofr.net']="https://mirror.vofr.net/voidlinux/|North America|Virginia, USA|2"
		['mirrors.lug.mtu.edu']="https://mirrors.lug.mtu.edu/voidlinux/|North America|Michigan, USA|2"
		['mirror.aarnet.edu.au']="https://mirror.aarnet.edu.au/pub/voidlinux/|Oceania|Canberra, Australia|2"
		['void.voidbr.org']="https://void.voidbr.org/voidlinux/|South and Central America|M. do Paranapanema, Brazil|2"
		['void.voidlinux.com.br']="https://void.voidlinux.com.br/voidlinux/|South and Central America|Cacoal/RO, Brazil|2"
		['mirror.linux.ec']="https://mirror.linux.ec/voidlinux/|South and Central America|Quito, Ecuador|2"
		#extra
		['void.chililinux.com']="https://void.chililinux.com/voidlinux/|South and Central America|Pimenta Bueno/RO, Brazil|2"
	)

	while true; do
		array=()
		sorted_list=$(for key in "${!Amirror[@]}"; do echo "$key|${Amirror[$key]}"; done | sort -t\| -k5 -k3)
		while IFS='|' LC_ALL=C read -r -a fields; do
			key="${fields[FLD_MIRROR]}"
			[[ "${AConfMirror[_MIRROR]}" = "$key" ]] && Aflag["$key"]='on' || Aflag["$key"]='off'
			array+=("$key" "$(printf "$sep%-6s$sep%-25s$sep%-26s$sep%-s" \
				"Tier ${fields[FLD_TIER]}" \
				"${fields[FLD_REGION]}" \
				"${fields[FLD_LOCATION]}" \
				"${fields[FLD_REPOSITORY]}")"
			"${Aflag[$key]}")
		done <<<"${sorted_list[@]}"

		mirror=$(${DIALOG} \
			--title "=== ${cmsg_Mirror^^} ===" \
			--stdout \
			--keep-tite \
			--aspect 20 \
			--clear \
			--backtitle "$ccabec" \
			--default-item "${AConfMirror[_MIRROR]}" \
			--colors \
			--cancel-label "${cmsg_ButtonBack}" \
			--ok-label "${cmsg_Aceitar}" \
			--extra-button \
			--extra-label "void-testmirror" \
			--radiolist "${cmsg_MENU}" \
			24 0 2 "${array[@]}")

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			return 1
			;;
		3)
			oldgrafico=$grafico
			grafico=1
			if [[ -n $(command -v void-testmirror) || -n $(command -v ./void-testmirror) ]]; then
				last_msg="Wait... ${cmsg_Gerando} test with void-testmirror ${xurl}"
				msg "=== ${cmsg_Mirror^^} === void-testmirror" "$last_msg" "$(log_info_msg "$last_msg")"
				result=$(void-testmirror --nocolor --ping --quiet)
				evaluate_retval "$?" "$err_not_fatal"
				[[ -z "$result" ]] && result="${RED}ERRO DESCONHECIDO: void-testmirror não retornou resultado${RESET}"
				info "=== ${cmsg_Mirror^^} === void-testmirror" "\n$result"
			else
				sh_info_msg "Wait... ${cmsg_Gerando} test with void-mirror ${xurl}"
				evaluate_retval 1 "$err_not_fatal"
				info "=== ${cmsg_Mirror^^} === void-testmirror" "\n${RED}void-testmirror não foi localizado no \$PATH${RESET}" \
					"${RED}void-testmirror não foi localizado em $PWD!${RESET}"
			fi
			grafico=$oldgrafico
			continue
			;;
		esac
		AConfMirror[_MIRROR]="$mirror"
		url_mirror="$(sh_splitarray "${Amirror[$mirror]}" "$FLD_REPOSITORY")"
		AConfMirror[url_mirror]="$url_mirror"
		AConfMirror[location]="$(sh_splitarray "${Amirror[$mirror]}" "$FLD_LOCATION")"
		LMIRROR=true

		if [[ "$DISTRO" = @(void|void-live|voidlinux|voidbr) ]]; then
			if conf "=== ${cmsg_Mirror^^} ===" \
				"\n${BOLD}$(gettext "Aparentemente, o VOID Linux está sendo usado como host.")\n" \
				"\n${BOLD}${CYAN}Mirror     : ${AConfMirror[_MIRROR]}" \
				"\n${BOLD}${CYAN}Url Mirror : $url_mirror" \
				"\n${BOLD}${CYAN}Region     : $(sh_splitarray "${Amirror[$mirror]}" "$FLD_REGION")" \
				"\n${BOLD}${CYAN}Location   : $(sh_splitarray "${Amirror[$mirror]}" "$FLD_LOCATION")\n" \
				"\n${RED}$(gettext "Você também deseja definir/alterar o espelho do host para o escolhido?")${RESET}\n\n"; then

				sh_info_msg "${cmsg_Configurando} ${cmsg_Mirror,,}"
				mkdir -p "/etc/xbps.d/"
				cat >"/etc/xbps.d/00-repository-main.conf" <<-EOF
					repository=${url_mirror}current
					repository=${url_mirror}current/nonfree
					repository=${url_mirror}current/multilib
					repository=${url_mirror}current/multilib/nonfree
				EOF
				evaluate_retval "$?"
			fi
		fi

		if ! sh_check_mirror; then
			continue
		fi

		return 0

	done
}

sh_check_mirror() {
	local check_url="$(curl -o /dev/null -s -w '%{http_code}\n' "$url_mirror")"

	if [[ "$check_url" != 200 ]]; then
		if conf "=== ${cmsg_Mirror^^} ===" \
			"\n$(gettext "O mirror $url_mirror parece estar offline")" \
			"\n\n$(gettext "Deseja escolher outro mirror ?")"; then
			return 1
		fi
	fi
	return 0
}

sh_testcommand() {
	if [[ -z $(command -v "$1") ]]; then
		#		echo "$(gettext "não disponível")"
		"$(gettext "não disponível")"
	else
		#		echo "$(gettext "mais avançado")"
		"$(gettext "mais avançado")"
	fi
}

sh_execUtilDisk() {
	local exit_status
	${DIALOG} \
		--title "Modify Partition Table on ${AConfDisk[_DEVICE]}" \
		--colors \
		--msgbox "\n
${BOLD}${software} $(gettext "será executado no disco") ${AConfDisk[_DEVICE]}.${RESET}\n\n
$(gettext "Para sistemas BIOS, ")\
$(gettext "tabelas de partições MBR (dos) ou GPT são suportadas.")\n
$(gettext "Para usar o GPT em sistemas de BIOS de PC, ")
$(gettext "uma partição vazia de 1 MB deve ser adicionada")\n
$(gettext "nos primeiros 2 GB do disco com flag bios_grub ativada.")\n
${BOLD}$(gettext "NOTA: você não precisa disso em sistemas UEFI.")${RESET}\n\n
$(gettext "Para sistemas UEFI, GPT é obrigatório, e uma partição FAT32 com pelo menos")\n
$(gettext "100MB deve ser criado com a flag boot,")
$(gettext "este será usado como")\n
$(gettext "Partição do sistema UEFI.")\
$(gettext "Esta partição deve ter um ponto de montagem como") '/boot/efi'\n\n
$(gettext "Pelo menos 1 partição é necessária para rootfs") '(/)'.\n
$(gettext "Para o swap,") $(gettext "Uma RAM*2 deve ser realmente suficiente.")\
$(gettext "Para o / minímo de 600 MB são necessários.")\n\n
${BOLD}$(gettext "AVISO: /usr não é suportado como uma partição separada.")${RESET}\n
${RESET}\n" 18 80
	exit_status=$?
	if [ $exit_status -eq 0 ]; then
		while true; do
			clear
			"$software" "${AConfDisk[_DEVICE]}"
			LAUTO=false
			break
		done
	else
		return 1
	fi
	sh_disk_part_info
	return 0
}

sh_menuUtilDisk() {
	local array=()
	local i
	local n=0
	local nc=0
	local result
	local sep="\xe2\x94\x82"
	local -A ARRAY_UTIL_DISK=()
	local cRecommended="$(gettext 'Recomendado')"
	local cRecommendedDesc="$(gettext 'Particionamento e formatação automatica')"
	local cNotDisp="$(gettext 'Não disponível')"
	local ccfdisk="$(gettext 'Simples de usar')"
	local ccfdiskDesc="$(gettext 'Programa baseado em curses para particionar dispositivos de bloco')"
	local cfdisk="$(gettext 'Tradicional e poderoso')"
	local cfdiskDesc="$(gettext 'Manipulador de tabela de particoes para Linux')"
	local cgdisk="$(gettext 'Modernoo para GPT')"
	local cgdiskDesc="$(gettext 'Ferramenta em modo texto para particionamento GPT')"
	local cparted="$(gettext 'Avancado e flexivel')"
	local cpartedDesc="$(gettext 'Editor de particoes GNU para criar e gerenciar particoes')"

	ARRAY_UTIL_DISK+=(["automatic"]="${cRecommended}|${cRecommendedDesc}|")
	ARRAY_UTIL_DISK+=(["cfdisk"]=$([[ -z $(command -v "cfdisk") ]] && echo "${cNotDisp}||" || echo "${ccfdisk}|${ccfdiskDesc}|"))
	ARRAY_UTIL_DISK+=(["fdisk"]=$([[ -z $(command -v "fdisk") ]] && echo "${cNotDisp}||" || echo "${cfdisk}|${cfdiskDesc}|"))
	ARRAY_UTIL_DISK+=(["gdisk"]=$([[ -z $(command -v "gdisk") ]] && echo "${cNotDisp}||" || echo "${cgdisk}|${cgdiskDesc}|"))
	ARRAY_UTIL_DISK+=(["parted"]=$([[ -z $(command -v "parted") ]] && echo "${cNotDisp}||" || echo "${cparted}|${cpartedDesc}|"))

	for i in $(echo "${!ARRAY_UTIL_DISK[@]}" | tr ' ' '\n' | sort); do
		array[n++]="$i"
		array[n++]=$(printf "%-22s$sep%-30s" "$(sh_splitarray "${ARRAY_UTIL_DISK[$i]}" 1)" "$(sh_splitarray "${ARRAY_UTIL_DISK[$i]}" 2)")
		((nc++))
	done

	software=$(${DIALOG} \
		--colors \
		--backtitle "$ccabec" \
		--title "$(gettext "Selecione o software para particionamento")" \
		--ok-label "${cmsg_Aceitar}" \
		--cancel-label "${cmsg_ButtonBack}" \
		--menu "${cmsg_MENU}\n\n\
${BOLD}DEVICE  : ${RESET}${RED}${AConfDisk[_DEVICE]}${RESET}\n\
${BOLD}MODEL   : ${RESET}${RED}${MODEL_ORIGEM}${RESET}\n" \
		12 0 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	esac

	case "$software" in
	"automatic")
		if sh_chooseTablePartition; then
			LMKPARTED=false
			oldgrafico=$grafico
			grafico=1
			sh_mkparted
			grafico=$oldgrafico
			sh_disk_part_info
		fi
		LAUTO=true
		return 0
		;;
	esac

	if sh_execUtilDisk; then
		LAUTO=false
	fi
	return 0
}

sh_getNvme() {
  local segtype
  local device="${AConfDisk[_DEVICE]}"

  segtype="$(sudo lvs "$device" -o segtype --noheadings 2>/dev/null | tr -d ' ')"

  case "$segtype" in
  thin | thin-pool)
    echo ''
    return
    ;;
  esac

	local tran
	local name

	name="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" $DSK_NAME)"
	tran="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" $DSK_TRAN)"

	case "$tran" in
	nvme | loop | lvm) echo 'p' ;;
	#lvm) echo '' ;;
	*)
		case "$name" in
		zram*) echo 'p' ;;
		nbd*) echo 'p' ;;
		*) echo '' ;;
		esac
		;;
	esac
}

sh_getlgrub() {
	local _device="$1"
	if [[ "$LGRUB" == "true" && "${AConfDisk[_BOOTLOADER]}" = "$_device" ]]; then
		echo '*'
	else
		echo ' '
	fi
}

sh_choose_disk() {
	local old_device="${AConfDisk[_DEVICE]}"

	sh_umount_fs

	while true; do
		sh_disk_part_info
		local array=()
		local i
		local n=0
		local nlen=0
		local nc=0
		local result
		local sep="\xe2\x94\x82"
		local xtitle
		local LCHOOSEBOOTLOADER=0
		local LCHOOSEHEALTH=false

		if [ $# -eq 0 ]; then
			xtitle="${cmsg_TitleDisco}"
			LCHOOSEBOOTLOADER=0
			LCHOOSEHEALTH=false
		else
			if [[ "$1" == "${cmsg_DiskHealth}" ]]; then
				xtitle="${cmsg_DiskHealth^^}"
				LCHOOSEHEALTH=true
			else
				xtitle="${cmsg_BootLoader^^}"
				LCHOOSEBOOTLOADER=1
			fi
		fi

		for i in "${ARRAY_DSK_DEVICES[@]}"; do
			array[n++]="$i"
			if ((nlen < ${#i})); then
				nlen=${#i}
			fi
			array[n++]=$(printf "$sep%-4s$sep%-6s$sep%6s$sep%-6s$sep%-15s$sep%-30s" \
				"$(sh_getlgrub "$i")" \
				"${ARRAY_DSK_TRAN[$nc]}" \
				"${ARRAY_DSK_SIZE[$nc]}" \
				"${ARRAY_DSK_PTTYPE[$nc]}" \
				"${ARRAY_DSK_LABEL[$nc]}" \
				"${ARRAY_DSK_MODEL[$nc]}")
			((nc++))
		done
		((nlen += 6))
		sd=$(${DIALOG} \
			--default-item "${AConfDisk[_DEVICE]}" \
			--backtitle "$ccabec" \
			--title "$xtitle" \
			--ok-label "${cmsg_ButtonSelecionar}" \
			--cancel-label "${cmsg_ButtonBack}" \
			--colors \
			--extra-button \
			--extra-button --extra-label "$(gettext 'Particionamento')" \
			--menu "${cmsg_MENU}\n\n\
$(printf "%${nlen}s$sep%-4s$sep%-6s$sep%6s$sep%-6s$sep%-15s$sep%-30s" "DEVICE" "BOOT" "TRAN" "SIZE" "PTTYPE" "LABEL" "MODEL")" \
			24 0 2 "${array[@]}" 2>&1 >/dev/tty)

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			return 1
			;;
		esac

		if [[ -n "$sd" ]]; then
			if $LCHOOSEHEALTH; then
				AConfDisk[_HEALTH]="$sd"
				return 0
			fi

			if ((LCHOOSEBOOTLOADER)); then
				AConfDisk[_BOOTLOADER]="$sd"
				LGRUB=true
				LOSPROBER=false
				return 0
			fi

			AConfDisk[_DEVICE]="$sd"
			AConfDisk[_BOOTLOADER]="$sd"
			AConfDisk[_HEALTH]="$sd"
			index=$(sh_seekstrarray "${ARRAY_DSK_DEVICES[*]}" "${AConfDisk[_DEVICE]}")
			NAME_ORIGEM="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" "$DSK_NAME")"
			MODEL_ORIGEM="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" "$DSK_MODEL")"
			SIZE_ORIGEM="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" "$DSK_SIZE")"
			TRAN_ORIGEM="$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_DEVICE]}]}" "$DSK_TRAN")"
			LDISK=true
			LGRUB=true
			[[ "$old_device" != "${AConfDisk[_DEVICE]}" ]] && LFSREVISED=false
		fi

		set_disk_choosed() {
			AConfDisk[_DEVICE]="$sd"
			AConfDisk[_BOOTLOADER]="$sd"
			AConfDisk[_HEALTH]="$sd"
			sh_checkdisk "$sd"
			sh_backup_partitions "$sd" "$NAME_ORIGEM"
			LDISK=true
			LGRUB=true
			LOSPROBER=false
			[[ "$old_device" != "${AConfDisk[_DEVICE]}" ]] && LFSREVISED=false

			#     if [[ "${#Amntpoint[@]}" -eq 0 ]]; then
			#	    if [[ "$old_device" != "${AConfDisk[_DEVICE]}" || ! $LFSREVISED ]]; then
			#	    if ! $LFSREVISED; then
			#     if [[ "${#Amntpoint[@]}" -eq 0 ]]; then
			if [[ "${AConfDisk[_DEVICE]}" != "${AsFs[_DEVICE]}" ]]; then
				sh_rebuild_amntpoint_for_new_disk
			fi
			AsFs[_DEVICE]="$sd"
		}

		case $exit_status in
		"$D_OK")
			set_disk_choosed

			if ! $LMKPARTED; then
				if conf "${xtitle} ${sd}" \
					"\n$(gettext 'O disco selecionado parece estar vazio ou sem partições configuradas.')" \
					"\n$(gettext 'Para continuar a instalação, é necessário criar as partições.')" \
					"\n\n${BOLD}${RED}$(gettext 'Deseja abrir as ferramentas de particionamento agora?')"; then
					sh_checkdisk "${AConfDisk[_DEVICE]}"
					sh_menuUtilDisk
					#continue
					set_disk_choosed # qui 07 mai 2026 21:22:11 -04
					return 0         # qui 07 mai 2026 21:22:11 -04
				fi

			fi
			return 0
			;;
		"$D_CONFIG")
			sh_checkdisk "${AConfDisk[_DEVICE]}"
			sh_menuUtilDisk
			#continue
			set_disk_choosed # qui 07 mai 2026 21:22:11 -04
			return 0         # qui 07 mai 2026 21:22:11 -04
			;;
		esac
	done
	LDISK=true
	LFSREVISED=false
	return 0
}

sh_chooseBootLoader() {
	if ! $LDISK; then
		AConfDisk[_BOOTLOADER]="${AConfDisk[_DEVICE]}"
		LGRUB=true
	fi

	if sh_choose_disk "=== BOOTLOADER (GRUB) ==="; then
		LOSPROBER=false
		if conf "=== OS-PROBER ===" "\n$(gettext "Detectar outro OS(s) instalado ?")\n\n"; then
			LOSPROBER=true
		fi
		AConfDisk[_OSPROBER]="$LOSPROBER"
		return 0
	fi
	return 1
}

sh_chooseTablePartitionAjuda() {
	${DIALOG} \
		--colors \
		--title "\Zb$(gettext "Resumo de Boot e Particionamento")\Zn" \
		--msgbox "\
  \Z1$(gettext "EFI / UEFI")\Zn
  $(gettext "Sistema moderno de boot que substituiu o BIOS antigo.")
  $(gettext "Suporta discos grandes, Secure Boot e inicialização rápida.")
  $(gettext "Usado normalmente com tabela GPT.")

  \Z2$(gettext "GPT_BIOS")\Zn
  $(gettext "Pequena partição especial usada quando o disco é GPT")
  $(gettext "mas o boot ainda utiliza BIOS legado.")
  $(gettext "Necessária para o BOOTLOADER em modo BIOS + GPT.")

  \Z3$(gettext "MBR")\Zn
  $(gettext "Método antigo de particionamento e boot.")
  $(gettext "Limite de até 2 TB.")
  $(gettext "Suporta até 4 partições primárias")
  $(gettext "(ou 3 primárias + 1 estendida com várias lógicas).")

  \Z4$(gettext "GPT")\Zn
  $(gettext "Tabela de particionamento moderna usada com UEFI.")
  $(gettext "Suporta discos enormes e normalmente até 128 partições")
  $(gettext "sem necessidade de partição estendida.")

  \Z5$(gettext "Importante")\Zn
  $(gettext "Se a ISO foi iniciada em modo UEFI, o BOOTLOADER poderá")
  $(gettext "ser instalado em modo UEFI utilizando EFI + GPT.")

  $(gettext "Se a ISO foi iniciada em modo BIOS/Legacy, utilize")
  $(gettext "GPT_BIOS com GPT ou utilize MBR.")" \
		0 0
}

sh_chooseTablePartition() {
	local -A Atable
	local -A Aflag
	local cextra
	local exit_status
	local array=()
	local x

	Atable[EFI]="${cmsg_Efi} - ${cmsg_TabelaGPT}"
	Atable[GPT_BIOS]="${cmsg_BiosGpt} - ${cmsg_TabelaGPT}"
	Atable[MBR_BIOS]="${cmsg_BiosMbr} - ${cmsg_TabelaMBR}"
	cextra="${YELLOW}${cmsg_ExtraNotEfi}\n${GREEN}${cmsg_ExtraNotEfiRecommended}${RESET}"

	for x in "${!Atable[@]}"; do
		Aflag[$x]='off'
		if sh_getBootEFI; then
			Aflag[EFI]='on'
			cextra="${YELLOW}${cmsg_ExtraEfi}\n${GREEN}${cmsg_ExtraEfiRecommended}${RESET}"
		fi
		if [[ -z "${AConfDisk[_DISKTABLE]}" ]]; then
			sh_getBootEFI && AConfDisk[_DISKTABLE]='EFI' || AConfDisk[_DISKTABLE]='GPT_BIOS'
		fi
		Aflag["${AConfDisk[_DISKTABLE]}"]='on'
		array+=("$x" "${Atable[$x]}" "${Aflag[$x]}")
	done

	table=$(${DIALOG} \
		--title "$(gettext "=== TABELA DE PARTIÇÕES ===")" \
		--default-item "${AConfDisk[_DISKTABLE]}" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--help-button \
		--help-label "$(gettext 'Ajuda')" \
		--radiolist "${cmsg_MENU}\n\n$cextra" \
		12 85 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return 1
		;;
	"$D_AJUDA")
		sh_chooseTablePartitionAjuda
		sh_chooseTablePartition
		;;
	"$D_OK")
		if [[ "$table" = "GPT" ]]; then
			if ! sh_getBootEFI; then
				info "$ccabec" "$cextra"
				sh_chooseTablePartition
			fi
		fi
		;;
	esac
	AConfDisk[_DISKTABLE]="$table"
	return 0
}

sh_checkdisk() {
	local device="$1"
	local dsk

	sh_info_msg "${cmsg_ChecandoParticoesMontadas}: $device"
	if [[ "$device" == /dev/zram* ]]; then
		if grep -qw "$device" /proc/swaps; then
			if ! conf "=== CHECKDISK ===" "\n${BOLD}${RED}ERRO:${RESET} o device: '$device' está ativo como swap (zram). Desativar?\n\n"; then
				evaluate_retval "$err_fatal" "$err_fatal" "zram ativo (swap): $device"
				return 1
			fi
			swapoff "$device" 2>/dev/null || {
				evaluate_retval "$err_fatal" "$err_fatal" "falha ao desativar zram: $device"
				return 1
			}
		fi
		return 0
	fi

	# desmonta qualquer partição do device (loop, sdX, nvme, nbd, etc) usando findmnt corretamente (SOURCE -> TARGET)
	# coleta todos os mountpoints das partições do device
	mnts="$(findmnt -rn -o TARGET,SOURCE | awk -v d="$device" '$2 ~ "^"d {print $1}')"
	if [[ -n "$mnts" ]]; then
		if ! conf "=== CHECKDISK ===" "\n${BOLD}${RED}ERRO:${RESET} o device: '$device' tem partições montadas! Desmontar?\n\n"; then
			evaluate_retval "$err_fatal" "$err_fatal" \
				"${cmsg_all_mounted_part}: $mnts"
			return 1
		fi
		# desmonta em ordem reversa (filho -> pai)
		while read -r mp; do
			umount "$mp" 2>/dev/null || {
				evaluate_retval "$err_fatal" "$err_fatal" "falha ao desmontar $mp"
				return 1
			}
		done <<<"$(printf '%s\n' "$mnts" | sort -r)"
	fi
	# desativa swap do device (swap não aparece no findmnt)
	while read -r sw; do
		swapoff "$sw" 2>/dev/null || {
			evaluate_retval "$err_fatal" "$err_fatal" "falha ao desativar swap: $sw"
			return 1
		}
	done < <(
		swapon --noheadings --raw | awk -v d="$device" '$1 ~ "^"d {print $1}'
	)
	return 0
}

sh_confadduser() {
	local size
	local model
	local chostname

	$LEXTRA && chostname="${AsUser[chostname]}" || chostname="${chostname_base}-${_WM}"
	sh_setUser
	size=$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 2)
	model=$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 4)

	while true; do
		exec 3>&1
		usertext=$(${DIALOG} \
			--title "$(gettext "=== EXTRA ===")" \
			--colors \
			--ok-label "${cmsg_Aceitar}" \
			--cancel-label "${cmsg_ButtonBack}" \
			--backtitle "$ccabec" \
			--insecure "$@" \
			--mixedform "${cmsg_MENU}" \
			0 0 0 \
			"${cmsg_Extra1}: " 1 1 "${AsUser[cfullname]}" 1 28 40 0 0 \
			"${cmsg_Extra2}: " 2 1 "${AsUser[cuser]}" 2 28 20 0 0 \
			"${cmsg_Extra3} (${AsUser[cpass]}): " 3 1 "${AsUser[cpass]}" 3 28 20 0 1 \
			"${cmsg_Extra4} (${AsUser[cpassroot]}): " 4 1 "${AsUser[cpassroot]}" 4 28 20 0 1 \
			"Hostname: " 5 1 "${chostname}" 5 28 20 0 0 \
			"${cmsg_Extra6}: " 6 1 "${AConfDisk[_DEVICE]}" 6 28 20 0 2 \
			"Tam/Model: " 7 1 "$size/$model" 7 28 20 0 2 \
			"${cmsg_Teclado}: " 8 1 "${AConfLocale[_KEYMAP]}" 8 28 20 0 2 \
			"Timezone: " 9 1 "${AConfLocale[_TIMEZONE]}" 9 28 20 0 2 \
			"${cmsg_Extra11}: " 10 1 "${_WINDOWMANAGER[*]}" 10 28 30 0 2 \
			2>&1 1>&3)

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			return
			;;
		"$D_OK")
			mapfile -t aUser <<<"$usertext"
			AsUser[cfullname]="${aUser[0]}"
			AsUser[cuser]="${aUser[1]}"
			AsUser[cpass]="${aUser[2]}"
			AsUser[cpassroot]="${aUser[3]}"
			AsUser[chostname]="${aUser[4]}"

			if [[ "${AsUser[cuser]}" == "root" ]]; then
				if ! conf "$(gettext "=== USUÁRIO ===")" "\n${cmsg_ adduser1}"; then
					die "$(gettext "=== USUÁRIO === ")" "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi

			if [[ -z "${AsUser[cuser]}" ]]; then
				if ! conf "=== ${cmsg_Usuario^^} ===" "\n${cmsg_adduser2}"; then
					die "=== ${cmsg_Usuario^^} === " "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi

			# Verificar se usuario começa com um número
			if [[ "${AsUser[cuser]}" =~ ^[0-9] ]]; then
				if ! conf "=== ${cmsg_Usuario^^} ===" "\n${cmsg_adduser5}"; then
					die "$(gettext "=== USUÁRIO === ")" "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi

			# Verificar se string1 começa com uma letra maiúscula
			if [[ "${AsUser[cuser]}" =~ ^[A-Z] ]]; then
				if ! conf "=== ${cmsg_Usuario^^} ===" "\n${cmsg_adduser6}"; then
					die "$(gettext "=== USUÁRIO === ")" "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi

			if [[ -z "${AsUser[cpass]}" ]]; then
				if ! conf "=== ${cmsg_Usuario^^} ===" "\n${cmsg_adduser3}"; then
					die "=== ${cmsg_Usuario^^} ===" "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi

			if [[ -z "${AsUser[cpassroot]}" ]]; then
				if ! conf "=== ROOT ===" "\n${cmsg_adduser4}"; then
					die "=== ROOT === " "${cmsg_adduserCancel}"
					return 1
				fi
				sh_confadduser
			fi
			LEXTRA=true
			;;
		esac
		exec 3>&-
		return 0
	done
}

sh_dryrun() {
	sh_umount_fs
	sh_mount_fs
	sh_init_bind

  #sh_limineInstall
	#sh_hack_hyprland_lib
	#sh_configure_hyprland_audio
	#sh_update_locale
	#sh_update_rc_conf
	#sh_update_rc_local
	#sh_activating_services
	#sh_make_user
	#sh_update_sshd
	#sh_update_sudoers
	#sh_make_fstab
	#sh_update_sddm_conf
	#sh_build_and_apply_dhcpcd_config
	#sh_change_grub

	export PS1="[chroot $dir_install] $PS1"
	LC_ALL=C chroot "$dir_install" "/bin/bash"
	sh_umount_fs
}

sh_usage() {
	local usage=$(gettext "usar:")
	local operation=$(gettext "operação")

	cat <<EOF
${white}${APP} v$_VERSION_${reset}
${orange}$usage ${APP} ${reset}<$operation> [...]
${orange}     ${APP} ${reset}-i
${orange}     ${APP} ${reset}-i [-f <file>]
${orange}     ${APP} ${reset}[-i|c|f|g|q|V|n|h]
${orange}     ${APP} ${reset}[--install|--chroot|--file|--grafico|--quiet|--version|--nocolor|--help]

[<operations>] ${reset}
   ${red}-i  --install${cyan}       # ${cmsg_Usage1}
   ${red}-c  --chroot${cyan}        # ${cmsg_Usage2}
   ${red}-f  --file${cyan}          # ${cmsg_Usage8} (default: $app_conf)
   ${red}-g  --grafico${cyan}       # ${cmsg_Usage3}
   ${red}-q  --quiet${cyan}         # ${cmsg_Usage4}
   ${red}-V  --version${cyan}       # ${cmsg_Usage5}
   ${red}-n  --nocolor${cyan}       # ${cmsg_Usage6}
   ${red}-h  --help${cyan}          # ${cmsg_Usage7}${reset}
EOF
}

sh_loadconf() {
	if ! $LCHROOT; then
		sh_info_msg "$(gettext 'Loading configuration file'): ${yellow}$app_conf"
	fi

	if [ -f "$app_conf" ] && [ -r "$app_conf" ]; then
		# shellcheck source=/dev/null
		source "$app_conf"
		evaluate_retval "$?"
		sh_parseconf
	else
		evaluate_retval "$?" 1 "${cmsg_falhaAbertura} $app_conf!"
	fi
}

sh_parseconf() {
	if ! $LCHROOT; then
		sh_info_msg "$(gettext 'Analisando o arquivo de configuração'): ${yellow}$app_conf"
	fi

	url_mirror="${AConfMirror[url_mirror]}"
#	[[ -n "${AsUser[cuser]}" && -n "${AsUser[cpass]}" && -n "${AsUser[cpassroot]}" && -n "${AsUser[chostname]}" ]] && LEXTRA=true
	[[ -n "${AConfLocale[_TIMEZONE]}" ]] && LTIMEZONE=true
	[[ -n "${AConfLocale[_KEYMAP]}" ]] && LKEYMAP=true
	[[ -n "${AConfMirror[_MIRROR]}" && -n "$url_mirror" ]] && LMIRROR=true
	[[ -n "${AConfMirror[_SOURCE]}" ]] && LSOURCE=true
	[[ -n "${AConfAudio[_AUDIOSERVER]}" ]] && LAUDIO=true
	[[ -n "${AConfKernel[_KERNEL]}" ]] && LKERNEL=true
	[[ -n "${Amntpoint[*]}" ]] && LPARTITION=true
	[[ -n ${_WINDOWMANAGER[*]} ]] && LWM=true
	[[ -n ${_DISPLAYMANAGER} ]] && LDM=true
	evaluate_retval "${PIPESTATUS[0]}" "$err_not_fatal"
}

sh_mkefiroaming() {
	#Caminho de inicialização padrão/reserva
	if [[ -e "$dir_install/boot/efi/EFI/$cnickefi/grubx64.efi" ]]; then
		sh_cmd_job "${cmsg_CriandoDiretorio}: $dir_install/boot/efi/EFI/BOOT" "
   		mkdir -pv $dir_install/boot/efi/EFI/BOOT
      " $err_not_fatal
		sh_cmd_job "${cmsg_CopiandoCaminhoReserva}: $dir_install/boot/efi/BOOT" "
   		cp -f $dir_install/boot/efi/EFI/$cnickefi/grubx64.efi $dir_install/boot/efi/EFI/BOOT/BOOTX64.EFI
      " $err_not_fatal
	fi
}

sh_getBootEFI() {
	if [ -d /sys/firmware/efi ]; then
		TARGET_EFI=x86_64-efi
		if [ -r /sys/firmware/efi/fw_platform_size ] &&
			[ "$(cat /sys/firmware/efi/fw_platform_size)" -eq 32 ]; then
			TARGET_EFI=i386-efi
		fi
		return 0
	fi
	return 1
}

sh_choose_wm() {
	declare -A aFlag
	declare -A aWm
	local x

	if [[ "${AConfMirror[_SOURCE]}" = "local" ]]; then
		alerta "=== ${cmsg_Wm^^} ===" "$(gettext 'Instalação escolhida foi via local/ISO, não é necessário alterar nada aqui.')"
		_WINDOWMANAGER='tty'
		LWM=true
		return
	fi

	aWm[tty]="${cmsg_tty}"
	aWm[server]="${cmsg_server}"
	aWm[xorg]="Xorg $(gettext "Minimal")"
	aWm[cinnamon]="Cinnamon"
	aWm[enlightenment]="Enlightenment"
	aWm[gnome]="Gnome"
	aWm[plasma]="Kde Plasma"
	aWm[xfce]="Xfce 4"
	aWm[mate]="Mate"
	aWm[awesome]="Awesome"
	aWm[bspwm]="Bspwm"
	aWm[dwm]="Dwm"
	aWm[fluxbox]="Fluxbox"
	aWm[hyprland]="(Experimental) Hyprland"
	aWm[i3wm]="I3wm"
	aWm[lxde]="Lxde"
	aWm[lxqt]="Lxqt"
	aWm[openbox]="Openbox"
	aWm[sway]="(Experimental) $(gettext "Tiling Wayland compositor compatible with i3")"
	aWm[mango]="(Experimental) $(gettext "Dwl-based wayland compositor using scenefx")"
	aWm[river]="(Experimental) $(gettext "Dynamic tiling Wayland compositor")"
	aWm[twm]="Twm"

	for x in "${!aWm[@]}"; do
		aFlag[$x]='off'
	done

	for x in "${_WINDOWMANAGER[@]}"; do
		aFlag[$x]='on'
	done

	#		awesome "${aWm[awesome]}" "${aFlag[awesome]}" \
	#		bspwm "${aWm[bspwm]}" "${aFlag[bspwm]}" \
	#		dwm "${aWm[dwm]}" "${aFlag[dwm]}" \
	#		lxde "${aWm[lxde]}" "${aFlag[lxde]}" \
	#		lxqt "${aWm[lxqt]}" "${aFlag[lxqt]}" \
	#		openbox "${aWm[openbox]}" "${aFlag[openbox]}" \
	#		twm "${aWm[twm]}" "${aFlag[twm]}" \

	wm=$(${DIALOG} \
		--backtitle "$ccabec" \
		--title "=== ${cmsg_Wm^^} ===" \
		--default-item "$_WINDOWMANAGER" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--checklist "${cmsg_MENU}" \
		0 0 0 \
		tty "${aWm[tty]}" "${aFlag[tty]}" \
		server "${aWm[server]}" "${aFlag[server]}" \
		xorg "${aWm[xorg]}" "${aFlag[xorg]}" \
		cinnamon "${aWm[cinnamon]}" "${aFlag[cinnamon]}" \
		enlightenment "${aWm[enlightenment]}" "${aFlag[enlightenment]}" \
		fluxbox "${aWm[fluxbox]}" "${aFlag[fluxbox]}" \
		gnome "${aWm[gnome]}" "${aFlag[gnome]}" \
		i3wm "${aWm[i3wm]}" "${aFlag[i3wm]}" \
		mate "${aWm[mate]}" "${aFlag[mate]}" \
		plasma "${aWm[plasma]}" "${aFlag[plasma]}" \
		sway "${aWm[sway]}" "${aFlag[sway]}" \
		mango "${aWm[mango]}" "${aFlag[mango]}" \
		hyprland "${aWm[hyprland]}" "${aFlag[hyprland]}" \
		river "${aWm[river]}" "${aFlag[river]}" \
		xfce "${aWm[xfce]}" "${aFlag[xfce]}" \
		2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac

	_WINDOWMANAGER=($(strtoarray "$wm"))
	_WM="$wm"
	LWM=true
	LONLY_TTY=true
	LSERVER=false
	AConfAudio[_AUDIOSERVER]="None"
	_DISPLAYMANAGER="None"

	for wm in "${_WINDOWMANAGER[@]}"; do
		case "$wm" in
		tty)
			LONLY_TTY=true
			AConfAudio[_AUDIOSERVER]="None"
			_DISPLAYMANAGER="None"
			_WM="tty"
			;;
		xorg)
			LONLY_TTY=true
			LXORG=true
			AConfAudio[_AUDIOSERVER]="None"
			_DISPLAYMANAGER="None"
			_WM="xorg"
			break
			;;
		server)
			LONLY_TTY=true
			LSERVER=true
			AConfAudio[_AUDIOSERVER]="None"
			_DISPLAYMANAGER="None"
			_WM="server"
			break
			;;
		sway)
			LONLY_TTY=false
			AConfAudio[_AUDIOSERVER]="Pipewire"
			_DISPLAYMANAGER="sddm"
			LSWAY=true
			_WM="$wm"
			break
			;;
		mango)
			LONLY_TTY=false
			AConfAudio[_AUDIOSERVER]="Pipewire"
			_DISPLAYMANAGER="sddm"
			LMANGO=true
			_WM="$wm"
			break
			;;
		hyprland)
			LONLY_TTY=false
			AConfAudio[_AUDIOSERVER]="Pipewire"
			_DISPLAYMANAGER="sddm"
			LHYPRLAND=true
			_WM="$wm"
			break
			;;
		*)
			LONLY_TTY=false
			AConfAudio[_AUDIOSERVER]="Pipewire"
			if grep -qi gnome <<<"${_WINDOWMANAGER[@]}"; then
				_DISPLAYMANAGER="gdm"
			else
				_DISPLAYMANAGER="lightdm"
			fi
			_WM="$wm"
			break
			;;
		esac
	done

	set_custom_install "=== ${cmsg_Wm^^} ==="

	LAUDIO=true
	LDM=true

	if grep -qi hyprland <<<"${_WINDOWMANAGER[@]}"; then
		LHYPRLAND=true
	fi

	LDHCP=false
	if $LSERVER; then
		if conf "=== IP SERVER ===" \
			"\n${BOLD}${WHITE}$(gettext "Uma instalação SERVIDOR foi escolhida")\n" \
			"\n${BOLD}${RED}$(gettext "Deseja configurar IP fixo?")\n\n"; then
			sh_configure_dhcpcd_static_ip_dialog
		fi
	fi

	#  debug "${_DISPLAYMANAGER[@]}" "\n${_WINDOWMANAGER[@]}" "\nLONLY_TTY=$LONLY_TTY" "\nLXORG=$LXORG"

}

sh_configure_custom_packages() {
	local pkg

	for pkg in "${aCustomPackages[@]}"; do
		case "${pkg,,}" in
		libreoffice)
			aCustomPackages+=(libreoffice-i18n-"$(sh_get_language_without_utf8)")
			;;
		voidbr-epoptes-client)
			aServicesTTY+=(epoptes-client)
			;;
		tailscale)
			aServicesTTY+=(tailscaled)
			;;
		avahi)
			aServicesTTY+=(avahi-daemon)
			;;
		acpid)
			aServicesTTY+=(acpid)
			;;
		irqbalance)
			aServicesTTY+=(irqbalance)
			;;
		cups)
			aServicesTTY+=(cupsd)
			;;
		docker)
			aServicesTTY+=(docker)
			;;
		podman)
			aServicesTTY+=(podman)
			;;
		net-snmp)
			aServicesTTY+=(snmpd)
			;;
		esac
	done
}

sh_choose_custom_packages() {
	declare -A aFlag
	declare -A aCustom
	local x
	local custom

	if ! $LONLY_TTY; then
		aCustom['louvorja-piano']="$(gettext 'LouvorJA - PIANO - aplicativo desktop para gerenciamento de culto)')"
		aCustom['voidbr-epoptes']="$(gettext 'An opensource computer lab management and monitoring tool (server)')"
		aCustom['gwenview']="$(gettext 'Fast and easy to use image viewer by KD')"
		aCustom['Thunar']="$(gettext 'Thunar File Manager')"
		aCustom['thunar-archive-plugin']="$(gettext 'Create and extract archives in Thunar')"
		aCustom['opera']="$(gettext 'Fast, secure, easy to use browser')"
		aCustom['eog']="$(gettext 'Eye of GNOME graphics viewer program')"
		aCustom['chromium']="$(gettext 'Google attempt at creating a safer, faster, and more stable browser')"
		aCustom['qutebrowser']="$(gettext 'Keyboard-focused browser with a minimal GUI')"
		aCustom['vivaldi']="$(gettext 'Advanced browser made with the power user in mind')"
		aCustom['brave-bin']="$(gettext 'Web browser that blocks ads and trackers by default (binary release)')"
		aCustom['celluloid']="$(gettext 'Simple GTK+ frontend for mpv')"
		aCustom['mpv']="$(gettext 'Video player based on MPlayer/mplayer2')"
		aCustom['cool-retro-term']="$(gettext 'Good looking terminal emulator which mimics the old cathode display')"
		aCustom['gparted']="$(gettext 'Gnome Partition Editor)')"
		aCustom['voidbr-google-chrome']="$(gettext 'The popular web browser by Google (Stable Channel)')"
		aCustom['libreoffice']="$(gettext 'Productivity suite')"
		aCustom['menulibre']="$(gettext 'Advanced menu editor')"
		aCustom['mousepad']="$(gettext 'Simple text editor for Xfce based on Leafpad')"
		aCustom['mugshot']="$(gettext 'Program to update personal user details')"
		aCustom['ocs-url']="$(gettext 'Install helper program for OpenCollaborationServices (ocs://)')"
		aCustom['vlc']="$(gettext 'Cross-platform multimedia player')"
		aCustom['samsung-unified-driver']="$(gettext 'Unified Linux Driver for Samsung printers and scanners')"
		aCustom['splix']="$(gettext 'CUPS driver for SPL printers (Samsung and several Xerox printers)')"
		aCustom['system-config-printer']="$(gettext 'CUPS printer configuration tool and status applet')"
		aCustom['bluez-cups']="$(gettext 'CUPS printer backend for Bluetooth printers')"
		aCustom['cups-pdf']="$(gettext 'PDF printer for cups')"
		aCustom['samba-cups']="$(gettext 'SMB backend for cups (transitional dummy package)')"
		aCustom['cups']="$(gettext 'Common Unix Printing System')"
	fi

	if $LSERVER; then
		aCustom['voidbr-network-tools']="$(gettext 'Meta‑pacote com utilitários essenciais de rede e monitoramento para Void Linux')"
	fi

	# tty
	aCustom['timeshift']="$(gettext 'System restore tool')"
	aCustom['voidbr-distrobox']="$(gettext 'Use any linux distribution inside your terminal')"
	aCustom['net-snmp']="$(gettext 'Simple Network Management Protocol (SNMP) suite')"
	aCustom['voidbr-samba']="$(gettext 'SMB/CIFS file, print, and login server for Unix')"
	aCustom['docker']="$(gettext 'Docker container runtim')"
	aCustom['podman']="$(gettext 'Simple management tool for containers and images')"
	aCustom['voidbr-epoptes-client']="$(gettext 'An opensource computer lab management and monitoring tool (client)')"
	aCustom['irqbalance']="$(gettext 'Handholding your interrupts for power and performance')"
	aCustom['acpi']="$(gettext 'Informations about ACPI devices (battery, thermal sensors and power)')"
	aCustom['acpid']="$(gettext 'ACPI Daemon (acpid) With Netlink Support)')"
	aCustom['tailscale']="$(gettext 'Easy, secure, cross platform WireGuard, oauth2, and 2FA/SSO')"
	aCustom['micro']="$(gettext 'Modern and intuitive terminal-based text editor')"
	aCustom['inxi']="$(gettext 'Full featured system information script')"
	aCustom['htop']="$(gettext 'Interactive process viewer')"
	aCustom['vim']="$(gettext 'Vim editor (vi clone)')"
	aCustom['neovim']="$(gettext 'Fork of Vim aiming to improve user experience, plugins and GUIs')"
	aCustom['tmate']="$(gettext 'Instant Terminal Sharing')"
	aCustom['bzip2']="$(gettext 'Freely available, patent free, high-quality data compressor')"
	aCustom['p7zip']="$(gettext 'Command-line version of the 7zip compressed file archive (transitional dummy package)')"
	aCustom['zip']="$(gettext 'Create/update ZIP files compatible with pkzip')"
	aCustom['7zip-unrar']="$(gettext 'File archiver with a high compression ratio - RAR support')"
	aCustom['avahi']="$(gettext 'Multicast DNS Service Discovery')"
	aCustom['avahi-discover']="$(gettext 'Service discovery user interface for avahi')"
	aCustom['dfc']="$(gettext 'Display file system space usage using graphs and colors')"
	aCustom['pfetch']="$(gettext 'System information tool written in POSIX sh')"
	aCustom['xtools']="$(gettext 'Opinionated helpers for working with XBPS')"

	for x in "${!aCustom[@]}"; do
		aFlag[$x]='off'
	done

	for x in "${aCustomPackages[@]}"; do
		aFlag[$x]='on'
	done

	local dialog_items=()
	for x in $(printf '%s\n' "${!aCustom[@]}" | sort); do
		dialog_items+=(
			"$x"
			"${aCustom[$x]}"
			"${aFlag[$x]}"
		)
	done

	custom=$(
		${DIALOG} \
			--stdout \
			--backtitle "$ccabec" \
			--title "=== Pacotes Extras ===" \
			--colors \
			--cancel-label "${cmsg_ButtonBack}" \
			--ok-label "${cmsg_Aceitar}" \
			--checklist "${cmsg_MENU}" \
			25 0 2 \
			"${dialog_items[@]}"
	)

	# debug "$custom"

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac

	# mapfile -t aCustomPackages= <<<"$custom"
	# read -r -a aCustomPackages <<< "$custom"
	aCustomPackages=($(strtoarray "$custom"))

}

sh_configure_dhcpcd_static_ip_dialog() {
	local CONFIG_FILE="/etc/dhcpcd.conf"
	local DEFAULT_IFACE

	# detecta interface padrão
	DEFAULT_IFACE="$(get_default_iface)"

	sh_setAsDhcp

	# formulário
	while true; do
		exec 3>&1
		dhcptext=$(dialog \
			--backtitle "$ccabec" \
			--title "$(gettext "Configuração de IP fixo (dhcpcd)")" \
			--form "$(gettext "Preencha os dados:")" \
			15 60 6 \
			"$(gettext "Interface:")" 1 1 "${AsDhcp[IFACE]}" 1 25 20 0 \
			"$(gettext "IP:")" 2 1 "${AsDhcp[IP]}" 2 25 20 0 \
			"$(gettext "Máscara (CIDR):")" 3 1 "${AsDhcp[CIDR]}" 3 25 20 0 \
			"$(gettext "Gateway:")" 4 1 "${AsDhcp[GATEWAY]}" 4 25 20 0 \
			"$(gettext "DNS 1:")" 5 1 "${AsDhcp[DNS1]}" 5 25 20 0 \
			"$(gettext "DNS 2:")" 6 1 "${AsDhcp[DNS2]}" 6 25 20 0 \
			2>&1 >/dev/tty)

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			return
			;;
		"$D_OK")
			# extrai valores
			mapfile -t adhcp <<<"$dhcptext"
			AsDhcp[IFACE]="${adhcp[0]}"
			AsDhcp[IP]="${adhcp[1]}"
			AsDhcp[CIDR]="${adhcp[2]}"
			AsDhcp[GATEWAY]="${adhcp[3]}"
			AsDhcp[DNS1]="${adhcp[4]}"
			AsDhcp[DNS2]="${adhcp[5]}"

			# mensagem confirmação
			CONFIRM_MSG="$(printf "%s\n\n%s: %s\n%s: %s/%s\n%s: %s\n%s: %s %s" \
				"${BOLD}${RED}$(gettext "Aplicar essas configurações?")" \
				"${RESET}$(gettext "Interface")" "${AsDhcp[IFACE]}" \
				"$(gettext "IP")" "${AsDhcp[IP]}" "${AsDhcp[CIDR]}" \
				"$(gettext "Gateway")" "${AsDhcp[GATEWAY]}" \
				"$(gettext "DNS")" "${AsDhcp[DNS1]}" "${AsDhcp[DNS2]}")"

			#   dialog --yesno "$CONFIRM_MSG" 12 50
			if conf "=== DHCP ===" "$CONFIRM_MSG"; then
				LDHCP=true
			fi
			;;
		esac
		exec 3>&-
		return 0
	done
}

sh_create_empty_iptables_rules() {
	local CONFIG_FILE="$dir_install/etc/iptables/iptables.rules"

	sh_info_msg "%(gettext 'Aplicando configuração do iptables')"

	# cria novo arquivo
	cat >"$CONFIG_FILE" <<EOF
# Empty iptables rule file
*filter
:INPUT ACCEPT [0:0]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [0:0]
COMMIT
EOF
}

sh_build_and_apply_dhcpcd_config() {
	local CONFIG_FILE="$dir_install/etc/dhcpcd.conf"
	local BACKUP_FILE="${CONFIG_FILE}.$(sh_diahora)"

	sh_info_msg "%(gettext 'Aplicando configuração do dhcpd')"
	# backup somente se existir
	if [[ -f "$CONFIG_FILE" ]]; then
		mv -f "$CONFIG_FILE" "$BACKUP_FILE"
	fi

	# cria novo arquivo
	cat >"$CONFIG_FILE" <<EOF
# See dhcpcd.conf(5) for details.

interface ${AsDhcp[IFACE]}
static ip_address=${AsDhcp[IP]}/${AsDhcp[CIDR]}
static routers=${AsDhcp[GATEWAY]}
static domain_name_servers=${AsDhcp[DNS1]} ${AsDhcp[DNS2]}
EOF

}

sh_choose_dm() {
	declare -A aFlag
	declare -A aDm
	local x

	aDm[lxdm]="Leve e simples, ideal para computadores antigos, Xorg"
	aDm[sddm]="Display manager moderno, Xorg e Wayland"
	aDm[gdm]="Moderno, Xorg e Wayland"
	aDm[lightdm]="Leve e flexível, Xorg (Wayland limitado)"
	aDm[None]="None"

	for x in "${!aDm[@]}"; do
		aFlag[$x]='off'
	done
	aFlag[$_DISPLAYMANAGER]='on'

	dm=$(${DIALOG} --title "=== ${cmsg_Dm^^} ===" \
		--default-item "$_DISPLAYMANAGER" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}" \
		0 0 0 \
		lxdm "${aDm[lxdm]}" "${aFlag[lxdm]}" \
		sddm "${aDm[sddm]}" "${aFlag[sddm]}" \
		gdm "${aDm[gdm]}" "${aFlag[gdm]}" \
		lightdm "${aDm[lightdm]}" "${aFlag[lightdm]}" \
		None "${aDm[None]}" "${aFlag[None]}" \
		2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac

	LDM=true
	_DISPLAYMANAGER="$dm"

	if $LHYPRLAND || $LSWAY || $LMANGO; then
		if [[ "$dm" != "None" && "$dm" != "sddm" ]]; then
			if conf "=== ${cmsg_Dm^^} ===" \
				"\n${BOLD}${CYAN}$(gettext "É aconselhável escolhar sddm para compatibilidade")" \
				"\n\n${BOLD}${RED}$(gettext "Deseja ativar esse Display Manager?")\n\n"; then
				_DISPLAYMANAGER="sddm"
			fi
		fi
	fi

	LAUTOLOGIN=false
	if [[ $dm != "None" ]]; then
		if conf "=== ${cmsg_Dm^^} ===" \
			"\n${BOLD}${WHITE}$(gettext "O login automático permite iniciar o ambiente gráfico")" \
			"\n$(gettext "sem solicitar usuário e senha no boot.")\n" \
			"\n${BOLD}${RED}$(gettext "Deseja ativar o login automático no Display Manager?")\n\n"; then
			LAUTOLOGIN=true
		fi
	fi

	#debug $_DISPLAYMANAGER

}

pcount() {
	local -i nargs="$#"

	echo $nargs
	[[ nargs -gt 0 ]] && return 0 || return 1
}

strtoarray() {
	local anew

	IFS=' ' read -r -a anew <<<"$1"
	echo "${anew[@]}"
}

lenarraystr() {
	local new=$1

	read -ra ADDR <<<"$new"
	echo "${#ADDR[@]}"
}

sh_chooseKeymap() {
	if notconf "=== ${cmsg_Teclado^^} ===" "${cmsg_LayoutAtual} : \Zb\Z1${AConfLocale[_KEYMAP]}${RESET}" "\n\n${cmsgSetKeyboardLayout}?"; then
		LKEYMAP=true
		return 0
	fi

	localectl 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER

	if [ "${PIPESTATUS[0]}" -eq 0 ]; then
		items=$(localectl list-keymaps | sort -V)
	else
		items=$(find /usr/share/kbd/keymaps/ -iname "*.gz" -type f -printf "%f\n" | sort -V)
	fi

	options=()

	for item in ${items}; do
		options+=("${item%%.*}" "")
	done

	keymap=$(${DIALOG} \
		--colors \
		--default-item "${AConfLocale[_KEYMAP]}" \
		--backtitle "${ccabec}" \
		--ok-label "${cmsg_Aceitar}" \
		--cancel-label "${cmsg_ButtonBack}" \
		--title "${cmsg_descTeclado}" \
		--menu "${cmsg_MENU}" \
		0 70 0 \
		"${options[@]}" 3>&1 1>&2 2>&3)

	nchoice=$?
	if ! ((nchoice)); then
		loadkeys "$keymap"
		AConfLocale[_KEYMAP]="$keymap"
		LKEYMAP=true
	fi
	return $nchoice
}

sh_chmod_tmp() {
	local cfile="$dir_install/etc/runit/core-services/03-filesystems.sh"

	sh_info_msg "${cmsg_Ajustando} ${cmsg_Permissoes}"
	if [[ -e "$cfile" ]]; then
		{
			echo ''
			echo 'msg $(gettext "Ajustando permissões para") /tmp and /var/tmp ...'
			echo 'mkdir -p /tmp /var/tmp'
			echo 'chmod 1777 /tmp /var/tmp'
		} >>"$cfile"
	fi
	evaluate_retval "$?" "$err_not_fatal"
}

display_config() {
	sh_disk_part_info
	SETUP="$(padr "${cmsg_Extra2} :" 30 ' ') \Zb\Z0${AsUser[cuser]} - [${AsUser[cfullname]}] ${RESET}\
                                         \n$(padr "Hostname :" 30 ' ') \Zb\Z0${AsUser[chostname]}${RESET}\
                                  \n$(padr "${cmsg_Teclado} :" 30 ' ') \Zb\Z0${AConfLocale[_KEYMAP]}${RESET}\
                                         \n$(padr "Timezone :" 30 ' ') \Zb\Z0${AConfLocale[_TIMEZONE]}${RESET}\
              \n$(padr "${cmsg_redewifi} (${cmsg_opcional}) :" 30 ' ') \Zb\Z0${AConfWifi[_NETWORK]}${RESET}\
                                   \n$(padr "${cmsg_Mirror} :" 30 ' ') \Zb\Z0${AConfMirror[url_mirror]} - ${AConfMirror[location]}${RESET}\
                                   \n$(padr "${cmsg_Source} :" 30 ' ') \Zb\Z0${AConfMirror[_SOURCE]}${RESET}\
                                   \n$(padr "${cmsg_Extra6} :" 30 ' ') \Zb\Z0${AConfDisk[_DEVICE]} | $(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 2) | $(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 4)${RESET}\
    \n$(padr "${cmsg_BootLoader} (${AConfDisk[_DISKTABLE]}) :" 30 ' ') \Zb\Z0${AConfDisk[_BOOTLOADER]} | $(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 2) | $(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 4)${RESET}\
                          \n$(padr "Detect SO's (os-prober) :" 30 ' ') \Zb\Z0$(sh_getyes "${AConfDisk[_OSPROBER]}")${RESET}\
                                  \n$(padr "${cmsg_Extra11} :" 30 ' ') \Zb\Z0"${_WINDOWMANAGER[*]}"${RESET}\
                                      \n$(padr "${cmsg_Dm=} :" 30 ' ') \Zb\Z0"${_DISPLAYMANAGER[*]}"${RESET}\
                                            \n$(padr "Audio :" 30 ' ') \Zb\Z0"${AConfAudio[_AUDIOSERVER]}"${RESET}\
                                     \n$(padr "Customizacao :" 30 ' ') ${YELLOW}$(sh_getTrueFalse "$LCUSTOM") \Zb\Z0${aCustomPackages[*]}${RESET}\
                                              \n$(padr "Fde :" 30 ' ') \Zb\Z0$(sh_getinfoFde "$LFDE")${RESET}\
                                              \n$(padr "Lvm :" 30 ' ') \Zb\Z0$(sh_getinfoFde "$LVM")${RESET}\
                            \n$(padr "FileSystem/Mountpoint :" 30 ' ') ${BOLD}${GREEN}↓↓↓\
    \n\Zb\Z4$(sh_getmntpoint)${RESET}${RESET}
  "
}

sh_getTrueFalse() {
	local var="$1"
	[[ "$var" == 'true' ]] && echo 'Sim' || echo 'Nao'
}

sh_getinfoFde() {
	local lfde="$1"
	local str
	local _vg
	str="$(sh_getyes "$lfde")"
	_vg="${AConfFde[vg]}"

	case $lfde in
	1)
		str+="|$_vg|${AConfFde[partition]}|/$_vg/root=${AConfFde[lvroot]}"
		[[ -n "${AConfFde[lvswap]}" ]] && str+="|/$_vg/swap=${AConfFde[lvswap]}"
		[[ -n "${AConfFde[lvvar]}" ]] && str+="|/$_vg/var=${AConfFde[lvvar]}"
		[[ -n "${AConfFde[lvhome]}" ]] && str+="|/$_vg/home=${AConfFde[lvhome]}"
		;;
	esac
	echo "$str"
}

sh_getmntpoint() {
	local str
	local nlen=13
	local sep="\xe2\x94\x82"

	str+="\
$(printf "%-${nlen}s" PARTITION)	\
$(printf "$sep%-${nlen}s" FSTYPE)	\
$(printf "$sep%-${nlen}s" SIZE)	\
$(printf "$sep%-${nlen}s" LABEL)	\
$(printf "$sep%-${nlen}s" MOUNTPOINT)	\
$(printf "$sep%-${nlen}s" NEWFSTYPE)	\
$(printf "$sep%-${nlen}s" FORMAT)"
	str+="\n"

	for i in $(echo "${!Amntpoint[@]}" | tr ' ' '\n' | sort); do
		str+="$(printf "%-${nlen}s" "$i")	\
$(printf "$sep%-${nlen}s" "$(sh_splitarray "${AARRAY_PART_DEVICES[$i]}" 7)")	\
$(printf "$sep%-${nlen}s" "$(sh_splitarray "${AARRAY_PART_DEVICES[$i]}" 2)")	\
$(printf "$sep%-${nlen}s" "$(sh_splitarray "${AARRAY_PART_DEVICES[$i]}" 5)")	\
$(printf "$sep%-${nlen}s" "$(sh_splitarray "${Amntpoint[$i]}" 1)")	\
$(printf "$sep%-${nlen}s" "$(sh_splitarray "${Amntpoint[$i]}" 2)")	\
$(printf "$sep%-${nlen}s" "$(sh_getyes "$(sh_splitarray "${Amntpoint[$i]}" 3)")")"
		str+="\n"
	done
	echo "$str"
}

sh_gethidden-password() {
	local senha="$1"
	echo -e "${senha//?/*}"
}

sh_checkInstall() {
	local cmdsearch

	if ! $LMIRROR; then
		alerta "${cmsg_Mirror^^}" "${RED}✗ ${cmsg_Mirror} ${cmsg_NotConfDefault}"
		DEFITEM="${cmsg_Mirror}"
		return 1
	elif ! $LSOURCE; then
		alerta "${cmsg_Source^^}" "${RED}✗ ${cmsg_Source} ${cmsg_NotConfDefault}"
		DEFITEM="${cmsg_Source}"
		return 1
	elif ! $LDISK; then
		alerta "${cmsg_Disco^^}" "${RED}✗ ${cmsg_Disco} ${cmsg_NotConfDefault}"
		DEFITEM="${cmsg_Disco}"
		return 1
	elif ! $LFSREVISED; then
		alerta "${GREEN}${cmsg_FileSystem^^}" "${RED}✗ ${WHITE}${cmsg_FileSystem} ${cmsg_Revised^^}"
		DEFITEM="FileSystem"
		return 1
	elif ! sh_validate_filesystem; then
		DEFITEM="FileSystem"
		return 1
	elif ! $LGRUB; then
		alerta "${cmsg_BootLoader^^}" "${RED}✗ ${cmsg_NotConfBootLoader}"
		DEFITEM="${cmsg_BootLoader}"
		return 1
	elif ! $LKEYMAP; then
		alerta "${cmsg_Teclado^^}" "${RED}✗ ${cmsg_NotConfTeclado}"
		DEFITEM="${cmsg_Teclado}"
		return 1
	elif ! $LTIMEZONE; then
		alerta "TIMEZONE" "${RED}✗ ${cmsg_NotConfTimezone}"
		DEFITEM="Timezone"
		return 1
	elif ! $LWM; then
		alerta "WM" "${RED}✗ ${cmsg_NotConfWm}"
		DEFITEM="Wm"
		return 1
		#	elif [ -z "$LWIFI" ]; then
		#		alerta "WIFI" "${cmsg_NotConfWifi}"
		#		DEFITEM="Wifi"
		#		return 1
	elif ! $LEXTRA; then
		alerta "EXTRA" "${RED}✗ ${RED}${cmsg_NotConfExtra}${RESET}"
		DEFITEM="${cmsg_Usuario}"
		return 1
	fi

	if ! sh_check_mirror; then
		DEFITEM="${cmsg_Mirror}"
    sh_choose_mirror
    return 1
	fi

	display_config
	if conf "${cmsg_ConfSalva^^}" "$SETUP " \
		"${RESET}\n${cmsg_AcompanheInstalacao} : ${YELLOW}sudo tail -f $BOOTLOG${RESET}" \
		"\n${cmsg_OuPeloTerminal}                : ${YELLOW}(ctrl+alt+f8)${RESET}" \
		"\n\n${BOLD}${RED}${cmsg_descInstalar}?"; then
		clear
		return 0
	fi
	return 1
}

sh_grubInstall() {
	local cfile="$dir_install/etc/default/grub"
	local xuuidfde

	cat >$cfile <<EOF
#
# Configuration file for GRUB.
#
GRUB_DEFAULT=0
#GRUB_HIDDEN_TIMEOUT=0
#GRUB_HIDDEN_TIMEOUT_QUIET=false
GRUB_TIMEOUT=5
GRUB_DISTRIBUTOR="Void"
# Uncomment to use basic console
#GRUB_TERMINAL_INPUT="console"
# Uncomment to disable graphical terminal
#GRUB_TERMINAL_OUTPUT=console
#GRUB_BACKGROUND=/usr/share/void-artwork/splash.png
#GRUB_GFXMODE=1920x1080x32
#GRUB_DISABLE_LINUX_UUID=true
#GRUB_DISABLE_RECOVERY=true
# Uncomment and set to the desired menu colors.  Used by normal and wallpaper
# modes only.  Entries specified as foreground/background.
#GRUB_COLOR_NORMAL="light-blue/black"
#GRUB_COLOR_HIGHLIGHT="light-cyan/blue"
GRUB_CMDLINE_LINUX_DEFAULT="loglevel=3 quiet splash"
GRUB_THEME="/boot/grub/themes/voidbr/theme.txt"
EOF

	echo "GRUB_THEME=/boot/grub/themes/voidbr/theme.txt" >>"$dir_install/etc/default/grub"
	if $LOSPROBER; then
		echo "GRUB_DISABLE_OS_PROBER=false" >>"$dir_install/etc/default/grub"
	else
		echo "GRUB_DISABLE_OS_PROBER=true" >>"$dir_install/etc/default/grub"
	fi

	if $LFDE; then
		sh_chroot_job "Alterando /etc/default/grub" "sed -i 's/^GRUB_CMDLINE_LINUX_DEFAULT=/#&/' /etc/default/grub"
		xuuidfde=$(blkid -o value -s UUID "${AConfFde[partition]}")
		{
			echo "GRUB_CMDLINE_LINUX_DEFAULT='splash quiet udev.log_priority=3 libata.noacpi=1 loglevel=4 rd.luks.allow-discards rd.lvm.vg=${AConfFde[vg]} rd.luks.uuid=$xuuidfde'"
			echo "GRUB_ENABLE_CRYPTODISK=y"
		} >>"$dir_install/etc/default/grub"

		sh_chroot_job "Criando chave aleatória" "dd bs=1 count=64 if=/dev/urandom of=/boot/volume.key"
		sh_chroot_job "Adicionando a chave ao volume cryptografado" "printf ${AConfFde[passphrase]} | cryptsetup luksAddKey ${AConfFde[partition]} /boot/volume.key --key-file=-"
		sh_chroot_job "Alterando permissões para proteger a chave" "chmod 000 /boot/volume.key; chmod -R g-rwx,o-rwx /boot"
		echo "${AConfFde[vg]}	UUID=$xuuidfde	/boot/volume.key	luks" >>"$dir_install/etc/crypttab"
		echo 'install_items+=" /boot/volume.key /etc/crypttab "' >>"$dir_install/etc/dracut.conf.d/10-crypt.conf"
	fi

	sh_cmd_job "${cmsg_Ajustando} /etc/grub.d/" "
    rm -f ${dir_install}/etc/grub.d/*new* || true
  "

	if $LBIOS; then
		sh_chroot_job "${cmsg_Instalando} GRUB $(gettext 'para a plataforma') i386-pc" "
		   grub-install ${AConfDisk[_BOOTLOADER]} --target=i386-pc --force
	   "
	fi

	if $LEFI; then
		# --removable   = garante boot universal via Fallback
		# --no-nvram    = não mexe na BIOS
		sh_chroot_job "${cmsg_Instalando} GRUB $(gettext 'para a plataforma') x86_64-efi" "
		   grub-install ${AConfDisk[_BOOTLOADER]} --target=$TARGET_EFI --efi-directory=/boot/efi --boot-directory=/boot --bootloader-id=$cnickefi --removable --no-nvram
	   "
		#		sh_mkefiroaming
	fi

	sh_change_grub

	if ! $LVM; then
		sh_chroot_job "${cmsg_Gerando} grub.cfg" "
		   grub-mkconfig -o /boot/grub/grub.cfg
	   "
	fi
}

sh_is_running_hypervisor() {
  grep -qw hypervisor $dir_install/proc/cpuinfo
}

sh_limineInstall() {
  sh_chroot_job "${cmsg_Instalando} Limine $(gettext 'para a plataforma') x86_64-efi" "
    mkdir -p /boot/efi/EFI/BOOT
    mkdir -p /boot/efi/EFI/limine
    mkdir -p /boot/efi/limine
    cp -a /usr/share/limine/BOOTX64.EFI /boot/efi/EFI/BOOT/
    cp -a /usr/share/limine/BOOTX64.EFI /boot/efi/EFI/limine/
    cp -a /usr/share/limine/limine-bios.sys /boot/efi/limine/
    rm -rf /boot/EFI
  "

  if $LBIOS; then
		sh_chroot_job "${cmsg_Instalando} Limine $(gettext 'para a plataforma') i386-pc" "
      limine bios-install ${AConfDisk[_BOOTLOADER]} 1
	   "
	fi

	if $LEFI; then
    if ! sh_is_running_hypervisor; then
  		sh_chroot_job "${cmsg_Instalando} Limine $(gettext 'para a plataforma') x86_64-efi" "
        efibootmgr -c \
          -d ${AConfDisk[_BOOTLOADER]} \
          -p 2 \
          -L 'Limine' \
          -l '\EFI\limine\BOOTX64.EFI'
    	"
    else
      vm_user="${SUDO_USER:-$(id -un)}"
      vm_home=$(getent passwd "$vm_user" | cut -d: -f6)
      vm_vars="$vm_home/.chili-fr/OVMF_VARS.4m.fd"

      virt-fw-vars \
        --inplace "$vm_vars" \
        --append-boot-filepath "$dir_install/boot/efi/EFI/limine/BOOTX64.EFI"
    fi

		sh_chroot_job "${cmsg_Instalando} Limine $(gettext 'para a plataforma') x86_64-efi" "
      update-limine || true
    "
	fi

}

confmulti() {
	xtitle="$1"
	shift
	${DIALOG} \
		--colors \
		--title "$xtitle" \
		--backtitle "$ccabec" \
		--yes-label "${cmsg_yeslabel}" \
		--no-label "${cmsg_nolabel}" \
		--yesno "$*" \
		10 60
	nchoice=$?
	return $nchoice
}

sh_cp_rootfs() {
	local lretval

	sh_info_msg "${cmsg_Descompactando} ISO"
	sh_execcopia
	lretval="$?"
	evaluate_retval "$lretval"

	clear
	rm -f $dir_install/etc/issue
	rm -f $dir_install/etc/motd
	return "$lretval"
}

sh_update_etc_issue() {
	sh_cmd_job "${cmsg_Ajustando} issue" '
    mv -f $dir_install/etc/issue.pos $dir_install/etc/issue
  ' $err_not_fatal
}

sh_touch_keys() {
	sh_cmd_job "Criando chaves" "mkdir -p keys" $err_not_fatal

	cat >keys/60:ae:0c:d6:f0:95:17:80:bc:93:46:7a:89:af:a3:2d.plist <<-EOF
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
		<plist version="1.0">
		<dict>
			<key>public-key</key>
			<data>LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQ0lqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FnOEFNSUlDQ2dLQ0FnRUF2clN6QlpNdmd2T0NJM0FYYk9qYQoycktSa0pTVE0zYy9FalRJZ0NnRFhndW05M0JQQ3RZOE1jRlZvQ1U0T2lYSEdmVG1xMzlCVk5wTHZMSEw5S2sxCnAyNzhTQmhYVk90YkIyRVZtREtudmZJREVUbGRMR3plN3JaTlJKZHR1TjJtWi9UVnJVQjlTMHlRYytJdWY0aHYKMytEOTdWSWRUSkhBN0FTcjA0MjhwcEVHSkd3U1NoWTJYSm05RDVJMEV1R1JXYzE0TUVHN2RJS0ppWWlNMG5FNAp0WW8yL3ZINElGVEhkblZBM2dZaVp5RG5idUNBUi84RVNmVVRVMTNTTkNPZGJ1ZGYzRDVCY3krVWlNREpJM1llCjRNRktCclQ5WmhaK0dzWEJaWTQ4MmxxaVppNkNMNXB0YzlJUUZmOC9lS1phOGphdGtpVkZWZ3JLZU5Sak9UeE4KZldTdTJua3hHTlgrYmhYWXRoaUdXbUpFWThjQ0FQeUZOK0x2NVJldEsyNTZnZGNiMnNrbUVxZWZ2MnpQQyt3VgpXQmJkSDViRDRiWmpuME42Wmw4MXJ2NVJ6RHZudmYrdkQxNGFGVWJaOFFGcXU3NVBiTDR3Nm1ZTTRsZE0vZzBSCjZOWEU4QXo5Qnd4MnREZlllS3V1dHcxRXBQbTJZdkZ5VFViMWNveUF1VEdSeUFhcDFVVEh2ZzlsaFBJSm1oRlEKSjVrQ2cxcUQ3QTMxV2wwUmxuZTZoZ0dvMFpaTko1Y0pNL3YvelNUS0pjdUZnd283SDBoT0dpbDZEZm84OUI0agpHOTZBQ3lQUytEVktQRlhSWXdqL0FrYkhwYVEyZjFGTUFvU3BCcXVEcUhoM3VrazcxS1g2ajE5dDBpRjhEUUxyCnZ0RlNTZElqREEwMmx3ZVY5TmFRcFdzQ0F3RUFBUT09Ci0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQo=</data>
			<key>public-key-size</key>
			<integer>4096</integer>
			<key>signature-by</key>
			<string>Void Linux</string>
		</dict>
		</plist>
	EOF

	cat >keys/76:75:c9:75:f1:97:35:78:3c:f9:73:d4:f6:04:0b:59.plist <<-EOF
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
		<plist version="1.0">
		<dict>
			<key>public-key</key>
			<data>LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQm9qQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FZOEFNSUlCaWdLQ0FZRUFxRlJBUnpFeVJMMlVJdU1GWkMwOApmSURJUWZrUzVNczRxOXFLUFhQdHMyN01mbDdDNFdoSHZYb2h2MnNKSzV1SThlOXM3OEJUL0gvbTJxallMWjZJCnF1NmNrZFJUZzNpakNYbTFqY21wRGh1eVpqVW5xaUdPcnBjZUpaTEtUZEYxQWRvZTI4NGRTTW92ZUZldVdlMkIKbkI1aml1ZGg4Szg2WThPdXptbldTN29PTWgzK3dMMEQrNHlGRVRrTTF0ckZCUC9GOUprZEx2dHVONWwyUmVJUQpYa0I5NHpIQ3l5dXkyUC9USnlQOFphSG0vckRwV2JJbUZLMzhsa05IcEczS1ZWYnl5bnFkZyszenJnTHNlR0ZXCnBnelFSdTdON3ByRGIvbDVQV3JSQ0tEUDJyWCtKZHFyWXBrUXh6SDNvTnpkZTd2cGFqejU2c2tzaDhUaHBIY2MKU2g3eTN2ZEJ3dHpDZFlqMkd0RlJaRzB4S21TY24rQ0hLR3dGQTdwdkkzVlVISXNLMm9IazlkSWlwZjkxbFMxVQp4ZUo5Y3RlQmdYZFJ0S0E3QXVTVTN0VzFRak1pNGJrWWVxZ1NUTFJueUxtbVYvR2MyT3BEMktOQVpuWnBIM2RrCnNtV25ibC9rZ05qa2NLTVQ2Rm5hSjdYNlJNdHZ4Mi9CWlcwMy9jQ25nRTR6QWdNQkFBRT0KLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg==</data>
			<key>public-key-size</key>
			<integer>3072</integer>
			<key>signature-by</key>
			<string>Vilmar Catafesta &lt;vcatafesta@gmail.com&gt;</string>
		</dict>
		</plist>
	EOF

	cat >keys/cc:e6:28:46:ff:19:07:a2:f0:4b:14:15:4f:89:1b:bc.plist <<-EOF
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
		<plist version="1.0">
		<dict>
			<key>public-key</key>
			<data>LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQm9qQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FZOEFNSUlCaWdLQ0FZRUEzcXVPbTNUNnc4RXN1ZnY2cnJIZwp6VTQ0S090dXF1M01HMS81Smd2UmJvb1hzS0swdW8wQkpzOFJaY2RLOWZRRWFNbUtHRUxvQVBiVEVQaGlZc0EzCnNkNy95QUR4bFNVcWR2VUl6Unh3M3E1VXFHNjQ5aFJjNnVHMjdxS2pZL0pxSXF5bGV5bmlaNUR0ejI5cm5Mc2wKTUFyT0YrNElsUk5LMnFHMy85RytETmVsVXFDeFRHQTVUd21DUlN5OXRQZ2dPQ3RnYmRuZjdCbHg4anB4MHo4MAo2RHl2ZDhPZ0ZRWEE4R3l5K2Mzc1N3Tm02Y1ZVUTV2clEzcGhCTnVuSzJDbHJzeE5iRGhzQnNXSklGd1JEeFJnCnpYQlJrSmxxL2M1L0crZTV2d0p1TWl6M09WYlh6TWo4WCtNYk5wMExkVzFVRU5tbmRYU1h3aForUllDQTRNMCsKSm1ZV0VRY0xKdnBIelB5cUZnaVhucnFMOUU0Tm4xK2t3TXZYOWEvTVhQcCtjRk12ajBUd01icWRDTTFGeGl2aQpUNkpCbUxOZG0vOXpQbUs5Yzg2UHRGVWNaaCtaV0NRMHBjTmRSWm5NZzJxVmdHUUdkeXFNQVN4QldpeVZrSHdHClkzSUcwZ3VaeVNJVnZmU0cyc0ZsQmZDWk9yK0pqNHNEbWhITXlNdlpoZGdGQWdNQkFBRT0KLS0tLS1FTkQgUFVCTElDIEtFWS0tLS0tCg==</data>
			<key>public-key-size</key>
			<integer>3072</integer>
			<key>signature-by</key>
			<string>Vilmar Catafesta &lt;vcatafesta@gmail.com&gt;</string>
		</dict>
		</plist>
	EOF

	cat >keys/3d:b9:c0:50:41:a7:68:4c:2e:2c:a9:a2:5a:04:b7:3f.plist <<-EOF
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
		<plist version="1.0">
		<dict>
			<key>public-key</key>
			<data>LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQ0lqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FnOEFNSUlDQ2dLQ0FnRUFvM1Nrc2p5N01PMmc4UWxsZjdCVQp1aXhFUWlqN3FOSVJrU0hrWWw4SGxxd1hOczFnK1FzbzhGV3dSbDNMbUpTVW5wT1BaOG1sdVdSajd4Y2pLbnVJCnhPRjBtQS8vM0lzTnVId2dYV2RLL0JiT29wNzFLZmt4aEE0WjhwK0hRbmhLMThxUkFPbG9xOGJ6WXZhaGI2NmEKemdWVTVFM1JzRDU4V0M2ZTFOUVdSSGpiMG1TM2h6M1NxVWVWZFVMT20zVzZBRTdYdWlVQVJOSEdyY1ljMXkyKwpxNjBKWHMrVk5sRlMwaGdDdnpqS3phMVg5cWtzQndzTmdaRlhBcXN1MGFKRndYSTEvM2R4ZWxBcUZFbnRMWVFSCjA4NHpaTDFmWDVRMWlacGNEaHVhTWZVREVZQjA4UzdKTTBYKytibkxxVnphVTZzc0RXdGtzbFJaNjNaVStISTUKemk5a0pyc25LcU5Pa3BKSnJTUkRyMGFvRjV2RDRwN20vYWdZKzdTRk5aaDZzOUJ5V0x3NDVFdytwalVVUmp5aQp6T01TSFhEM3YzczhFdzZkV29wbTVQTGUvUEgzZWFiMEVnbG9yVDZhYmRwaCtaVG4zaUxMWVVkSGNmQ1FDN01GCkNmVGl1TWt4SkJpaCtoOEhKaUlBdmpDZjVxdjZiaFpEUHpGRzAwbEpYRUZwNHRpbGp6eTFmbitiMkdLY3BDOWQKUUs4TEc3M0RFaXhacHBmU09IU09MMWYxVlBzZTBRdnl6d2RWc0xzR0dqV0FaZkw4WUdVZDl4Y20yeW5tVzFuNgpKTjl6NE9oZ3lRa21mNUFFUXpYSUxQR0d1MlREUVh5c05IRG0vUnRMMHJPN3cxbFVKSTVYOW1kbEZYd0xUWHI3ClYrU25aK3U5VCtFREg1NTV6WDJDZTgwQ0F3RUFBUT09Ci0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQo=</data>
			<key>public-key-size</key>
			<integer>4096</integer>
			<key>signature-by</key>
			<string>Void Linux</string>
		</dict>
		</plist>
	EOF

	cat >keys/7d:45:a3:eb:2a:0d:e7:14:e6:66:65:ce:27:4a:ac:e2.plist <<-EOF
		<?xml version="1.0" encoding="UTF-8"?>
		<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
		<plist version="1.0">
		<dict>
			<key>public-key</key>
			<data>LS0tLS1CRUdJTiBQVUJMSUMgS0VZLS0tLS0KTUlJQ0lqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FnOEFNSUlDQ2dLQ0FnRUFrNFFMWk9vQjI3NndLS1RFaTJDZQpGZnZpY1R4aGttWmVYaGk3WUJWTnZVMzZPeCt5VXZKNndZQ1VJZFNMMUdNdGNRN0dsM2tqOG94RjJRZXVJMisrCjk2SzF4K09WTnlnWXU2cVdZNkZuTEZHVHR2Q3FZK2crd2Fyb29oZFd1OU94RUl1ZVJrUzJndmtieFFYZm55Y2QKa1RSU1o4VzBSdFVXbE5XT3pDdHZ1ZzZMMUFadGlMc1FpblFlZndLb0hZVnJhZlFMS0h2aVI2Z2poaStZOFZwVwpxUFlncU4vU1FSZWhxQkRKNXJuTFpkbDczTTlOSTlPazJaOEZ6NXdFQU45dXNKa2lSRm1zVlRZOXF4dE9yQmc5Cmp6ZC9MaFBDY0VPWnFPSG05K1d4WXFJZzFNQkppRStLL0VEVjhENlBrN0lzZW93Y2FmaW9VSU9NRk5NNUZNV3IKSThlNDFtYVAxVjZ5VlZYM0dVRHlnNlA2bUNYQnNSQU4wOHovQ0RkUVlWakN1ZFhiNWtZK2dJMDhkK0JnTXZlYQpHcFZLMlBrT0tEZ1NmRTlrVDYzbTZYRGg4TnkrNGtDaHBaemR3YnZCTm1CRGQzazR2VVoxSWgwWVF0VEdXTlhGCjZjRTZtV3FpSE10SC9iaUNxYkVDSXR4S2RVdlkyMGxsRE5aaUJGeWNESGpSNTBjeFJjdkEvRW9XdlNlNm9ZT0EKeklnRjNXZDZnOHo3VWJxSE9Rc1FHd2NER3VjV1Q3SlAxN2VTQnYvYkt5N0xVUG9ONnZhOWNjSHhNdjJ5c0YxMQpiSFQxWUk0alpYa2d3OXZIUDdZcm9yN0xyYjIraWFxTWFXR1ZBZWlCY3I0amJnSmxGM3BUU2ljaFF4QjVkUEhJCkoxSGYzYmMwY2ZmRGpKMkoybGRpMk1jQ0F3RUFBUT09Ci0tLS0tRU5EIFBVQkxJQyBLRVktLS0tLQo=</data>
			<key>public-key-size</key>
			<integer>4096</integer>
			<key>signature-by</key>
			<string/>
		</dict>
		</plist>
	EOF

}

sh_copy_keys() {
	local destdirkeys="$dir_install/var/db/xbps/keys"

	sh_touch_keys
	if [[ ! -d $destdirkeys ]]; then
		sh_cmd_job "Criando diretorio de chaves em $destdirkeys" "mkdir -pv $destdirkeys" $err_not_fatal
	fi

	if [[ -d keys/ ]]; then
		sh_cmd_job "Copiando chaves locais para $destdirkeys" "cp -fv keys/*.plist $destdirkeys/" $err_not_fatal
	fi

	if [[ -d /var/db/xbps/keys/ ]]; then
		sh_cmd_job "Copiando chaves da ISO para $destdirkeys" "cp -fv /var/db/xbps/keys/*.plist $destdirkeys/" $err_not_fatal
	fi

}

sh_install_prereqs() {
	#	REQUIRED_PKGS="base-files xbps libgcc dash coreutils sed tar gawk limine grub-i386-efi grub-x86_64-efi binutils device-mapper dhclient dracut-network openresolv"
	#	REQUIRED_PKGS="base-container-full xbps libgcc dash coreutils sed tar gawk limine grub-i386-efi grub-x86_64-efi binutils device-mapper dhclient dracut-network openresolv"
	#	REQUIRED_PKGS="base-voidstrap xbps libgcc dash coreutils sed tar gawk limine grub-i386-efi grub-x86_64-efi binutils device-mapper dhclient dracut-network openresolv"
	REQUIRED_PKGS="base-voidstrap" # xbps tar xz"

	sh_cmd_job "Instalando bootstrap" \
		"LC_ALL=C xbps-install --rootdir "$dir_install" --repository=${url_mirror}/current -c $CACHEDIR -y $REQUIRED_PKGS -S"
}

sh_extract_root_fs() {
	if [[ "${AConfMirror[_SOURCE]}" = "local" ]]; then
		sh_cp_rootfs
	elif [[ "${AConfMirror[_SOURCE]}" = "network" ]]; then
		sh_tar_rootfs
	elif [[ "${AConfMirror[_SOURCE]}" = "networkFull" ]]; then
		sh_install_prereqs
	fi
}

sh_install_pkgs_in_chroot() {
	local msg="$1"
	local pkgs="$2"

	[[ -n "$pkgs" ]] || return 1

	sh_chroot_job "$msg" \
		"LC_ALL=C ${XBPS_INSTALL_UNPACK_ONLY} $pkgs" \
		"$err_fatal" \
		"$err_not_fatal"
}

sh_get_session_name() {
	local SESSION_NAME=xfce
	local NEWROOT="$dir_install"

	for x in "${_WINDOWMANAGER[@]}"; do
		case "$x" in
		"i3wm")
			SESSION_NAME=i3wm
			break
			;;
		"fluxbox")
			SESSION_NAME=fluxbox
			break
			;;
		"hyprland")
			SESSION_NAME=hyprland
			break
			;;
		"sway")
			SESSION_NAME=sway
			break
			;;
		"mango")
			SESSION_NAME=mango
			break
			;;
		"river")
			SESSION_NAME=river
			break
			;;
		"xfce")
			SESSION_NAME=xfce
			break
			;;
		"gnome")
			SESSION_NAME=gnome
			break
			;;
		"plasma")
			SESSION_NAME=plasma
			break
			;;
		"cinnamon")
			SESSION_NAME=cinnamon
			break
			;;
		"mate")
			SESSION_NAME=mate
			break
			;;
		"enlightenment")
			SESSION_NAME=enlightenment
			break
			;;
		*) continue ;;
		esac
	done
	echo $SESSION_NAME
}

sh_update_lxdm_conf() {
	local cfile="$dir_install/etc/lxdm/lxdm.conf"
	local cuser="${AsUser[cuser]}"

	sh_info_msg "Customizando $cfile"
	mkdir -p "$dir_install/etc/lxdm"

	if [[ "$LAUTOLOGIN" == true ]]; then
		autologin_line="autologin=$cuser"
		skip_pass_line="skip_password=1"
	else
		autologin_line="# autologin="
		skip_pass_line="skip_password=0"
	fi

	cat >"$cfile" <<EOF
[base]
$autologin_line
# timeout=10
session=/usr/bin/startxfce4
numlock=1
# xauth_path=/tmp
$skip_pass_line
greeter=/usr/libexec/lxdm-greeter-gtk

[server]
arg=/usr/bin/X -background vt7
# tcp_listen=1
# reset=1

[display]
gtk_theme=Clearlooks
bg=/usr/share/backgrounds/chililinux/abstract-art3.jpg
bottom_pane=1
lang=1
# keyboard=1
theme=vdojo
transparent_pane=1

[input]

[userlist]
disable=0
white=
black=
EOF
}

sh_update_sddm_conf() {
	local cfileconf="$dir_install/etc/sddm.conf"
	local cfile="$dir_install/etc/sddm.conf.d/00-autologin.conf"
	local cuser="${AsUser[cuser]}"
	local SESSION_NAME=$(sh_get_session_name)

	sh_info_msg "Customizando SDDM $cfile"
	mkdir -p "$dir_install/etc/sddm.conf.d"

	if [[ "$LAUTOLOGIN" == true ]]; then
		enable="true"
		user="$cuser"
		session="$SESSION_NAME"
	else
		enable="false"
		user=""
		session=""
	fi

	cat >"$cfile" <<EOF
[Autologin]
Enable=$enable
User=$user
Session=$session
EOF

	if $LHYPRLAND || $LSWAY || $LMANGO; then
		sed -i '/^\[General\]/,/^\[/{
    /^\[/!b
    /^\[General\]/!i\
  DisplayServer=wayland
  }' "$cfileconf"

	fi

}

sh_change_accountsservice_user() {
	local cuser="${AsUser[cuser]}"
	local f="${dir_install}/var/lib/AccountsService/users/${cuser}"

	sh_cmd_job "$(gettext 'Aplicando ajustes no AccountsService')" "
    mkdir -p "${dir_install}/var/lib/AccountsService/users"
    cat > ${f} << EOF
[org.freedesktop.DisplayManager.AccountsService]
BackgroundFile=''

[User]
Languages=${AConfLocale[_LOCALE]};
Session=
XSession=xfce
Icon=/home/${cuser}/.face
SystemAccount=false
EOF
  " "$err_not_fatal"
}

sh_update_gdm_conf() {
	local cfile="$dir_install/etc/gdm/custom.conf"
	local cuser="${AsUser[cuser]}"
	local SESSION_NAME
	SESSION_NAME=$(sh_get_session_name)

	sh_info_msg "Customizando GDM $cfile"
	mkdir -p "$dir_install/etc/gdm"

	if [[ "$LAUTOLOGIN" == true ]]; then
		auto_enable="True"
		auto_user="$cuser"
		session="$SESSION_NAME"
	else
		auto_enable="False"
		auto_user=""
		session=""
	fi

	cat >"$cfile" <<EOF
[daemon]
AutomaticLoginEnable=$auto_enable
AutomaticLogin=$auto_user
DefaultSession=${session}.desktop
EOF

	sh_change_accountsservice_user

}

sh_update_lightdm_conf() {
	local cuser="${AsUser[cuser]}"
	local cfile="$dir_install/etc/lightdm/lightdm.conf.d/00-autologin.conf"
	local cpath_state="$dir_install/var/lib/lightdm/.cache/lightdm-gtk-greeter"
	local cfile_state="$dir_install/var/lib/lightdm/.cache/lightdm-gtk-greeter/state"
	local SESSION_NAME
	SESSION_NAME=$(sh_get_session_name)

	sh_info_msg "Customizando LightDM $cfile"
	mkdir -p "$dir_install/etc/lightdm/lightdm.conf.d"

	if [[ "$LAUTOLOGIN" == true ]]; then
		auto_user="$cuser"
		session="$SESSION_NAME"
	else
		auto_user=""
		session=""
	fi

	cat >"$cfile" <<EOF
[Seat:*]
autologin-user=$auto_user
autologin-session=$session
EOF

	if ! $LSERVER && ! $ONLY_TTY; then
		mkdir -p $cpath_state
		cat >"${cfile_state}" <<EOF
[greeter]
last-user=$cuser
last-session=$SESSION_NAME
EOF
	fi

}

sh_install() {
	local user="${AsUser[cuser]}"
	local start_datetime
	local end_datetime
	local akernel=()
	local afirmware=()
	local abase=()
	local agrub=()

	aPackageDaemons+=(dbus)
	akernel+=("${AConfKernel[_KERNEL]:-linux}")
	#
	afirmware+=(linux-firmware)
	afirmware+=(linux-firmware-network)
	afirmware+=(wifi-firmware)
	afirmware+=(wireless_tools)
	afirmware+=(wpa_supplicant)
	afirmware+=(iwd)
	afirmware+=(iw)
	#
	abase+=(xfsprogs)
	abase+=(jfsutils)
	abase+=(bash-completion)
	abase+=(voidbr-base-config)
	abase+=(voidbr-vinstall)
	abase+=(voidbr-utils)
	abase+=(chili-utils)
	abase+=(fzf)
	abase+=(eza)
	abase+=(gettext)
	abase+=(chrony)
	abase+=(pigz)
	abase+=(zstd)
	abase+=(xz)
	abase+=(sed)
	abase+=(grep)
	abase+=(grc)
	abase+=(socklog)
	abase+=(socklog-void)
	abase+=(fastfetch)
	#

	agrub+=(dracut voidbr-plymouth-theme)
  if [[ "${AConfBootLoader[_LOADER]}" == 'grub' ]]; then
  	agrub+=(grub-i386-efi)
  	agrub+=(grub-utils)
  	agrub+=(grub-terminus)
  	agrub+=(grub-btrfs-runit)
  	agrub+=(voidbr-grub-theme)
  else
  	agrub+=(limine)
  	agrub+=(voidbr-limine-config)
  fi

	if $LVM; then
		abase+=(lvm2)
	fi

	if $LFDE; then
		abase+=(cryptsetup)
	fi

	ncounter=0
	sh_checkInstall || return 1

	#	dialog --title $BOOTLOG --begin 1 0 --tailbox "$BOOTLOG" 20 0 &
	reset
	sh_checkNet "$url_mirror" || return 1
	if [[ "${AConfMirror[_SOURCE]}" = "network" ]]; then
		sh_checkTarball
	fi

	sh_choose_common_packages

	start_time=$(date +%s) # Obtém o tempo de início em segundos desde a época Unix
	start_datetime=$(date)

	if $LEFI; then
		if sh_getBootEFI; then
      if [[ "${AConfBootLoader[_LOADER]}" == 'grub' ]]; then
		  	agrub+=(grub-"$TARGET_EFI")
      fi
 			agrub+=(efivar)
			agrub+=(efibootmgr)
		else
			LEFI=false
			LBIOS=true
		fi
	fi

	{
		sh_umount_fs

		if ! sh_make_fs; then
			die "Erro"
		fi

		sh_mount_fs
		sh_mk_working_dir
		sh_copy_keys
		sh_configure_custom_packages

		if sh_extract_root_fs; then
			sh_init_bind
			sh_cmd_job "${cmsg_Copiando} /etc/resolv.conf" "cp -f /etc/resolv.conf $dir_install/etc/"
			sh_update_mirror
			#			sh_checkNet "$url_mirror" || return 1

			# Go install
			#			sh_chroot_job "${cmsg_Atualizando} xbps" "
			#       LC_ALL=C xbps-install --sync --update xbps --yes
			#     "
			sh_chroot_job "${cmsg_Atualizando} xbps" "
			  LC_ALL=C xbps-install -Syuf voidbr-xbps
		  "
			sh_copy_keys # ao remover xbps a chave tamém é removida, recolocando!
			if [[ "${AConfMirror[_SOURCE]}" = "local" && "${LCUSTOM:-}" = "false" ]]; then
				#sh_chroot_job "${cmsg_AtualizandoRepositorio}" "LC_ALL=C xbps-install -Syu"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando') BootLoader" "${agrub[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Atualizando Pacotes Base')" "${abase[*]}"
			else
				#				sh_chroot_job "${cmsg_AtualizandoRepositorio}" "LC_ALL=C xbps-install -Syu"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Kernel')" "${akernel[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando') BootLoader" "${agrub[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Atualizando Pacotes Base')" "${abase[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Wifi Firmware')" "${afirmware[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Daemons')" "${aPackageDaemons[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Editores Texto Gráfico ')" "${aEditorX[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Editores texto')" "${aEditorTxt[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Downloaders')" "${aDownloader[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Utilitários')" "${aUtility[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Archiver tty')" "${aArchiverTty[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Extras')" "${aExtra[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Suplementos')" "${aSuplemento[*]}"
				sh_install_pkgs_in_chroot "$(gettext 'Instalando Pacotes customizados')" "${aCustomPackages[*]}"
			fi

      if [[ "${AConfBootLoader[_LOADER]}" == 'grub' ]]; then
  			sh_grubInstall
	    else
        sh_limineInstall
	    fi

			sh_make_fstab

			#debug $LONLY_TTY
			if ! $LONLY_TTY; then
				sh_update_Xkeymap
				if [[ "${AConfMirror[_SOURCE]}" = "local" && "${LCUSTOM:-}" = "false" ]]; then
					:
				elif $LSWAY; then
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM')" "${aDisplaymanager[*]}"
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM Config')" "${aDisplaymanagerConfig[*]}"
					:
				elif $LMANGO; then
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM')" "${aDisplaymanager[*]}"
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM Config')" "${aDisplaymanagerConfig[*]}"
					:
				elif $LHYPRLAND; then
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM')" "${aDisplaymanager[*]}"
					sh_install_pkgs_in_chroot "$(gettext 'Instalando Meta Pacote DM Config')" "${aDisplaymanagerConfig[*]}"
					:
				else
					sh_X11_minimal
				fi
			fi

			aDE=()
			for x in "${_WINDOWMANAGER[@]}"; do
				aDE+=("$x")
				case "$x" in
				"tty") : ;;
				"local")
					if $LCUSTOM; then
						sh_xfce_minimal
					fi
					;;
				"server") sh_server_minimal ;;
				"xorg") sh_xorg_minimal ;;
				"awesome") sh_awesome_minimal ;;
				"bspwm") sh_bspwm_minimal ;;
				"dwm") sh_dwm_minimal ;;
				"enlightenment") sh_enlightenment_minimal ;;
				"fluxbox") sh_fluxbox_meta_package ;;
				"hyprland") sh_hyprland_meta_package ;;
				"openbox") sh_openbox_minimal ;;
				"gnome") sh_gnome_minimal ;;
				"plasma") sh_plasma_minimal ;;
				"xfce") sh_xfce_minimal ;;
				"cinnamon") sh_cinnamon_minimal ;;
				"i3wm") sh_i3_minimal ;;
				"sway") sh_sway_meta_package ;;
				"mango") sh_mango_meta_package ;;
				"river") sh_river_minimal ;;
				"twm") sh_twm_minimal ;;
				"mate") sh_mate_minimal ;;
				"lxde") sh_lxde_minimal ;;
				"lxqt") sh_lxqt_minimal ;;
				esac
			done

			sh_make_user
			sh_update_hostname
			sh_update_rc_local

			if ! $SERVER; then
				sh_update_sshd
			fi

			sh_update_rc_conf
			sh_update_locale
			#sh_update_wpa_suplicant

			if [[ "${AConfAudio[_AUDIOSERVER]}" == 'Pipewire' ]]; then
				sh_activating_pipewire
			elif [[ "${AConfAudio[_AUDIOSERVER]}" == 'Pulseaudio' ]]; then
				sh_activating_pulseaudio
			fi

			#			debug "$_DISPLAYMANAGER" "\n${aDisplaymanager[*]}"

			case "$_DISPLAYMANAGER" in
			lxdm) sh_update_lxdm_conf ;;
			sddm) sh_update_sddm_conf ;;
			gdm) sh_update_gdm_conf ;;
			lightdm) sh_update_lightdm_conf ;;
			esac

			sh_activating_services

			if $LSERVER; then
				sh_create_empty_iptables_rules
				if $LDHCP; then
					sh_build_and_apply_dhcpcd_config
				fi
			fi

			sh_chroot_job "$(gettext 'Validando configuração para FINALIZAR')" "
                xbps-reconfigure --force glibc-locales
                xbps-reconfigure --force --all
            "
			sh_chroot_job "${cmsg_RemovendoPacotesAntigosObseletos}" "
			   rm -fv /var/cache/xbps/*.xbps
               rm -fv /var/cache/xbps/*.sig*
            "

			if $LHYPRLAND; then
				sh_configure_hyprland_audio
				sh_hack_hyprland_lib
			fi

			sh_chmod_tmp
			sh_update_etc_issue
			sh_umount_fs
			end_datetime=$(date)

			alerta_end "$APP" "${cmsg_FinalizadaComSucesso}\n" \
				"Start Date time  : $start_datetime" \
				"Finish Date Time : $end_datetime" \
				"Time elapsed     : ${RED}$(sh_time_elapsed)"
			nchoice="$?"
			case "$nchoice" in
			1) poweroff ;;
			3) reboot ;;
			esac
		else
			die "${cmsg_ERRO} tar #$?. ${cmsg_ErroTar} $_TARBALL_ROOTFS"
		fi
		exit 0
	} # > out & sh_monitor
	#	killall dialog
}

sh_time_elapsed() {
	local end_time=$(date +%s)                # Obtém o tempo de término em segundos desde a época Unix
	local duration=$((end_time - start_time)) # Calcula a duração em segundos
	local hours=$((duration / 3600))
	local minutes=$(((duration % 3600) / 60))
	local seconds=$((duration % 60))

	# Formatar os valores para terem sempre dois dígitos
	hours=$(printf "%02d" $hours)
	minutes=$(printf "%02d" $minutes)
	seconds=$(printf "%02d" $seconds)
	echo "$hours:$minutes:$seconds"
}

sh_monitor() {
	${DIALOG} \
		--clear \
		--colors \
		--title "$BOOTLOG" \
		--begin 10 10 --tailboxbg $BOOTLOG 20 120 \
		--and-widget \
		--begin 3 10 --progressbox "$last_msg" 5 30
}

sh_setMknodTty() {
	if [[ -c "$LOGGER" ]]; then
		return 0
	fi
	mknod -m 0620 /dev/tty8 c 4 8
	chown --reference=/dev/tty0 /dev/tty8
}

sh_seekstrarray() {
	local str=("$1")
	local search="$2"
	local result=

	for i in "${!str[@]}"; do
		if [[ "${str[$i]}" == "$search" ]]; then
			result="$i"
			break
		fi
	done
	echo "$result"
}

sh_splitarray() {
	local str=("$1")
	local pos="$2"
	local sep="${3:-'|'}"
	local array

	[[ $# -eq 3 && "$pos" = "|" && "$sep" =~ ^[0-9]+$ ]] && {
		sep="$2"
		pos="$3"
	}
	[[ $# -eq 2 && "$pos" = "$sep" ]] && {
		sep="$pos"
		pos=1
	}
	[[ $# -eq 1 || ! "$pos" =~ ^[0-9]+$ ]] && { pos=1; }

	IFS="$sep" read -r -a array <<<"$str"
	echo "${array[pos - 1]}"
}

sh_validate_filesystem() {
	local mntpoint
	local fstype
	local rootfound=0
	local homefound=0
	local varfound=0
	local bootfound=0
	local swapfound=0
	local dsk
	local ext=$(sh_getNvme)
	local flag
	local oldfstype

	sh_disk_part_info
	mensagem "$(gettext "=== DISCO/PARTIÇÃO ===")" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... Verificando disco e partições")"

	for i in "${!Amntpoint[@]}"; do
		_PART="$i"
		dsk="${_PART%%[p0-9]*([0-9])}"
		device="${AARRAY_DSK_DEVICES[$dsk]}"
		tran="$(sh_splitarray "${AARRAY_DSK_DEVICES[$dsk]}" 3)"
		partition="$(sh_splitarray "${AARRAY_PART_DEVICES[$_PART]}" 1)"
		oldfstype="$(sh_splitarray "${AARRAY_PART_DEVICES[$_PART]}" 7)"
		flag="$(sh_splitarray "${AARRAY_PART_DEVICES[$_PART]}" 8)"
		mntpoint="$(sh_splitarray "${Amntpoint[$_PART]}" 1)"
		fstype="$(sh_splitarray "${Amntpoint[$_PART]}" 2)"

		if [[ -z "$device" ]]; then
			${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} The disk configured in the file ($app_conf) does not exist in the system!\n\n\
${BOLD}${WHITE}Device : ${RED}$dsk\n" 8 75
			return 1
		fi

		if [[ -z "$partition" ]]; then
			${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} The partition configured in the file ($app_conf) does not exist in the system!\n\n\
${BOLD}${WHITE}Partition : ${RED}$_PART\n" 8 75
			return 1
		fi
	done

	if [[ -z "${AConfDisk[_BOOTLOADER]}" || -z "$LGRUB" ]]; then
		alerta "${cmsg_BootLoader^^}" "${cmsg_NotConfBootLoader}"
		DEFITEM="${cmsg_BootLoader}"
		return 1
	fi

	if [[ -z "${AConfDisk[_DISKTABLE]}" ]]; then
		sh_getBootEFI && AConfDisk[_DISKTABLE]='EFI' || AConfDisk[_DISKTABLE]='GPT_BIOS'
	fi

	sh_getBootEFI && LEFI=true || LEFI=false
	LBIOS=true

	if $LEFI; then
		if [[ "$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" 7)" != "gpt" ]]; then
			if ! infoconf "${cmsg_Disco}" "$(fdisk -l "${AConfDisk[_BOOTLOADER]}")" \
				"$(gettext "${YELLOW}=== UEFI ===")" "${BOLD}${RED}$(gettext "AVISO:") ${RESET}\
$(gettext "O sistema foi iniciado em modo UEFI, mas o disco selecionado para instalar o bootloader não possui tabela GPT.")\n\
$(gettext "Para instalação em modo UEFI, o disco precisa usar GPT.")\n\
$(gettext "Refaça a tabela de partição como GPT ou escolha outro disco.")\n\n\
${BOLD}${RED}$(gettext "Deseja continuar sem suporte a UEFI?")\n\n"; then
				return 1
			fi
			LEFI=false
		fi
	fi

	if $LEFI; then
		for i in {0..9}; do
			[[ "$(sh_splitarray "${AARRAY_PART_DEVICES[${AConfDisk[_BOOTLOADER]}${ext}${i}]}" 8)" = "BIOS boot" ]] && {
				LBIOS=true
				break
			} || LBIOS=false
		done
		if ! $LBIOS; then # alguns device block em lvm não são detectados pelo lsblk
			[[ -n "$(sh_splitarray "${AARRAY_PART_DEVICES[${AConfDisk[_BOOTLOADER]}${ext}1]}" 8)" ]] && LBIOS=true
		fi
	fi

	for i in "${!Amntpoint[@]}"; do
		_PART="$i"
		dsk="${_PART%%[p0-9]*([0-9])}"
		tran="$(sh_splitarray "${AARRAY_DSK_DEVICES[$dsk]}" 3)"
		oldfstype="$(sh_splitarray "${AARRAY_PART_DEVICES[$_PART]}" 7)"
		flag="$(sh_splitarray "${AARRAY_PART_DEVICES[$_PART]}" 8)"
		mntpoint="$(sh_splitarray "${Amntpoint[$_PART]}" 1)"
		fstype="$(sh_splitarray "${Amntpoint[$_PART]}" 2)"

		if [ "$mntpoint" = "/" ]; then
			((++rootfound))
			_PART_ROOT="$i"
			_ROOT_FSTYPE="$fstype"
		elif [ "$mntpoint" = "/home" ]; then
			((++homefound))
			_PART_HOME="$i"
		elif [ "$mntpoint" = "/var" ]; then
			((++varfound))
			_PART_VAR="$i"
		elif [ "$fstype" = "vfat" -a "$mntpoint" = "/boot/efi" ]; then
			if $LEFI; then
				if [[ "$flag" != "EFI System" ]]; then
					if ! conf "=== UEFI ===" "${BOLD}${RED}ERROR:${RESET} Could not verify selected partition for mountpoint ${BOLD}${BLUE}/boot/efi${RESET}\n\
whether it has the ${RED}'esp'${RESET} flag required for this purpose.\n
However flag of ${RED}'lvm disk'${RESET} partitions are not detected by lsblk.\n\
${RED}Change${RESET} the partition flag or continue install if you are sure it exists.\n\n\
Type disk     : ${BOLD}${WHITE}${tran}${RESET}\n\
Partition     : ${BOLD}${WHITE}${_PART}${RESET}\n\
mntpoint      : ${BOLD}${WHITE}${mntpoint}${RESET}\n\
current flag  : ${BOLD}${WHITE}${flag}${RESET}\n\
flag required : ${BOLD}${WHITE}EFI System${RESET}\n\
oldfstype     : ${BOLD}${WHITE}${oldfstype}${RESET}\n\
newfstype     : ${BOLD}${WHITE}${fstype}\n\n\
Do you wish to continue install ?"; then
						return 1
					fi
				fi
			fi
			if [[ "$dsk" != "${AConfDisk[_BOOTLOADER]}" ]]; then
				${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} The bootloader disk is different from the /boot/efi disk.
Bootloader : ${AConfDisk[_BOOTLOADER]}\n\
/boot/efi  : $dsk" 8 75
				return 1
			fi
			((++bootfound))
			_PART_BOOT="$i"
		elif [ "$fstype" = "swap" ]; then
			((++swapfound))
			_PART_SWAP="$i"
		fi
	done

	LFS=false
	LPARTITION=false
	if [ "$rootfound" -eq 0 ]; then
		${DIALOG} --colors --msgbox "${BOLD}${RED}ERRO:${RESET} o ponto de montagem do sistema de arquivos raiz (/) ainda não foi configurado." 8 75
		return 1
	elif [ $LEFI == "true" -a "$bootfound" -eq 0 ]; then
		info "=== UEFI ===" "\n\
${BOLD}${RED}ERROR:${RESET}\
The EFI system partition has not yet been configured.\n
Create it or define:\n
	- disk table : gpt\n
	- fstype     : FAT32\n
	- size       : minimum 100MB\n
	- mountpoint : /boot/efi\n"
		return 1
	elif [ "$rootfound" -gt 1 ]; then
		${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} the mount point for the root (/) file system was set on more than 1 partition." 8 75
		return 1
	elif [ "$bootfound" -gt 1 ]; then
		${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} the mount point for the boot file system (/boot/efi) has been configured on more than 1 partition." 8 75
		return 1
	elif [ "$homefound" -gt 1 ]; then
		${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} mount point for home (/home) has been configured on more than 1 partition." 8 75
		return 1
	elif [ "$varfound" -gt 1 ]; then
		${DIALOG} --colors --msgbox "${BOLD}${RED}ERROR:${RESET} mount point for var (/var) has been configured on more than 1 partition." 8 75
		return 1
	fi
	LFS=true
	LPARTITION=true
	return 0
}

sh_getyes() {
	local var="$1"

	case "$var" in
	0 | false)
		echo "${cmsg_nolabel}"
		;;
	1 | true)
		echo "${cmsg_yeslabel}"
		;;
	*)
		# fallback defensivo (opcional)
		echo "${cmsg_nolabel}"
		;;
	esac
}

sh_choose_Partition() {
	sh_umount_fs
	while true; do
		sh_disk_part_info
		local array=()
		local i
		local nlen=0
		local n=0
		local nc=0
		local result
		local exit_status
		local sep="\xe2\x94\x82"
		local oldfstype=
		local newfstype=
		local fsformat=
		local mntpoint=
		local oldmntpoint=
		local part=
		local -A Aoldfstype=()
		local dsk

		if ! $LDISK; then
			info "${cmsg_TitleFileSystem}" "\n\n${RED}$(gettext 'Disco de armazenamento não foi escolhido')${RST}"
			return 1
		fi

		if [[ "${#ARRAY_PART_DEVICES[@]}" -eq 0 ]]; then
			info "${cmsg_TitleFileSystem}" "\n\n${RED}$(gettext 'Disco de armazenamento não foi particionado')${RST}"
			return 1
		fi

		for i in "${ARRAY_PART_DEVICES[@]}"; do
			array[n++]="$i"
			if ((nlen < ${#i})); then
				nlen=${#i}
			fi
			array[n++]=$(
				printf "$sep%-11s$sep%6s$sep%-20s$sep%-20s$sep%-20s$sep%-9s$sep%-6s" \
					"${ARRAY_PART_FSTYPE[$nc]}" \
					"${ARRAY_PART_SIZE[$nc]}" \
					"${ARRAY_PART_LABEL[$nc]}" \
					"${ARRAY_PART_PARTTYPENAME[$nc]:0:20}" \
					"$(sh_splitarray "${Amntpoint[$i]}" 1)" \
					"$(sh_splitarray "${Amntpoint[$i]}" 2)" \
					"$(sh_getyes "$(sh_splitarray "${Amntpoint[$i]}" 3)")"
			)
			Aoldfstype+=([$i]="${ARRAY_PART_FSTYPE[$nc]}")
			((nc++))
		done
		((nlen += 6))
		part=$(${DIALOG} \
			--defaultno \
			--default-item "${AsFs[_DEVICE]}p1" \
			--backtitle "$ccabec" \
			--title "${cmsg_TitleFileSystem}" \
			--ok-label "${cmsg_Mudar}" \
			--cancel-label "${cmsg_ButtonFeito}" \
			--colors \
			--extra-button \
			--extra-label "${cmsg_info_particao}" \
			--menu "${cmsg_MENU}\n\n\
$(printf "%${nlen}s$sep%-11s$sep%6s$sep%-20s$sep%-20s$sep%-20s$sep%-8s$sep%s" \
				"PARTITION" \
				"FSTYPE" \
				"SIZE" \
				"LABEL" \
				"TYPENAME" \
				"MOUNTPOINT" \
				"NEWFSTYPE" \
				"FORMAT?")" \
			24 0 2 "${array[@]}" 2>&1 >/dev/tty)

		exit_status=$?
		dsk="${part%%[p0-9]*([0-9])}"

		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			LFS=true
			LPARTITION=true
			LFSREVISED=true
			return 0
			;;
		3)
			result=$(fdisk -x "$dsk")
			display_result "$result" "${cmsg_part_disk^^}"
			continue
			;;
		esac

		oldfstype="${Aoldfstype[$part]}"
		oldmntpoint="$(sh_splitarray "${Amntpoint[$part]}" 1)"

		if sh_choose_fstype "$oldfstype"; then
			newfstype=${AConfDisk[_FILESYSTEM]}
		else
			continue
		fi

		if [[ "$newfstype" != "swap" ]]; then
			if [[ -z "$newfstype" ]]; then
				unset 'Amntpoint["$part"]'
				continue
			fi

			if sh_getBootEFI && [[ "$newfstype" == "vfat" && -z "$oldmntpoint" ]]; then
				oldmntpoint='/boot/efi'
			fi

			if [[ "$newfstype" != "vfat" && -z "$oldmntpoint" ]]; then
				oldmntpoint='/'
			fi
			mntpoint=$(${DIALOG} \
				--colors \
				--title "$xtitle" \
				--backtitle "$ccabec" \
				--inputbox "$(gettext 'Por favor, especifique o ponto de montagem para') \n${CYAN}$part${RESET} -> $newfstype" 8 75 "$oldmntpoint" 2>&1 >/dev/tty)
			exit_status=$?
			if [[ $exit_status -eq 1 ]]; then
				continue
			elif [[ "$mntpoint" = "/usr" ]]; then
				${DIALOG} \
					--colors \
					--msgbox "${BOLD}${RED}ERROR:${CYAN} /usr ${RESET}$(gettext 'esse ponto de montagem não é suportado. Altere e tente novamente.') ex.: ${CYAN}/ ${RESET}para raiz, ${CYAN}/home${RESET}" \
					8 75
				continue
			elif [[ "$mntpoint" = "/" ]]; then
				if [[ "$newfstype" = "ntfs" ]]; then
					${DIALOG} \
						--colors \
						--msgbox "${BOLD}${RED}ERROR:${CYAN} FS ntfs ${RESET}$(gettext 'ponto de montagem raiz nao pode ser NFTS. Altere e tente novamente.')" \
						8 75
					continue
					AConfDisk[_FILESYSTEM]="$oldfstype"
				fi
				AConfDisk[_FILESYSTEM]="$newfstype"
			elif [[ -z "$mntpoint" ]]; then
				unset 'Amntpoint["$part"]'
				continue
			fi
		else
			mntpoint="none"
		fi

		${DIALOG} \
			--colors \
			--title "$xtitle" \
			--backtitle "$ccabec" \
			--yes-label "${cmsg_yeslabel}" \
			--no-label "${cmsg_nolabel}" \
			--yesno "Filesystem original : ${BLUE}$oldfstype${RESET}\n
New filesystem      : ${RED}$newfstype${RESET}\n\n
$(gettext "Criar um novo sistema de arquivos em") $part?" 8 75
		exit_status=$?
		if [ $exit_status -eq 0 ]; then
			fsformat=1
		elif [ $exit_status -eq 1 ]; then
			if [[ "$newfstype" = "swap" ]]; then
				unset 'Amntpoint["$part"]'
				continue
			fi
			fsformat=0
		else
			continue
		fi

		Amntpoint+=(["$part"]="$mntpoint|$newfstype|$fsformat")
		case $newfstype in
		"swap") Amkfs+=(["swap"]="mkswap") ;;
		*)
			Amkfs+=(["$newfstype"]="mkfs.$newfstype")
			LFS=true
			LPARTITION=true
			;;
		esac
		continue
	done
}

sh_chooseperfumery() {
	local -A Aperfumery
	local -A Aflag
	local -a array=()
	local exit_status
	local x

	Aperfumery[bash]=$(gettext "Ativar o bash para o usuario root")
	Aperfumery[bashrc]=$(gettext "Instalar bashrc.sh personalizado")
	Aperfumery[console]=$(gettext "Usar um terminal gráfico para o Carregador de Inicialização (GRUB)")
	Aperfumery[sshd]=$(gettext "Configurar servidor ssh")
	Aperfumery[sudo]=$(gettext "Enable sudo for login user")

	for x in "${!Aperfumery[@]}"; do
		Aflag[$x]='off'
		array+=("$x" "${Aperfumery[$x]}" "${Aflag[$x]}")
	done

	perf=$(${DIALOG} --title "$(gettext "=== PERFUMARIA ===")" \
		--default-item "$_WINDOWMANAGER" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--checklist "${cmsg_MENU}" \
		12 70 0 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac
	_PERFUMERY=($(strtoarray "$perf"))
	LPERFUMERY=1
}

sh_toBytes() {
	local ent mut num fra sai

	ent=${1^^}
	[[ ${ent} = "" ]] && ent=0B
	mut=${ent//[^BKMGT]/}
	num=${ent//[^[:digit:]]/}
	ent=${ent//$mut/}
	fra=${ent//[^,.]/}
	fra=${fra:+${ent//*[,.]/}}
	ent=0BKMGT
	ent=${ent//$mut*/}
	#mut=$((${#ent}-1))
	((mut = ${#ent} - 1, sai = num * 1024 ** mut))
	((ent = ${#sai} - ${#fra}))
	echo ${sai:0:$ent}
}

sh_ternario() {
	local retval="$1"
	[[ "$retval" -eq 0 ]] && {
		echo 1
		return 1
	} || {
		echo 0
		return 0
	}
}

sh_menu_language() {
	while true; do
		i18=$(${DIALOG} \
			--stdout --keep-tite --aspect 20 --clear \
			--default-item "$LC_DEFAULT" \
			--backtitle "$ccabec" \
			--clear \
			--title "${welcome}" \
			--ok-label "${cmsg_Aceitar}" \
			--cancel-label "${cmsg_Exit}" \
			--menu "\n${escolhaIdioma}:" \
			0 80 0 \
			0 "$(gettext "Português")" \
			1 "$(gettext "Inglês")" \
			2 "$(gettext "Alemão")" \
			3 "$(gettext "Francês")" \
			4 "$(gettext "Espanhol")" \
			5 "$(gettext "Italiano")")

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			exit 0
			;;
		esac
		LC_DEFAULT="$i18"
		LOCALE="${Alocale[$i18]}"
		#		sh_init "$@"
		break
	done
}

sh_run_binary() {
	local binary="${1}"
	local lang="${2}"
	local grafic="${3}"

	if [[ -n $(command -v "${binary}") || -n $(command -v ./"${binary}") ]]; then
		bash "${binary}" "$lang" "${grafic}"
		return 0
	fi

	msg "INFO" "$(log_info_msg "$(gettext "Aguarde...") ${cmsg_Gerando} test with "${binary}" ${xurl}")"
	evaluate_retval 1 "$err_not_fatal"
	info "=== ${binary} ===" \
		"\n${RED}✗ $(gettext "binário não foi localizado no") ${YELLOW}\$PATH${RESET}" \
		"${RED}✗ $(gettext "binário não foi localizado na pasta local:") ${YELLOW}$PWD${RESET}" \
		"${YELLOW}\n➡ $(gettext "DICA: instale o pacote voidbr-utils")"
	return 1
}

sh_getparamfile() {
	if ((LFILE)); then
		echo "- ${BOLD}${WHITE}[$app_conf]"
		return 0
	fi
	return 1
}

sh_main_menu() {
	local cOK="${RST}${BOLD}${GREEN}✓ ${RST}${YELLOW}"
	local cNOK="${RST}${BOLD}${RED}✗ ${cERRO}[${cmsg_Nao_definido}]${RST} ● "
	local cWARN="${RST}${YELLOW}"
	local cERRO="${RST}${UNDERLINE}${BOLD}${RED}"

	sh_disk_part_info

	while true; do
		sh_touchConf
		if [ -z "$DEFITEM" ]; then
			DEFITEM="${cmsg_Mirror}"
		fi

		ccabec="${baseccabec}${BLACK}${url_mirror} "
		$LMIRROR && MENU_MIRROR="${cOK}[${AConfMirror[_MIRROR]}]${RST} ● " ||
		            MENU_MIRROR="${cNOK}"
		$LSOURCE && MENU_SOURCE="${cOK}[${AConfMirror[_SOURCE]}]${RST} ● " ||
		            MENU_SOURCE="${cNOK}"
		$LDISK && MENU_DEVICE="${cOK}[${AConfDisk[_DEVICE]}]${RST} ● " ||
		          MENU_DEVICE="${cNOK}"
		$LLOADER && MENU_BOOTLOADER="${cOK}[${AConfBootLoader[_LOADER]}]${RST}" ||
		            MENU_BOOTLOADER="${cNOK}"
		$LGRUB && MENU_BOOTLOADER+="/${cOK}[${AConfDisk[_BOOTLOADER]}]${RST} ● " ||
		          MENU_BOOTLOADER+="/${cERRO}[${cmsg_Nao_definido}]${RST} ● "
		$LMKPARTED && { $LFSREVISED && MENU_FS="${cOK}[OK => revisado!]${RST} ● " ||
		                               MENU_FS="${cOK}[${cERRO}NOK${cWARN} => revise!]${RST} ● "; } ||
		                               MENU_FS="${cNOK}"
		$LKEYMAP && MENU_KEYMAP="${cOK}[${AConfLocale[_KEYMAP]}]${RST} ● " ||
		            MENU_KEYMAP="${cNOK}"
		$LTIMEZONE && MENU_TIMEZONE="${cOK}[${AConfLocale[_TIMEZONE]}]${RST} ● " ||
		              MENU_TIMEZONE="${cNOK}"
		$LLOCALE && MENU_LOCALE="${cOK}[${AConfLocale[_LOCALE]} ${AConfLocale[_REGION]}]${RST} ● " ||
		            MENU_LOCALE="${cNOK}"
		$LKERNEL && MENU_KERNEL="${cOK}[${AConfKernel[_KERNEL]}]${RST} ● " ||
		            MENU_KERNEL="${cNOK}"

		$LAUDIO && MENU_AUDIO="${cOK}[${AConfAudio[_AUDIOSERVER]}]${RST} ● " ||
			{ $LONLY_TTY && MENU_AUDIO="${cOK}[${AConfAudio[_AUDIOSERVER]}]${RST} ● " ||
			                MENU_AUDIO="${cMOK}"; }
		$LCUSTOM && MENU_CUSTOM="CUSTOM" ||
		            MENU_CUSTOM=""
		$LWM && MENU_WM="${cOK}[${_WINDOWMANAGER[*]} ${MENU_CUSTOM}]${RST} ● " ||
		        MENU_WM="${cNOK}"
		$LDM && MENU_DM="${cOK}[${_DISPLAYMANAGER}]${RST} ● " ||
		        MENU_DM="${cNOK}"
		#			{ $LONLY_TTY && MENU_DM="${cWARN}[${_DISPLAYMANAGER}]${RST} ● " || MENU_DM="${cERRO}[${cmsg_Nao_definido}]${RST} ● "; }
		$LEXTRA && MENU_EXTRA="${cOK}[OK]${RST} ● " ||
		           MENU_EXTRA="${cNOK}"

		#			"Sistema" "${MENU_KEYMAP}Configurações regionais" \
		#			"${cmsg_Mirror}" "${MENU_MIRROR}${cmsg_descMirror}" \

		menu=$(${DIALOG} \
			--backtitle "$ccabec" \
			--clear \
			--colors \
			--default-item "$DEFITEM" \
			--ok-label "${cmsg_Aceitar}" \
			--cancel-label "${cmsg_Sair}" \
			--extra-button --extra-label "${cmsg_Definicoes}" \
			--title "$APP - ${cmsg_MenuInstalacao} $(sh_getparamfile)" \
			--menu "${RESET}${cmsg_MENU}" \
			25 100 2 \
			"${cmsg_Source}" "${MENU_SOURCE}${cmsg_DefinirInstalacaoDeOrigem}" \
			"${cmsg_Disco}" "${MENU_DEVICE}${cmsg_descDisco}" \
			"FileSystem" "${MENU_FS}${cmsg_descFileSystem}" \
			"${cmsg_BootLoader}" "${MENU_BOOTLOADER}${cmsg_descBootLoader}" \
			"${cmsg_Teclado}" "${MENU_KEYMAP}${cmsg_descTeclado}" \
			"Timezone" "${MENU_TIMEZONE}${cmsg_descTimezone}" \
			"Locale" "${MENU_LOCALE}${cmsg_descLocale}" \
			"Kernel" "${MENU_KERNEL}${cmsg_descKernel}" \
			"Wm" "${MENU_WM}${cmsg_descWm}" \
			"Dm" "${MENU_DM}${cmsg_descDm}" \
			"Audio" "${MENU_AUDIO}${cmsg_DefinirAudioServer}" \
			"${cmsg_Usuario}" "${MENU_EXTRA}${cmsg_descExtra}" \
			"${cmsg_Instalar}" "${cmsg_descInstalar}" \
			'↑↓' '↓↑' \
			"${cmsg_Saude_disco}" "${cmsg_Testar_Saude_disco} ${AConfDisk[_HEALTH]}" \
			"Fde" "$(gettext 'Criptografia de disco completo + LVM (opcional)')" \
			"Lvm" "$(gettext 'Gerenciamento de Volume Lógico LVM (opcional)')" \
			"Vg" "Delete/Clear Volume Group (VG) from LVM (optional)" \
			"${cmsg_Tema}" "$(gettext 'Seletor de temas do dialog (opcional)')" \
			"${cmsg_Servicos}" "${cmsg_utilvoidservices}" \
			"Clonedisk" "$(gettext 'Utilitário para clonar discos (opcional)')" \
			"Wifi" "${cmsg_descWifi}" \
			"Prompt" "$(gettext 'Prompt de comando - Exit para voltar')" \
			"${cmsg_Sair}" "${cmsg_descSair}" \
			2>&1 >/dev/tty)

		if [ $? -eq 3 ]; then
			display_config
			info "${cmsg_ConfSalva^^}" "$SETUP"
			continue
		fi

		case "$menu" in
		"${cmsg_Mirror}") sh_choose_mirror "$@" && [ -n "$LMIRROR" ] && DEFITEM="${cmsg_Source}" ;;
		"${cmsg_Source}") sh_chooseSource && [ -n "$LSOURCE" ] && DEFITEM="${cmsg_Disco}" ;;
		"${cmsg_Disco}") sh_choose_disk && [ -n "$LDISK" ] && DEFITEM="FileSystem" ;;
		"FileSystem") sh_choose_Partition && [ -n "$LPARTITION" ] && DEFITEM="${cmsg_BootLoader}" ;;
		"${cmsg_BootLoader}") sh_choose_bootloadernew && [ -n "$LGRUB" ] && DEFITEM="${cmsg_Teclado}" ;;
		"${cmsg_Teclado}") sh_chooseKeymap && [ -n "$LKEYMAP" ] && DEFITEM="Timezone" ;;
		"Timezone") sh_chooseTimezone && [ -n "$LTIMEZONE" ] && DEFITEM="Locale" ;;
		"Locale") sh_chooseLocale && [ -n "$LLOCALE" ] && DEFITEM="Kernel" ;;
		"Kernel") sh_choose_kernel && [ -n "$LKERNEL" ] && DEFITEM="Wm" ;;
		"Wm") sh_choose_wm && [ -n "$LWM" ] && DEFITEM="Dm" ;;
		"Dm") sh_choose_dm && [ -n "$LDM" ] && DEFITEM="Audio" ;;
		"Audio") sh_choose_audioserver "$@" && [ -n "$LAUDIO" ] && DEFITEM="${cmsg_Usuario}" ;;
		"${cmsg_Usuario}") sh_confadduser "$@" && [ -n "$LEXTRA" ] && DEFITEM="${cmsg_Instalar}" ;;
		"${cmsg_Instalar}") sh_install ;;
		'↑↓') : ;;
		"${cmsg_Saude_disco}") sh_check_disk_health ;;
		"${cmsg_Tema}") sh_run_binary 'voidbr-dialog-theme-selector' ;;
		"${cmsg_Servicos}") sh_run_binary 'void-services' "$LC_DEFAULT" "-g" ;;
		"Clonedisk") sh_run_binary 'void-clonedisk' ;;
		"Fde") sh_confLvm && [ -n "$LFDE" ] && DEFITEM="${cmsg_Instalar}" ;;
		"Lvm") sh_confLvm && [ -n "$LVM" ] && DEFITEM="${cmsg_Instalar}" ;;
		"Vg") sh_chooseVg ;;
		"Wifi") sh_run_binary 'voidbr-wifi-setup' && DEFITEM="${cmsg_Instalar}" ;;
		"Prompt") bash "$@" && [ -n "$LWIFI" ] && DEFITEM="Prompt" ;;
		"${cmsg_Sair}") die "${cmsg_InstalacaoAbortada}..." ;;
		*)
			errorbeep
			${DIALOG} --clear \
				--title "$ccabecmin" \
				--colors \
				--yes-label "${cmsg_yeslabel}" \
				--no-label "${cmsg_nolabel}" \
				--yesno "\n${BOLD}${WHITE}${cmsg_SairSemInstalar}?" \
				8 70 && exit 0
			;;
		esac
	done
}

sh_version() {
	cat <<-EOF
		${bold}${cyan}${0##*/} v${_VERSION_}${reset}
		${bold}${black}Copyright (C) 2023 vcatafesta@gmail.com
		$(gettext 'Licença GPL v3+: GNU GPL versão 3 ou posterior') <https://gnu.org/licenses/gpl.html>
		$(gettext 'Este é um software livre: você é livre para alterá-lo e redistribuí-lo.')
		$(gettext 'NÃO HÁ QUALQUER GARANTIA, na máxima extensão permitida em lei.')${reset}
	EOF
}

sh_init() {
	while test $# -gt 0; do
		case $1 in
		-h | -H | --help)
			sh_usage
			exit $(($# ? 0 : 1))
			;;
		-V | --version)
			sh_version
			exit $(($# ? 0 : 1))
			;;
		-f | --file)
			LFILE=1
			if [[ -n "$2" && "${2:0:1}" != '-' ]]; then
				app_conf="$2"
				shift
			fi
			sh_checkRoot
			sh_loadconf
			;;
		-n | --nocolor)
			log_msg "$(gettext "Desligando saída de cores")"
			sh_unsetVarColors
			;;
		-q | --quiet)
			log_msg "$(gettext "Ativando resumo na saída")"
			quiet=1
			;;
		-g | --grafico)
			log_msg "$(gettext "Ligando modo gráfico")"
			grafico=1
			;;
		-i | -I | --install)
			sh_checkRoot
			LINSTALL=true
			appexec+=('sh_main_menu')
			;;
		-c | -C | --chroot)
			sh_checkRoot
			LCHROOT=true
			appexec+=('sh_dryrun')
			;;
		*) die "${cmsg_operNotSupported}: $1 $(gettext 'usar -h para ajuda')" ;;
		esac
		shift
	done
}

sh_getfullusernameloggeduser() {
	local passwd_fields
	IFS=: read -r -a passwd_fields <<<"$(grep -w "$USER" /etc/passwd)"
	echo "${passwd_fields[4]}"
}

function sh_getfullusernameloggeduserbyGetent() {
	local logged_user="${SUDO_USER:-$USER}" # Prioriza SUDO_USER, mas usa USER como fallback
	getent passwd "$logged_user" | cut -d ':' -f 5 | cut -d ',' -f 1
}

sh_getfullusernameloggeduserbyid() {
	local passwd_fields
	IFS=: read -r -a passwd_fields <<<"$(grep -w 1000 /etc/passwd)"
	echo "${passwd_fields[4]%%[,]*}"
}

sh_getusernameloggeduserbyid() {
	local passwd_fields
	IFS=: read -r -a passwd_fields <<<"$(grep -w 1000 /etc/passwd)"
	echo "${passwd_fields[0]}"
}

sh_getdevicefrompartition() {
	local _part="$1"
	echo "${_part%%[p0-9]*([0-9])}"
}

sh_confLvm() {
	local size
	local FdeText
	local arr
	local disk
	local _part
	local dsk
	local oldfstype
	local flag
	local mntpoint
	local fstype
	local i
	local rootfound=0
	local ctitlemenu
	local VGs
	local PVs

	if [[ "$menu" = "Fde" ]]; then
		ctitlemenu='FDE CONFIG'
		LCONFIGFDE=1
	else
		ctitlemenu='LVM CONFIG'
		LCONFIGFDE=0
	fi

	if ! $LDISK; then
		alerta "${RED}${REVERSE}$ctitlemenu ${cmsg_TitleDisco}" "${RED}${REVERSE}${cmsg_NotConfDisco^^}"
		DEFITEM="${cmsg_Disco}"
		return 1
	elif ! $LPARTITION; then
		alerta "${RED}${REVERSE}$ctitlemenu $(gettext "=== PARTIÇÃO ===")" "${RED}${REVERSE}${cmsg_NotConfFileSystem^^}"
		DEFITEM="FileSystem"
		return 1
	fi

	sh_disk_part_info
	mensagem "=== VGs ===" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... coletando informações sobre VGs")"
	VGs="$(vgs --noheadings)"
	mensagem "=== PVs ===" "\n\n${BOLD}${WHITE}$(gettext "Aguarde... coletando informações sobre PVs")"
	PVs="$(pvs --noheadings)"
	disk="${AConfDisk[_BOOTLOADER]}|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_TRAN")|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_SIZE")|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_PTTYPE")|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_MODEL")|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_LABEL")|\
$(sh_splitarray "${AARRAY_DSK_DEVICES[${AConfDisk[_BOOTLOADER]}]}" "$DSK_SERIAL")"

	for i in "${!Amntpoint[@]}"; do
		_part="$i"
		dsk="${_part%%[p0-9]*([0-9])}"
		size="$(sh_splitarray "${AARRAY_PART_DEVICES[$_part]}" 2)"
		oldfstype="$(sh_splitarray "${AARRAY_PART_DEVICES[$_part]}" 7)"
		flag="$(sh_splitarray "${AARRAY_PART_DEVICES[$_part]}" 8)"
		mntpoint="$(sh_splitarray "${Amntpoint[$_part]}" 1)"
		fstype="$(sh_splitarray "${Amntpoint[$_part]}" 2)"

		if [ "$mntpoint" = "/" ]; then
			AConfFde[partition]="$_part"
			((++rootfound))
			break
		fi
	done

	if [ "$rootfound" -eq 0 ]; then
		${DIALOG} \
			--colors \
			--msgbox "${BOLD}${RED}ERROR:${RESET} $(gettext 'o ponto de montagem para o sistema de arquivos raiz (/) ainda não foi configurado.')" \
			8 75
		return 1
	fi

	while true; do
		exec 3>&1
		FdeText=$(${DIALOG} \
			--title "=== $ctitlemenu ===" \
			--colors \
			--ok-label "${cmsg_Aceitar}" \
			--cancel-label "${cmsg_ButtonBack}" \
			--backtitle "$ccabec" \
			--insecure "$@" \
			--mixedform "${cmsg_MENU}\n\n$(gettext "O tamanho das partições é uma questão de preferência pessoal.")" \
			0 0 0 \
			"Disk: " 1 1 "$disk" 1 42 40 0 2 \
			"Partition: " 2 1 "$_part" 2 42 40 0 2 \
			"Size: " 3 1 "$size" 3 42 40 0 2 \
			"Old FS: " 4 1 "$oldfstype" 4 42 40 0 2 \
			"New FS: " 5 1 "$fstype" 5 42 40 0 2 \
			"Flag: " 6 1 "$flag" 6 42 40 0 2 \
			"Volume Group: " 7 1 "${AConfFde[vg]}" 7 42 25 0 0 \
			"Passphrase: " 8 1 "${AConfFde[passphrase]}" 8 42 20 0 1 \
			"Verify Passphrase: " 9 1 "${AConfFde[verifypassphrase]}" 9 42 20 0 1 \
			"Logical volume (/): " 10 1 "${AConfFde[lvroot]}" 10 42 15 0 0 \
			"Logical volume (/swap) (empty to none): " 11 1 "${AConfFde[lvswap]}" 11 42 15 0 0 \
			"Logical volume (/var)  (empty to none): " 12 1 "${AConfFde[lvvar]}" 12 42 15 0 0 \
			"Logical volume (/home) (empty to none): " 13 1 "${AConfFde[lvhome]}" 13 42 15 0 0 \
			2>&1 1>&3)

		exit_status=$?
		case $exit_status in
		"$D_ESC" | "$D_CANCEL")
			LFDE=false
			LVM=false
			return 1
			;;
		"$D_OK")
			mapfile -t arr <<<"$FdeText"
			AConfFde[vg]="${arr[6]}"
			AConfFde[passphrase]="${arr[7]}"
			AConfFde[verifypassphrase]="${arr[8]}"
			AConfFde[lvroot]="${arr[9]}"
			AConfFde[lvswap]="${arr[10]}"
			AConfFde[lvvar]="${arr[11]}"
			AConfFde[lvhome]="${arr[12]}"
			AConfFde[partition]="$_part"

			lvunitroot="${AConfFde[lvroot]: -1}"
			lvsizeroot="${AConfFde[lvroot]%$lvunitroot}"
			lvunitswap="${AConfFde[lvswap]: -1}"
			lvsizeswap="${AConfFde[lvswap]%$lvunitswap}"
			lvunitvar="${AConfFde[lvvar]: -1}"
			lvsizevar="${AConfFde[lvvar]%$lvunitvar}"
			lvunithome="${AConfFde[lvhome]: -1}"
			lvsizehome="${AConfFde[lvhome]%$lvunithome}"
			maxbytespartition="$(sh_toBytes "$size")"
			byteslvroot="$(sh_toBytes "${AConfFde[lvroot]}")"
			byteslvswap="$(sh_toBytes "${AConfFde[lvswap]}")"
			byteslvvar="$(sh_toBytes "${AConfFde[lvvar]}")"
			byteslvhome="$(sh_toBytes "${AConfFde[lvhome]}")"

			if grep -o -q "$_part " <<<"$PVs"; then
				if ! conf "=== FDE/LVM - $(gettext "Partição") === " \
					"\n$(gettext "Partição") : '$_part'\n$(gettext "Aparentemente,") $(gettext "a partição escolhida já está atribuída como PV no sistema.")\n\n${BOLD}${WHITE}$(gettext "Continuar de qualquer maneira?")\n\n"; then
					LFDE=false
					LVM=false
					continue
				fi
			fi

			if grep -o -q "${AConfFde[vg]} " <<<"$VGs"; then
				if ! conf "=== FDE/LVM - $(gettext "Grupo de Volume") === " \
					"\n$(gettext "Group de Volume") : '${AConfFde[vg]}'\n$(gettext "Aparentemente,") $(gettext "o VG existe no sistema.")\n\n${BOLD}${WHITE}$(gettext "Continuar mesmo assim?")\n\n"; then
					LFDE=false
					LVM=false
					continue
				fi
			fi

			if [[ -z "${AConfFde[vg]}" ]]; then
				if ! conf "=== FDE/LVM - $(gettext "Grupo de Volume") === " \
					"\nVolume Group = '${AConfFde[vg]}'\n$(gettext "O nome do grupo de volumes não pode estar vazio.")\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ $maxbytespartition -lt $((byteslvroot + byteslvswap + byteslvhome + byteslvvar)) ]]; then
				if ! conf "=== FDE/LVM - $(gettext "Volumes lógicos") === " \
					"\n$(gettext "A soma das partições excede o tamanho total do disco.")\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ -z "$lvunitroot" || "$lvunitroot" != @(K|M|G|T|%) ]]; then
				if ! conf "=== FDE/LM - $(gettext "Volume lógico raiz") === " \
					"\nThe logical volume root cannot be empty or minuscule in size and/or units out of scope (K|M|G|T|%)\nex: 25% [1-100]% or 10G [1-n](K|M|G|T).\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ -n "$lvunitswap" && "$lvunitswap" != @(K|M|G|T|%) ]]; then
				if ! conf "=== FDE/LVM - $("Volume lógico") swap === " \
					"\nThe logical volume swap cannot be empty or minuscule in size and/or units out of scope (K|M|G|T|%)\nex: 25% [1-100]% or 10G [1-n](K|M|G|T).\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ -n "$lvunithome" && "$lvunithome" != @(K|M|G|T|%) ]]; then
				if ! conf "=== FDE/LVM - $("Volume lógico") swap === " \
					"\nThe logical volume swap cannot be empty or minuscule in size and/or units out of scope (K|M|G|T|%)\nex: 25% [1-100]% or 10G [1-n](K|M|G|T).\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ -n "$lvunitvar" && "$lvunitvar" != @(K|M|G|T|%) ]]; then
				if ! conf "=== FDE/LVM - $("Volume lógico") var === " \
					"\nThe logical volume var cannot be empty or minuscule in size and/or units out of scope (K|M|G|T|%)\nex: 25% [1-100]% or 10G [1-n](K|M|G|T).\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			if [[ -z "${AConfFde[passphrase]}" || "${AConfFde[passphrase]}" != "${AConfFde[verifypassphrase]}" ]]; then
				if ! conf "=== FDE/LVM - $(gettext "Senha") === " \
					"\nPassphrases do not match and also not be empty.\n\n${BOLD}${WHITE}$(gettext "Novamente?")\n\n"; then
					LFDE=false
					LVM=false
					return 1
				fi
				continue
			fi

			AmntpointFDE=()
			AmntpointFDE+=(["/dev/${AConfFde[vg]}/root"]="root|$fstype|1|${AConfFde[lvroot]}|/")
			#					[[ -n "${AConfFde[lvswap]}" && "$(sh_toBytes "${AConfFde[lvswap]}")" -gt 0 ]] &&	AmntpointFDE+=(["/dev/${AConfFde[vg]}/swap"]="swap|swap|1|${AConfFde[lvswap]}|swap")
			#					[[ -n "${AConfFde[lvvar]}"  && "$(sh_toBytes "${AConfFde[lvvar]}")"  -gt 0 ]]	&&	AmntpointFDE+=(["/dev/${AConfFde[vg]}/var"]="var|$fstype|1|${AConfFde[lvvar]}|/var")
			#					[[ -n "${AConfFde[lvhome]}" && "$(sh_toBytes "${AConfFde[lvhome]}")" -gt 0 ]]	&&	AmntpointFDE+=(["/dev/${AConfFde[vg]}/home"]="home|$fstype|1|${AConfFde[lvhome]}|/home")
			[[ -n "${AConfFde[lvswap]}" ]] && AmntpointFDE+=(["/dev/${AConfFde[vg]}/swap"]="swap|swap|1|${AConfFde[lvswap]}|swap")
			[[ -n "${AConfFde[lvvar]}" ]] && AmntpointFDE+=(["/dev/${AConfFde[vg]}/var"]="var|$fstype|1|${AConfFde[lvvar]}|/var")
			[[ -n "${AConfFde[lvhome]}" ]] && AmntpointFDE+=(["/dev/${AConfFde[vg]}/home"]="home|$fstype|1|${AConfFde[lvhome]}|/home")
			;;
		esac
		exec 3>&-
		if ((LCONFIGFDE)); then
			LFDE=true
			LVM=true
		else
			LFDE=false
			LVM=true
		fi
		return 0
	done
}

sh_make_fsFde() {
	local i
	local format
	local fstype
	local _part
	local label

	sh_info_msg "Formatando e cryptografando a unidade : ${AConfFde[partition]}"
	printf "${AConfFde[passphrase]}" | cryptsetup luksFormat --type luks1 "${AConfFde[partition]}" --key-file=- -v 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	evaluate_retval "${PIPESTATUS[1]}"

	sh_info_msg "Abrindo a unidade cryptografada: ${AConfFde[partition]}"
	printf "${AConfFde[passphrase]}" | cryptsetup luksOpen "${AConfFde[partition]}" "${AConfFde[vg]}" --key-file=- -v 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	evaluate_retval "${PIPESTATUS[1]}"
}

sh_make_fsLvm() {
	local i
	local _part
	local label
	local fstype
	local format
	local size
	local mntpoint
	local lvunit
	local aLVs=()

	if $LFDE; then
		sh_make_fsFde
	fi

	if $LFDE; then
		:
	else
		sh_info_msg "Criando a unidade fisica LVM: ${AConfFde[vg]}"
		pvcreate -ff "${AConfFde[partition]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
		evaluate_retval "${PIPESTATUS[0]}"
	fi

	sh_info_msg "Criando o grupo de volumes LVM: ${AConfFde[vg]}"
	if $LFDE; then
		vgcreate -ff "${AConfFde[vg]}" "/dev/mapper/${AConfFde[vg]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	else
		vgcreate -ff "${AConfFde[vg]}" "${AConfFde[partition]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	fi
	evaluate_retval "${PIPESTATUS[0]}"

	#order required for creation due to issue of 100%
	aLVs=("/dev/${AConfFde[vg]}/root" "/dev/${AConfFde[vg]}/swap" "/dev/${AConfFde[vg]}/var" "/dev/${AConfFde[vg]}/home")
	for i in "${aLVs[@]}"; do
		_part="$i"
		label="$(sh_splitarray "${AmntpointFDE[$i]}" 1)"
		fstype="$(sh_splitarray "${AmntpointFDE[$i]}" 2)"
		format="$(sh_splitarray "${AmntpointFDE[$i]}" 3)"
		size="$(sh_splitarray "${AmntpointFDE[$i]}" 4)"
		mntpoint="$(sh_splitarray "${AmntpointFDE[$i]}" 5)"
		lvunit="${size: -1}"

		[[ -z "$size" ]] && continue

		sh_info_msg "Criando o volume lógico: $label"
		if [[ "$lvunit" = "%" ]]; then
			lvcreate --yes --name "$label" -l "${size}FREE" "${AConfFde[vg]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
		else
			lvcreate --yes --name "$label" -L "${size}" "${AConfFde[vg]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
		fi
		evaluate_retval "${PIPESTATUS[0]}"

		if [[ "$format" = "1" ]]; then
			sh_info_msg "${cmsg_FormatandoParticao} ${_part} FS ${fstype,,}"
			declare -A fsparms=(
				[ext2]="-F   -L $label"
				[ext3]="-F   -L $label"
				[ext4]="-F   -L $label"
				[btrfs]="-f   -L $label"
				[f2fs]="-f   -l $label"
				[xfs]="-f   -L $label"
				[jfs]="-f   -L $label"
				[vfat]="-F32 -n EFI"
				[reiserfs]="-f   -l $label"
			)
			if [[ "$fstype" = "swap" ]]; then
				mkswap "$_part" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
			else
				mkfs.$fstype ${fsparms[$fstype]} $_part 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
			fi
			evaluate_retval "${PIPESTATUS[0]}"
		fi
	done
	_arch=$(xbps-uhelper arch)
	export XBPS_ARCH=${_arch}
	return 0
}

sh_clearVg() {
	local _vg="$1"
	local alogical=()
	local alogical=("/dev/$_vg/root" "/dev/$_vg/swap" "/dev/$_vg/home" "/dev/$_vg/var")
	local afs=("/dev/mapper/$_vg-root" "/dev/mapper/$_vg-swap" "/dev/mapper/$_vg-home" "/dev/mapper/$_vg-var")
	local i

	sh_umount_fs
	sh_info_msg "$(gettext 'Removendo LVs (Volumes Lógicos')"
	lvremove -ff /dev/"$_vg"/* 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	evaluate_retval "${PIPESTATUS[0]}" "$err_not_fatal"

	sh_info_msg "$(gettext 'Removendo VG (Volume Group)')"
	vgremove -ff "$_vg" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	evaluate_retval "${PIPESTATUS[0]}" "$err_not_fatal"

	sh_info_msg "$(gettext 'Removendo PVs (Volumes Fisícos)')"
	pvremove -ff "${AConfFde[partition]}" 2>&1 | tee -i -a "$BOOTLOG" >"$LOGGER"
	evaluate_retval "${PIPESTATUS[0]}" "$err_not_fatal"
}

sh_chooseVg() {
	local -A Avg
	local -A Aflag
	local array=()
	local defaultitem
	local fields
	local sorted_list
	local exit_status
	local sep="\xe2\x94\x82"

	sh_vg_info
	sorted_list=$(for key in "${!AARRAY_VG_DEVICES[@]}"; do echo "$key|${AARRAY_VG_DEVICES[$key]}"; done | sort -t\| -k2 -k1)

	if [[ ${#sorted_list} -eq 0 ]]; then
		alerta "=== VG ===" "${BOLD}${BLACK}${REVERSE}$(gettext "Info: Nenhum VG localizado no sistema.")"
		return 1
	fi

	defaultitem="${AConfFde[vg]}"
	while IFS='|' LC_ALL=C read -r -a fields; do
		x="${fields[0]}"
		Aflag[$x]='off'
		Aflag[$defaultitem]='on'
		array+=("$x" "$(printf "$sep%-15s$sep%10s$sep%10s$sep%-s" \
			"${fields[1]}" \
			"${fields[2]}" \
			"${fields[3]}" \
			"${fields[4]}")"
		"${Aflag[$x]}")
	done <<<"${sorted_list[@]}"

	vg=$(${DIALOG} --title "=== VG ===" \
		--colors \
		--cancel-label "${cmsg_ButtonBack}" \
		--ok-label "${cmsg_Aceitar}" \
		--radiolist "${cmsg_MENU}" \
		25 70 24 "${array[@]}" 2>&1 >/dev/tty)

	exit_status=$?
	case $exit_status in
	"$D_ESC" | "$D_CANCEL")
		return
		;;
	esac
	if ! infoconf "=== VG === " "$(lvs --noheadings "$vg")" \
		" === VG ===" "${BOLD}${RED}$(gettext 'AVISO'):${RESET} $(gettext "É importante lembrar que remover um VG")\
$(gettext "é uma operação irreversível e pode resultar em perda de dados.")\n
$(gettext "Certifique-se de fazer backup de seus dados.")\n
$(gettext "Todos os dados do disco serão apagados!")\n\n\
${BOLD}${WHITE}$(gettext "Deseja continuar?")"; then
		return 1
	fi
	sh_clearVg "$vg"
}

sh_setLanguage() {
	#	langmsg=('lang=("pt_BR"	"en_US" "de_DE" "fr_FR" "es_ES" "it_IT")')
	#	for xmsg in "${langmsg[@]}"; do eval "$xmsg"; done
	#	#echo "lang       ${#lang[@]} ${lang[@]} ${lang[$PT_BR]} ${lang[$EN_US]}"
	#	#echo "cmsg_ERRO ${#cmsg_ERRO[@]} ${cmsg_ERRO[@]} ${cmsg_ERRO[$PT_BR]} ${cmsg_ERRO[$EN_US]}"
	#	cmsg_LABEL[pt_BR]=$(gettext "Usar as teclas ${RED}↑ PARA CIMA ${RESET}e ${RED}↓ PARA BAIXO ${RESET}para navegar.\nUsar ${RED}TAB ${RESET}para alternar entre os botões e ${RED}ENTER ${RESET}para selecionar.")
	#	cmsg_LBL_check[pt_BR]=$(gettext "Usar as teclas ${RED}PARA CIMA ${RESET}e ${RED}PARA BAIXO ${RESET}para navegar.\nUsar ${RED}BARRA DE ESPAÇO ${RESET}para selecionar.\nUsar ${RED}TAB ${RESET}para alternar entre os botões e ${RED}ENTER ${RESET}para aceitar.")
	#	cmsg_Tarball_Corrompido[pt_BR]=$(gettext "\n${RED}Aparentemente o tarball rootfs ${_TARBALL_ROOTFS} está corrompido.\n\n${BOLD}${WHITE}Testar a integridade e reiniciar a instalação ?")
	#
	#	cmsg_LABEL1=$(gettext "Usar as setas ${CYAN}↑ ${RST}e ${CYAN}↓ ${RST}para navegar.")
	#	cmsg_LABEL2=$(gettext "Usar ${CYAN}TAB ${RST}para alternar entre os botões.")
	#	cmsg_LABEL3=$(gettext "Usar ${CYAN}ENTER ${RST}ou ${CYAN}BARRA DE ESPAÇO ${RST}para selecionar e aceitar.")
	#	#cmsg_LABEL1=$(gettext "Usar as setas ↑ e ↓ para navegar.")
	#	#cmsg_LABEL2=$(gettext "Usar TAB para alternar entre os botões.")
	#	#cmsg_LABEL3=$(gettext "Usar ENTER ou BARRA DE ESPAÇO para selecionar e aceitar.")
	#	cmsg_MENU="${cmsg_LABEL1}\n${cmsg_LABEL2}\n${cmsg_LABEL3}"

	cLB1="$(gettext "Use as teclas")"
	cLB2="$(gettext "PARA CIMA")"
	cLB3="$(gettext "e")"
	cLB4="$(gettext "PARA BAIXO")"
	cLB5="$(gettext "para navegar")"
	cLB6="$(gettext "Use")"
	cLB7="$(gettext "para alternar entre os botões")"
	cLB8="$(gettext "para selecionar/aceitar")"
	ccolor="${BOLD}${RED}"
	cmsg_MENU="$cLB1 ${ccolor}↑ $cLB2$RESET \
$cLB3 ${ccolor}↓ $cLB4$RESET \
$cLB5\n$cLB6 ${ccolor}⇥ TAB${RESET} \
$cLB7 ${ccolor}↵ ENTER${RESET} ou ${ccolor}BARRA DE ESPAÇO${RESET} $cLB8"

	cmsg_Tarball_Corrompido0=$(gettext "Aparentemente o tarball rootfs")
	cmsg_Tarball_Corrompido1=$(gettext "está corrompido.")
	cmsg_Tarball_Corrompido2=$(gettext "Testar a integridade e reiniciar a instalação ?")
	cmsg_Tarball_Corrompido="\n${RED}${cmsg_Tarball_Corrompido0} ${_TARBALL_ROOTFS} ${cmsg_Tarball_Corrompido1}\n\n${BOLD}${WHITE}${cmsg_Tarball_Corrompido2}"

	cmsg_TamanhoInsuficiente=$(gettext "Tamanho disco insuficiente para criar partições com swap")
	cmsg_DesejaProsseguir=$(gettext "Deseja prosseguir SEM partição de swap?")
	cmsg_DesejaCriarParticaoSwap=$(gettext "Deseja criar partição de swap ?")
	cmsg_AcompanheInstalacao=$(gettext "Acompanhe a evolução da instalação            ")
	cmsg_OuPeloTerminal=$(gettext "e/ou pelo terminal tty8        ")
	cmsg_PacotesDaImagemIso=$(gettext "Usar os pacotes já presentes na imagem ISO (clonagem da ISO)")
	cmsg_BaixadoDoRepositorioOficial=$(gettext "Usar tarball base e atualizar via internet (funciona em qualquer host Linux)")
	cmsg_BaixadoDoRepositorioOficialFull=$(gettext "Baixar todos os pacotes diretamente da internet (requer host Void Linux)")
	cmsg_DefinirInstalacaoDeOrigem=$(gettext "Selecionar fonte da instalação")
	cmsg_Definicoes=$(gettext "Definições")
	cmsg_naodefinido=$(gettext "não definido")
	cmsg_AjustandoSenhaUsuario=$(gettext "Ajustando senha usuário")
	cmsg_AtivandoBashUsuario=$(gettext "Ativando o bash para o usuário")
	cmsg_CriandoUsuario=$(gettext "Criando usuário")
	cmsg_MenuInstalacao=$(gettext "MENU DE INSTALAÇÃO")
	cmsg_DesMontandoAmbiente=$(gettext "Desmontando ambiente")
	cmsg_MontandoAmbiente=$(gettext "Montando ambiente")
	cmsg_EntrandoAmbienteChroot=$(gettext "Entrando no ambiente chroot")
	cmsg_MontandoParticao=$(gettext "Montando partição")
	cmsg_Gerando=$(gettext "Gerando")
	cmsg_Ajustando=$(gettext "Ajustando")
	cmsg_Copiando=$(gettext "Copiando")
	cmsg_Descompactando=$(gettext "Descompactando")
	cmsg_Atualizando=$(gettext "Atualizando")
	cmsg_Instalando=$(gettext "Instalando")
	cmsg_Configurando=$(gettext "Configurando")
	cmsg_Em="${cyan}=>${reset}"
	cmsg_ERRO=$(gettext "ERRO")
	cmsg_Aceitar=$(gettext "Aceitar")
	cmsg_Conectar=$(gettext "Conectar")
	cmsg_Configurar=$(gettext "Configurar")
	cmsg_Nao_definido=$(gettext "Não definido")
	cmsg_Mudar=$(gettext "Mudar")
	cmsg_Sair=$(gettext "Sair")
	cmsg_Saude_disco=$(gettext "Saúde disco")
	cmsg_Testar_Saude_disco=$(gettext "Fazer diagnostico da saúde do disco")
	cmsg_Instalar=$(gettext "Instalar")
	cmsg_Mirror=$(gettext "Espelho")
	cmsg_BootLoader="Bootloader"
	cmsg_DiskHealth="Health disk test"
	cmsg_FileSystem=$(gettext "Sistema de Arquivos")
	cmsg_Revised=$(gettext "não foi revisado!")
	cmsg_Disco=$(gettext "Armazenamento")
	cmsg_Teclado=$(gettext "Teclado")
	cmsg_SairSemInstalar=$(gettext "Sair sem instalar")
	cmsg_tty=$(gettext "Somente terminal, sem interface gráfica")
	cmsg_server=$(gettext "Servidor Void")
	cmsg_descMirror=$(gettext "Selecionar espelho dos pacotes")
	cmsg_descDisco=$(gettext "Selecionar disco e partições")
	cmsg_descFileSystem=$(gettext "Configurar sistema de arquivos e pontos de montagem")
	cmsg_descBootLoader=$(gettext "Escolher gerenciador e disco para o bootloader")
	cmsg_descTeclado=$(gettext "Selecionar layout do teclado")
	cmsg_descTimezone=$(gettext "Selecionar fuso horário")
	cmsg_descKernel=$(gettext "Selecionar versão do kernel")
	cmsg_descBootLoader=$(gettext "Selecionar gerenciador/disco de bootloader")
	cmsg_descLocale=$(gettext "Selecionar localidade do sistema")
	cmsg_descWm=$(gettext "Selecionar interface gráfico/gerenciador de janelas")
	cmsg_descDm=$(gettext "Selecionar gerenciador de login")
	cmsg_descWifi=$(gettext "Configurar rede Wi-fi (opcional)")
	cmsg_opcional=$(gettext "opcional")
	cmsg_Usuario=$(gettext "Usuário")
	cmsg_descExtra=$(gettext "Definir usuário,senha,hostname")
	cmsg_descInstalar=$(gettext "Iniciar instalação")
	cmsg_descSair=$(gettext "Encerrar instalação")
	cmsg_InstalacaoAbortada=$(gettext "Instalação abortada")
	cmsg_ChecandoRota=$(gettext "Checando rota de internet para o servidor")
	cmsg_falhaAbertura=$(gettext "ERRO: falha de abertura de")
	cmsg_operNotRoot=$(gettext "erro: você não pode realizar esta operação a menos que seja root.")
	cmsg_operNotSupported=$(gettext "erro: operação não suportada")
	cmsg_ButtonBack=$(gettext "Voltar")
	cmsg_ButtonFeito=$(gettext "Feito")
	cmsg_ButtonEscolher=$(gettext "Escolher")
	cmsg_ButtonSelecionar=$(gettext "Selecionar")
	cmsg_ButtonCancelar=$(gettext "Cancelar")
	cmsg_ButtonRevisar=$(gettext "Revisar")
	cmsg_ButtonProsseguir=$(gettext "Prosseguir")
	cmsg_info_disco=$(gettext "Info disco")
	cmsg_info_particao=$(gettext "Info partição")
	cmsg_ok=$(gettext "Ok")
	cmsg_Exit=$(gettext "Sair")
	cmsg_Select=$(gettext "Selecionar")
	cmsg_disco_origem=$(gettext "DISCO DE ORIGEM")
	cmsg_Source=$(gettext "Fonte")
	cmsg_disco_destino=$(gettext "DISCO DE DESTINO")
	cmsg_dest=$(gettext "Escolha o disco de DESTINO:")
	cmsg_yeslabel=$(gettext "Sim")
	cmsg_nolabel=$(gettext "Não")
	cmsg_todos_os_dados_serao_perdidos=$(gettext "Ao prosseguir, todos os dados disco DESTINO serão perdidos!")
	cwarning=$(gettext "=== AVISO ===")
	cmsg_DismountFileSystem=$(gettext "Desmontando sistema de arquivos")
	cmsg_FinalizadaComSucesso=$(gettext "Instalação finalizada com sucesso")
	cmsg_ErroTar=$(gettext "Falha ao descompactar o tarball")
	cmsg_Para=$(gettext "para")
	cmsg_ConfSalva=$(gettext "Configurações salvas para instalação")
	cmsg_Operacao=$(gettext "nenhuma operação especificada - usar -h para ajuda")
	cmsg_OneOperacao=$(gettext "apenas uma operação pode ser usada por vez")
	cmsg_TestandoDisco=$(gettext "Testando disco")
	cmsg_ContinuarParticionamento=$(gettext "Continuar com o particionamento em")
	cmsg_FormatandoParticao=$(gettext "Formatando partição")
	cmsg_AtivandoServico=$(gettext "Ativando serviço")
	cmsg_IniciandoServico=$(gettext "Iniciando serviço")
	cmsg_Permissoes=$(gettext "permissões")
	cmsg_ChecandoTarball=$(gettext "Checando existência do tarball")
	cmsg_VerificandoIntegridadeTarball=$(gettext "Verificando a integridade do tarball")
	cmsg_IniciandoDownload=$(gettext "Iniciando download de")
	cmsg_CriandoParticoes=$(gettext "Criando partições em")
	cmsg_CriandoPartSwap=$(gettext "Partição Swap")
	cmsg_CriandoDiretorio=$(gettext "Criando diretório")
	cmsg_AtualizandoRepositorio=$(gettext "Atualizando instalação")
	cmsg_RemovendoPacotesAntigosObseletos=$(gettext "Removendo pacotes antigos/absoletos")
	cmsg_InstalandoMetaPacotes=$(gettext "Instalando meta pacote X")
	cmsg_AtualizandoPacotesBase=$(gettext "Atualizando pacotes base")
	cmsg_AtualizandoPacotesAdicionais=$(gettext "Atualizando pacotes adicionais em")
	cmsg_part_disk=$(gettext "Visualizar partições do disco")
	cmsg_TitleDisco=$(gettext "=== ARMAZENAMENTO ===")
	cmsg_TitleFileSystem=$(gettext "=== FILE SYSTEM ===")
	cmsg_ChecandoParticoesMontadas=$(gettext "Checando por partições montadas no disco")
	cmsg_all_mounted_part=$(gettext "O disco selecionado contém partições montadas")
	cmsgSetKeyboardLayout=$(gettext "Escolher outro layout de teclado")
	cmsg_LayoutAtual=$(gettext "Layout atual")
	cmsg_umount_partition=$(gettext "Aguarde, Desmontando particao de trabalho")
	cmsg_ErroLeituraDisco=$(gettext "Erro de leitura do disco")
	cmsg_SemRota=$(gettext "Sem rota para o servidor")
	cmsg_CheckNet=$(gettext "Check sua conexão com a internet!")
	cmsg_CommandNotFound=$(gettext "não encontrei o comando")
	cmsg_ImpossivelContinuar=$(gettext "IMPOSSÍVEL CONTINUAR")
	cmsg_ImpossivelContinuar1=$(gettext "Esse script precisa dos comandos listados acima")
	cmsg_ImpossivelContinuar2=$(gettext "Instale-os e/ou verifique se estão no seu")
	cmsg_InstCommand=$(gettext "Instalar o(s) comando(s)")
	cmsg_RunNew=$(gettext "INFO: Rode novamente o aplicativo")
	cmsg_RunNewErro=$(gettext "ERRO na instalação dos comandos. Tente manualmente")
	cmsg_CopiandoCaminhoReserva=$(gettext "Criando inicialização padrão/reserva (roaming) para")
	cmsg_Error_not_fatal=$(gettext "Erro não fatal. Para mais detalhes veja o log")
	cmsg_Wm=$(gettext "gerenciador de janelas (wm)")
	cmsg_Dm=$(gettext "gerenciador de login (dm)")
	cmsg_TabelaMBR=$(gettext "Tabela MBR (dos)")
	cmsg_ExtraEfi=$(gettext "✓ Detectado: sistema iniciado em modo EFI")
	cmsg_ExtraEfiRecommended=$(gettext "✓ Recomendado: EFI")
	cmsg_ExtraNotEfi=$(gettext "✗ EFI não detectado: sistema iniciado em modo BIOS")
	cmsg_ExtraNotEfiRecommended=$(gettext "✓ Recomendado: GPT_BIOS ou MBR_BIOS")
	cmsg_ExtraIso=$(gettext "Detectado boot via ISO ↓ é recomendável instalar ↓")
	cmsg_ExtraNotIso=$(gettext "ISO não detectado ↓ é recomendável usar NETWORK ↓")
	cmsg_ExtraNotHostVoid=$(gettext "Host VOID não detectado ↓ é recomendável usar NETWORK↓")
	welcome=$(gettext "Bem-vindo ao instalador $APP")
	escolhaIdioma=$(gettext "Escolha o idioma")
	cmsg_Usuario=$(gettext "Usuário")
	cmsg_adduser1=$(gettext "Usuário não pode ser root! Novamente?")
	cmsg_adduser2=$(gettext "Usuário não pode estar vazio! Novamente?")
	cmsg_adduser3=$(gettext "Senha do usuário não pode ser vazia! Novamente?")
	cmsg_adduser4=$(gettext "Senha de root não pode ser vazia! Novamente?")
	cmsg_adduser5=$(gettext "Usuário não pode iniciar com números! Novamente?")
	cmsg_adduser6=$(gettext "Usuário não pode iniciar com letras maiúsculas! Novamente?")
	cmsg_adduserCancel=$(gettext "Cadastro de usuário cancelado")
	cmsg_redewifi=$(gettext "Rede Wi-Fi")
	cmsg_senhawifi=$(gettext "Senha Wi-Fi")
	cmsg_interfacewifi=$(gettext "Interface Wi-Fi")
	cmsg_mkfs=$(gettext "↓ é recomendável ext4 ↓")
	cmsg_utilvoidservices=$(gettext "Utilitário void-services (opcional)")
	cmsg_Servicos=$(gettext "Serviços")
	cmsg_Tema="$(gettext 'Estilo')"
	cmsg_Usage1=$(gettext "Instalar")
	cmsg_Usage2=$(gettext "Rodar chroot na partição instalada")
	cmsg_Usage3=$(gettext "Ativar modo gráfico")
	cmsg_Usage4=$(gettext "Saída resumida")
	cmsg_Usage5=$(gettext "Mostrar versão do aplicativo")
	cmsg_Usage6=$(gettext "Remove cores da saída")
	cmsg_Usage7=$(gettext "Este help")
	cmsg_Usage8=$(gettext "Carregar arquivo de configuração")
	cmsg_Extra1=$(gettext "Nome Completo")
	cmsg_Extra2=$(gettext "Nome usuario")
	cmsg_Extra3=$(gettext "Senha usuario")
	cmsg_Extra4=$(gettext "Senha root")
	cmsg_Extra6=$(gettext "Disco destino")
	cmsg_Extra11=$(gettext "Gerenciador Janelas")
	cmsg_Efi=$(gettext "EFI + GPT (recomendado) PCs modernos")
	cmsg_BiosGpt=$(gettext "BIOS + GPT Compatibilide avançada")
	cmsg_BiosMbr=$(gettext "BIOS + MBR Computadores antigos")
	cmsg_TabelaGPT=$(gettext "Tabela GPT")
	cmsg_NotConfDefault=$(gettext "não foi configurado!")
	cmsg_NotConfDisco=$(gettext "Disco não foi configurado!")
	cmsg_NotConfFileSystem=$(gettext "Filesystem não foi configurado!")
	cmsg_NotConfBootLoader=$(gettext "Bootloader não foi configurado!")
	cmsg_NotConfTeclado=$(gettext "Teclado não foi configurado!")
	cmsg_NotConfTimezone=$(gettext "Timezone não foi configurado!")
	cmsg_NotConfWm=$(gettext "Gerenciador de Janelas não foi configurado!")
	cmsg_NotConfWifi=$(gettext "Rede wifi não foi configurado!")
	cmsg_NotConfExtra=$(gettext "Usuário não foi configurado!")
	cmsg_DefinirAudioServer=$(gettext "Selecionar sistema de áudio")
}

sh_tar_rootfs() {
	sh_checkTarball || return 1
	sh_info_msg "${cmsg_Descompactando} rootfs"
	tar xpf "$_TARBALL_ROOTFS" --xattrs-include='*.*' --numeric-owner -C $dir_install 2>&1 | tee -i -a "$BOOTLOG" >$LOGGER
	ret="${PIPESTATUS[0]}"
	if [[ "$ret" -eq 0 ]]; then
		evaluate_retval "$ret"
		return "$ret"
	else
		evaluate_retval "$ret" "$err_not_fatal"
		sh_umount_fs
		if conf "${YELLOW}${_TARBALL_ROOTFS}" "${cmsg_Tarball_Corrompido}"; then
			sh_checkIntegrityTarball || return 1
			sh_install
		else
			die "${cmsg_ERRO} tar '#'$ret. ${cmsg_ErroTar} $_TARBALL_ROOTFS"
		fi
	fi
}

sh_execcopia() {
	ORIGEM="/run/rootfsbase/"
	DESTINO="$dir_install/"
	DEST="$dir_install"
	PONT='|/—\' # Ponteiros de um hélice do lado direito
	nVal=0

	sizeof() { du -s "$1" 2>/dev/null | cut -f1; }
	running() { ps "$1" | grep "$1" >/dev/null; }

	TITLE="INSTALL"
	#   INTERVALO=0.001
	INTERVALO=0.5
	#   PORCENTO=0
	DIR_DESTINO="$DESTINO/${ORIGEM##*/}"
	MSG="Aguarde, instalando... if=$ORIGEM of=$DESTINO"
	#   MSG=$(eval echo "$MSG")
	mensagem "Aguarde, computando arquivos para instalar"
	#   TOTAL=$(unsquashfs -ll "$LIVE_DIR" | awk '{n+=$3} END {print n}')
	#   TOTAL=$((TOTAL/1024))
	#  TOTALGB=$((TOTAL/1024))
	TOTAL=$(sizeof "$ORIGEM")
	TOTALGB=$((TOTAL / 1024))
	DISPONIVEL=$(df | grep "${DEST}" | awk '{print $4}' | head -1)
	DISPONIVEL=$((DISPONIVEL / 1024))

	if ((DISPONIVEL < TOTALGB)); then
		if ! confmulti "$(gettext '*** AVISO ***')" \
			"\n$(gettext 'Tamanho da partição destino é menor que o necessário')\n" \
			"\n$(gettext 'Partição destino')   : ${part}" \
			"\n$(gettext 'Tamanho disponível') : ${DISPONIVEL}G" \
			"\n$(gettext 'Tamanho necessário') : ${TOTALGB}G" \
			"\n\n$(gettext 'Sistema destino poderá não funcionar, continuar?')"; then
			#           sh_stop_bind
			#           sh_stop_mount
			#           sh_main_menu "$@"
			return 1
		fi
	fi

	log="/tmp/${_APP_}.log"
	[ -e "$log" ] && rm -f "$log"

	rsync -crav "$ORIGEM" "$DESTINO" 1>&2 >"$log" &
	export CPPID=$!

	#  trap sh_trapErro 2 15
	#trap "kill $CPPID" 2 15
	(
		while running "$CPPID"; do
			((nval >= 4)) && nval=0
			COPIADO=$(sizeof "$DIR_DESTINO")
			PERCENTAGEM=$((COPIADO * 100 / TOTAL))
			COPIADOMB=$((COPIADO / 1024))
			LASTFILE=$(tail -n1 "$log")
			[[ "$PERCENTAGEM" -gt 100 ]] && PERCENTAGEM=100
			${DIALOG} --colors \
				--title $TITLE \
				--gauge "$MSG                                       \n$(gettext 'Falta') ${RED}${REVERSE}$((100 - PERCENTAGEM))%${RESET} $(gettext 'para completar a tarefa') \Zb\Z1${PONT:nval:1}\ZB\Zn \
                                    \n\n$(gettext 'Destino')    : ${BLUE}${REVERSE}${AConfDisk[_DEVICE]}$dir_install${RESET}
                                    \n$(gettext 'Disponivel') : ${DISPONIVEL}MB\
                                    \n$(gettext 'Total')      :  ${TOTALGB}MB\
                                    \n$(gettext 'Copiado')    :  ${BLUE}${REVERSE}${COPIADOMB}MB${RESET}\
                                    \n$(gettext 'Arquivo')    : ${LASTFILE}\
                                    \n" 13 130 0 <<<$PERCENTAGEM
			((nval++))
			#           sleep $INTERVALO
		done
	)
	return 0
}

sh_populate_mountpoints() {
	local parent="${AConfDisk[_DEVICE]}"
	local dev fs mp
	local formatar=1

	# zera o array global
	Amntpoint=()

	while read -r dev fs mp; do
		# swap não tem mountpoint
		if [[ "$fs" == "swap" ]]; then
			mp="none"
		fi

		mp="${mp:-none}"
		fs="${fs:-unknown}"
		Amntpoint["$dev"]="$mp|$fs|$formatar"
	done < <(
		lsblk -lnpo NAME,FSTYPE,MOUNTPOINT "$parent" | tail -n +2
	)
}

sh_rebind_amntpoint_device() {
	local new_device="${AConfDisk[_DEVICE]}"
	local old_device
	local dev newdev
	local -A _new

	# array vazio? nada a fazer
	((${#Amntpoint[@]})) || return 0

	# descobre o device antigo a partir da primeira chave
	for dev in "${!Amntpoint[@]}"; do
		old_device="${dev%p*}"
		break
	done

	# se for o mesmo device, não altera
	[[ "$old_device" == "$new_device" ]] && return 0

	# copia mudando o prefixo do device
	for dev in "${!Amntpoint[@]}"; do
		newdev="${dev/#$old_device/$new_device}"
		_new["$newdev"]="${Amntpoint[$dev]}"
	done

	# substitui o array original
	Amntpoint=()
	for dev in "${!_new[@]}"; do
		Amntpoint["$dev"]="${_new[$dev]}"
	done
}

sh_rebuild_amntpoint_for_new_disk() {
	local device="${AConfDisk[_DEVICE]}"
	local efi_set=false
	local efi_set=false
	local swap_set=false
	local efi_set=false
	local root_set=false
	local home_set=false
	local fs

	[[ -n "$device" ]] || return 1

	#   # se já existe algo desse device, não refaz
	#   for fs in "${!Amntpoint[@]}"; do
	#      [[ "$fs" == "$device"* ]] && return 0
	#   done
	#
	Amntpoint=()

	while read -r line; do
		eval "${line//=/_=}"

		# só partições
		[[ "$TYPE_" == "part" ]] || continue

		# --- CASO 1: FSTYPE EXISTE ---
		if [[ -n "$FSTYPE_" ]]; then
			case "$FSTYPE_" in
			vfat)
				Amntpoint["$PATH_"]="/boot/efi|vfat|1"
				efi_set=true
				continue
				;;
			swap)
				Amntpoint["$PATH_"]="none|swap|1"
				swap_set=true
				continue
				;;
			*)
				fs="$FSTYPE_"
				;;
			esac

		# --- CASO 2: FSTYPE VAZIO → PARTTYPENAME ---
		else
			case "$PARTTYPENAME_" in
			*BIOS*)
				continue
				;;
			*EFI*)
				Amntpoint["$PATH_"]="/boot/efi|vfat|1"
				efi_set=true
				continue
				;;
			*swap*)
				Amntpoint["$PATH_"]="none|swap|1"
				swap_set=true
				continue
				;;
			*NTFS*)
				Amntpoint["$PATH_"]="/home|ntfs|1"
				home_set=true
				continue
				;;
			*"Linux"*)
				fs="ext4"
				;;
			*)
				continue
				;;
			esac
		fi

		# --- FILESYSTEM NORMAL (ext4, xfs, etc) ---
		case "$PARTLABEL_" in
		ROOT)
			Amntpoint["$PATH_"]="/|$fs|1"
			root_set=true
			;;
		HOME)
			Amntpoint["$PATH_"]="/home|$fs|1"
			home_set=true
			;;
		*)
			case "$PTTYPE_" in
			gpt) Amntpoint["$PATH_"]="none|$fs|0" ;;
			dos)
				if ! $root_set; then
					Amntpoint["$PATH_"]="/|$fs|1"
					root_set=true
				else
					if ! $home_set; then
						Amntpoint["$PATH_"]="/home|$fs|1"
						home_set=true
					else
						Amntpoint["$PATH_"]="none|$fs|0"
					fi
				fi
				;;
			esac
			;;
		esac

	done < <(
		lsblk -fPAo PTTYPE,TYPE,NAME,PATH,SIZE,TRAN,MODEL,LABEL,SERIAL,FSTYPE,PARTTYPENAME,PARTLABEL "$device" |
			grep -P 'TYPE="(part)"' |
			sort -k5,5 -k2,2
	)
	((${#Amntpoint[@]})) && LMKPARTED=true || LMKPARTED=false
}

sh_check_lock() {
	if [[ -e "$LOCKFILE" ]]; then
		# Verifica se o processo ainda existe
		local pid
		pid=$(cat "$LOCKFILE")
		if kill -0 "$pid" 2>/dev/null; then
			die "O script já está em execução (PID: $pid)."
			exit 1
		fi
	fi
	echo $$ >"$LOCKFILE"
	trap 'rm -f "$LOCKFILE"; exit' INT TERM EXIT
}

sh_checkUpdatePackages() {
	local TMP_FILE="/tmp/$(basename "$0").restarted"
	local PackagesToUpdate=(void-install)

	sh_msg_job "Distro detectada : ${CYAN}${DISTRO}${RST}"

	if [[ "$DISTRO" = @(void|void-live|voidlinux|voidbr) ]]; then
		# adiciona repositorios inexistentes no /etc/xbps.d/00-repository-main.conf
		#sh_add_repo

		if [[ ! -f "$TMP_FILE" ]]; then
			if conf "** UPDATE - ${APP} **" "É fortemente recomendado sincronizar e atualizar este utilitário antes da instalação. \n\n${AMARELO}Deseja proceder ?"; then
				sh_cmd_job_infobox "Aguarde alguns instantes, sincronizando e atualizando..." \
					"xbps-install -Syuf --ignore-file-conflicts "${PackagesToUpdate[@]}" &>/dev/null"
				sh_msg_job "Reiniciando o script pela primeira vez..."
				touch "$TMP_FILE"
				exec "$0" "$@"
			fi
		fi
		# verifica dependencias
		#check_dependencies
	else
		touch "$TMP_FILE"
	fi
}

sh_check_internet() {
	local url="8.8.8.8" # Servidor DNS do Google, sempre online
	local timeout=2     # Tempo limite reduzido para resposta rápida
	local pipe_test="1"

	if sh_cmd_job "$(gettext 'Testando conexão com a internet...')" \
		"ping -c 1 -W $timeout $url >/dev/null 2>&1" \
		"$err_not_fatal" "$pipe_test"; then
		return 0
	else
		if conf "** INTERNET **" \
			"$(gettext 'Parece que não há uma rota disponível para a internet.') \n\n${AMARELO}$(gettext 'Deseja configurar um Wi-Fi?')"; then
			sh_confWifi
			return 0
		fi
		return 1
	fi
}

sh_change_grub() {
	local f="${dir_install}/etc/default/grub"

	sh_cmd_job "$(gettext 'Aplicando ajustes no GRUB')" "
    if ! grep '^GRUB_DISTRIBUTOR=' '$f' | grep -Fqi '${_WM^}'; then
      sed -i 's/^GRUB_DISTRIBUTOR=\"\\(.*\\)\"/GRUB_DISTRIBUTOR=\"\\1 ${_WM^}\"/' '$f'
    fi
    #sed -i 's|^GRUB_CMDLINE_LINUX_DEFAULT=.*|GRUB_CMDLINE_LINUX_DEFAULT="quiet splash plymouth.enable=1 loglevel=4 libata.noacpi=1 acpi=force apm=power-off nowatchdog tsc=nowatchdog cryptomgr.notests no_timer_check rcupdate.rcu_expedited=1 intel_pstate=active amd_pstate=active cpuidle.governor=teo split_lock_detect=off clearcpuid=514 transparent_hugepage=never skew_tick=1 intremap=off nosoftlockup audit=0 nomce systemd.show_status=auto rd.udev.log_level=3 apparmor=1 security=apparmor vconsole.font=Uni2-Fixed16 intel_iommu=on amd_iommu=on tdx=on nvme_load=yes nouveau.modeset=1 i915.modeset=1 amdgpu.modeset=1 radeon.si_support=0 radeon.cik_support=0 amdgpu.si_support=1 amdgpu.cik_support=1 nvidia.modeset=1 nvidia_drm.modeset=1 DEEPIN_GFXMODE="|' /etc/default/grub 1>/dev/null
  " "$err_not_fatal"
}

sh_setEnvironment
sh_setLanguage
sh_setVarColors
sh_setAsciiLines
sh_setLogPrefix
#sh_check_lock

[[ "${1-}" = @(-V|--version) ]] && {
	sh_version
	exit $(($# ? 0 : 1))
}

[[ "${1-}" = @(-h|--help) ]] && {
	sh_usage
	exit $(($# ? 0 : 1))
}

sh_without_chroot() {
	sh_checkDisplay
	sh_check_internet
	check_dependencies
	sh_checkUpdatePackages
}

sh_with_all() {
	reset
	#sh_update_self "$@"
	sh_loadSavedConfig
	sh_disablePrintk
	sh_loadconf
}

case " $* " in
*" -c "* | *" --chroot "*)
	LCHROOT=true
	sh_with_all
	grafico=0
	sh_init "$@"
	;;
*)
	sh_without_chroot
	sh_with_all
	grafico=1
	sh_init -i "$@"
	;;
esac

# sanity checks
if ! $LINSTALL && ! $LCHROOT; then
	die "${cmsg_Operacao}"
fi

if $LINSTALL && $LCHROOT; then
	die "${cmsg_OneOperacao}"
fi

sh_setMknodTty
#sh_menu_language "$@"
for x in "${appexec[@]}"; do $x; done
sh_enablePrintk