My .bashrc

# /home/user/.bashrc

PATH="${HOME}/.local/bin:${HOME}/bin:${PATH}"

# Some variables that change how ~/.bash_history works.
PROMPT_COMMAND='history -a'
HISTCONTROL="ignoredups:erasedups"
HISTSIZE=10000

LD_LOADER_PATH="/usr/local/lib:${LD_LOADER_PATH}"

# Creates a backup of the $IFS variable.
IFS_bak="$IFS"

# Creates a pause message, for read / sudo prompts.
pause_msg='Press Enter to continue...'

# Declaring some aliases...

alias dnf_files='dnf repoquery -l'
alias dnf_groups_all='dnf group list --available'
alias dnf_groups='dnf group list --installed'
alias dnf_list='rpm -qa | sort'
alias which_pkg='rpm -qf'
alias cue_verify='whipper image verify'
alias burn_img='cdrdao write --device /dev/sr0 --speed 2'
alias read_img='cdrdao read-cd --device /dev/sr0 --read-raw --datafile'
alias shellcheck='shellcheck -s bash'
alias mate_restart='killall -15 mate-panel'
alias kill_wine='wineserver --kill'
alias temp='watch -n 2 sensors'
alias temp_config='sudo sensors-detect'
alias cpu_clock='watch -n.1 "grep \"^[c]pu MHz\" /proc/cpuinfo"'
alias ps_handbrake='ps -C HandBrakeCLI -o pid,tty,stat,etime,cmd'
alias tribler="${HOME}/bin/tribler/src/tribler.sh"
alias freenet="${HOME}/freenet/run.sh"
alias ipredator="${HOME}/bin/ipredator.sh"
alias io_stats='sudo iotop -a -o -P'
alias frag_level_xfs='xfs_db -c frag -r'

alias pulse_reset='pactl set-sink-volume 0 100%'
alias pipewire_reset='systemctl --user restart pipewire pipewire-pulse'

alias irc_logs="cd ${HOME}/.local/share/konversation/logs"

alias import_flac="sudo ${HOME}/bin/import.pl ${HOME}/Music/FLAC"
alias fix_flac_tags="sudo ${HOME}/bin/replaygain.pl ${HOME}/Music/FLAC"

alias check_smart='sudo smartctl -a'
alias drop_cache='sudo bash -c "echo 3 > /proc/sys/vm/drop_caches"'

alias discord='${HOME}/bin/Discord/Discord'
alias tor-browser='${HOME}/bin/tor-browser/Browser/start-tor-browser'
alias jdownloader='${HOME}/bin/jd2/JDownloader2'
alias read_log='journalctl -r'
alias read_log2='dmesg -H'
alias list_services='systemctl --all list-units'
alias gedit='gnome-text-editor'
alias su_gedit='sudo gnome-text-editor'
alias irssi="irssi -c EFnet --config=${HOME}/.irssi2/config --home=~/.irssi2"
alias is_wayland="echo $XDG_SESSION_TYPE"

alias arch_pack='packer.sh a'
alias arch_unpack='packer.sh x'
alias arch_test='packer.sh t'
alias arch_list='packer.sh l'
alias stop_handbrake='stop_handbrake.sh'
alias start_handbrake='start_handbrake.sh'
alias stop_ffmpeg='sudo killall -20 ffmpeg'
alias start_ffmpeg='sudo killall -18 ffmpeg'
alias lower_volume='lower_volume_pw.sh'

alias wine32="WINEPREFIX=${HOME}/.wine32 wine start /unix"
alias wine32cfg="WINEARCH=win32 WINEPREFIX=${HOME}/.wine32 winecfg"

alias redshift='redshift -l 57.70:11.97'

alias wolf3d='wolf4sdl-registered-id --res 1600 1000'
alias sod='wolf4sdl-spear --res 1600 1000'

# alias quake='darkplaces-sdl -game quake15'
alias quake='darkplaces-sdl'

# alias prboom-plus='/usr/local/games/prboom-plus'

alias rott='rott-registered fullscreen resolution 800x600'

alias red_eclipse="${HOME}/SSD/redeclipse-1.6.0/redeclipse.sh"

alias daikatana="${HOME}/SSD/Daikatana/start"

alias doom64ex="${HOME}/SSD/doom64ex/doom64ex"

# Declaring some regexes...

declare no_ext ext
declare -A regex

regex[blank]='^[[:blank:]]*(.*)[[:blank:]]*$'
regex[du]='^([[:digit:]]+)M([[:blank:]]+)(.*)$'
regex[path]='^(.*[\\\/])(.*)$'
regex[fn]='^(.*)\.([^.]*)$'
regex[tar]='^\.tar\.[^.]*$'
regex[dar]='^\.[0-9]+\.dar$'

regex[num]='^[0-9]+$'

regex[720p]='\(([0-9]{3,4})p_h\.264-aac\)'
regex[1080p]='\(([0-9]{3,4})p_([0-9]{1,2})fps_(h264|av1)-([0-9]{2,3})kbit_(aac|opus)\)'

regex[bin_backup]='bin_[0-9]{4}-[0-9]{2}-[0-9]{2}\.tar\.xz'
regex[opensub]='.*[[:alpha:]]{3}.[[:digit:]]cd.\([[:digit:]]+\)( \([[:digit:]]+\))*.zip'

# Declaring some functions...

mame () {
    declare cwd

    cwd="$PWD"

    cd "${HOME}/.mame"

    /usr/bin/mame

    cd "$cwd"
}

# Creates a function, called 'gzdoom', which will run the GZDoom
# Flatpak (with arguments).
gzdoom () {
    flatpak run org.zdoom.GZDoom "$@"
}

duke3d () {
    declare cwd

    cwd="$PWD"

    cd "${HOME}/SSD/eduke32/bin"
    ./eduke32

    cd "$cwd"
}

ignition () {
    declare cwd

    cwd="$PWD"

    cd "${HOME}/SSD/ignition"
# wine 'ign_3dfx.exe'
# ./start.sh
    dosbox -userconf -conf "dosbox_single.conf"

    cd "$cwd"
}

tmnt_palooza () {
    declare cwd

    cwd="$PWD"

    cd "${HOME}/SSD/TMNT Rescue-Palooza 1.1.1"
    wine 'TMNT_Rescue_Palooza.exe'

    cd "$cwd"
}

cube2 () {
    cd "${HOME}/SSD/sauerbraten"

    ./sauerbraten_unix
}

doom1 () {
# sed --in-place 's/doom.*\.wad/doom.wad/'
# ${HOME}/.prboom-plus/prboom-plus.cfg
    prboom-plus -iwad "${HOME}/Documents/DOOM/doom.wad"
}

doom2 () {
# sed --in-place 's/doom.*\.wad/doom2.wad/'
# ${HOME}/.prboom-plus/prboom-plus.cfg
    prboom-plus -iwad "${HOME}/Documents/DOOM/doom2.wad"
}

allupgrade () {
    sudo bash <<UPGRADE
dnf --assumeyes --best --allowerasing upgrade
dnf --assumeyes --best --allowerasing distro-sync
dnf --assumeyes autoremove
dnf --assumeyes clean all
flatpak update
UPGRADE
}

no_reboot () {
    sudo bash <<UPGRADE
dnf --assumeyes --best --allowerasing --exclude="kernel*" --exclude="systemd*" upgrade
dnf --assumeyes autoremove
dnf --assumeyes clean all
flatpak update
systemctl daemon-reload
UPGRADE
}

renice_pid () {
    declare pid

    if [[ ! $1 =~ ${regex[num]} ]]; then
        return
    fi

    pid="$1"

    sudo bash <<RENICE
renice -n -20 -p "$pid"
RENICE
}

brktext () {
    tr "[[:punct:]]" " " <"$1" | tr "\n" " " | sed 's/  */ /g'
}

clntext () {
    tr -d "[[:digit:]]" <"$1" | sed -e 's/  */ /g' -e 's/^ *//g' -e 's/ *$//g'
}

searchtxt () {
    find "${HOME}/Documents" -iname "*.txt" | while read txt; do grep -iH "$1" "$txt"; done
}

searchodt () {
    find "${HOME}/Documents" -iname "*.rtf" | while read txt; do grep -iH "$1" "$txt"; done
    find "${HOME}/Documents" -iname "*.doc" | while read txt; do grep -iH "$1" "$txt"; done
    find "${HOME}/Documents" -iname "*.odt" | while read txt; do grep -iH "$1" "$txt"; done
}

find_cfg () {
    declare dn
    declare -a names dirs files

    mapfile -t names < <(printf '%s\n' "${@,,}" | sort -u)

    mapfile -t dirs < <(find "$HOME" -mindepth 1 -maxdepth 1 -type d -iname ".*")

    for (( i = 0; i < ${#dirs[@]}; i++ )); do
        dn="${dirs[${i}]}"

        for name in "${names[@]}"; do
            mapfile -t files < <(find "$dn" -iname "*${name}*")

            if [[ ${#files[@]} -gt 0 ]]; then
                printf '%s\n' "${files[@]}"
            fi
        done
    done | sort -u
}

find_old_cfg () {
    declare date_limit date_fn dn fn
    declare -a dirs files old

    date_limit=$(date --date=2020-01-01 '+%s')

    mapfile -t dirs < <(find "$HOME" -mindepth 1 -maxdepth 1 -type d -iname ".*")

    for (( i = 0; i < ${#dirs[@]}; i++ )); do
        dn="${dirs[${i}]}"

        mapfile -t files < <(find "$dn" -type f)

        for (( j = 0; j < ${#files[@]}; j++ )); do
            fn="${files[${j}]}"

            date_fn=$(stat -c '%Y' "$fn")

            if [[ $date_fn -lt $date_limit ]]; then
                old+=("$fn")
            fi
        done
    done

    printf '%s\n' "${old[@]}"
}

find_double () {
    declare fn bn

    if [[ $# -ne 2 ]]; then
        return
    fi

    ls -1 "$1" | while read fn; do
        bn=$(basename "$fn")
        find "$2" -maxdepth 1 -name "$bn"
    done
}

find_all () {
    if [[ $# -eq 0 ]]; then
        return
    fi

    declare cmd names_str
    declare -a names

    for name in "$@"; do
        names+=( "\"$(sed -E 's/([[:blank:]])/\\\1/g' <<<"$name")\"" )
    done

    find_all_tmp () {
        for name in "$@"; do
            cmd=$(printf '%s\n' "find '/home' '/run/media' -iname \"${name}\"")
            eval "$cmd" 2>&-
        done
    }

    names_str="${names[@]}"
    sudo bash -c "$(declare -f find_all_tmp); find_all_tmp ${names_str}"
}

find_all_size () {
    declare line size fn
    declare -a files files_size

    mapfile -t files < <(find_all "$@")

    get_size () {
        for (( i = 0; i < ${#files[@]}; i++ )); do
            line="${files[${i}]}"
            du -BM -s "$line"
        done | sed -E "s/${regex[du]}/\1 \3/" | sort -rn
    }

    mapfile -t files_size < <(get_size)

    for (( i = 0; i < ${#files_size[@]}; i++ )); do
        line="${files_size[${i}]}"
        size="${line%% *}"
        fn="${line#* }"
        printf '%s\n' "$fn"
    done
}

find_list () {
    if [[ ! -f $1 ]]; then
        return
    fi

    while read line; do
        read -p "$pause_msg"
        find_all "$line"
    done <"$1"
}

find_meta () {
    find_all '.ds_store' 'thumbs.db'
}

find_trash () {
    sudo find '/home' '/run/media/' -maxdepth 3 -type d -iname ".trash*"
}

find_root () {
    sudo find / \( -path '/home' -o -path '/run/media' -o -path '/proc' -o -path '/sys' \) -prune -o -iname "$1" -print 2>&-
}

find_root_recent () {
    declare session of_bn of_list of_size
    declare -a files

    session="${RANDOM}-${RANDOM}"
    of_bn="${HOME}/find_recent_files"
    of_list="${of_bn}_list-${session}.txt"
    of_size="${of_bn}_size-${session}.txt"

    sudo find / \( -path '/home' -o -path '/run/media' -o -path '/proc' -o -path '/sys' \) -prune -o -type f -printf "%T@ %Tc %p\n" 2>&- | sort -n | cut -d' ' -f9- | tee "$of_list"

    mapfile -t files <"$of_list"

    touch "$of_size"

    for (( i = 0; i < ${#files[@]}; i++ )); do
        sudo du -h "${files[${i}]}" 2>&- | tee --append "$of_size"
    done
}

find_movie_dups () {
    "${HOME}/bin/find_movie_dups.sh" "${HOME}" "/run/media/${USER}"
}

find_movie_dups_imdb () {
    "${HOME}/bin/find_movie_dups.sh" -imdb "${HOME}" "/run/media/${USER}"
}

find_shitrips () {
    declare fn bn bn_lc of line size
    declare -a files files_size

    of="${HOME}/shitrips.txt"

    mapfile -t files < <(find_all "*720p*" "*dvd*rip*" "*dvdscr*" "*screener*" "*divx*" "*xvid*")

    get_size () {
        for (( i = 0; i < ${#files[@]}; i++ )); do
            line="${files[${i}]}"
            du -BM -s "$line"
        done | sed -E "s/${regex[du]}/\1 \3/" | sort -rn
    }

    mapfile -t files_size < <(get_size)

    for (( i = 0; i < ${#files_size[@]}; i++ )); do
        line="${files_size[${i}]}"
        size="${line%% *}"
        fn="${line#* }"
        bn=$(basename "$fn")
        bn_lc="${bn,,}"

        if [[ $bn_lc =~ ${regex[720p]} || $bn_lc =~ ${regex[1080p]} ]]; then
            continue
        fi

        printf '%s\n' "$fn"
    done | tee "$of"
}

find_mkv_dups () {
    declare fn fn_mkv md5 hash_ref
    declare -a files_array
    declare -A files_hash

    mapfile -t files_array < <(find_all "*.mkv" "*.mp4" "*.avi" "*.mpg" "*.mpeg")

    for (( i = 0; i < ${#files_array[@]}; i++ )); do
        fn="${files_array[${i}]}"

        get_ext "$fn" 1

        fn_mkv="${no_ext}.mkv"
        md5=$(md5sum -b <<<"$fn_mkv")
        md5="${md5%% *}"
        hash_ref="files_hash[${md5}]"

        if [[ $ext != 'mkv' && -n ${!hash_ref} ]]; then
            printf '%s\n' '***'
            printf '%s\n' "${!hash_ref}"
            printf '%s\n' "$fn"
        fi

        if [[ $ext == 'mkv' && -z ${!hash_ref} ]]; then
            files_hash["${md5}"]="$fn"
        fi
    done
}

no_blank () {
    xset s off
    xset -dpms
}

run_wow () {
    WINEPREFIX="${HOME}/prefix32"
    WINEARCH=win32
    cd "/run/media/${USER}/0d6b70fa-0c49-47d6-84c1-3f8509d52b58/wow/WOW Wotlk 3.3.5a"
    wine 'Wow.exe'
}

restart_kde () {
    kquitapp5 plasmashell &&
    kstart5 plasmashell

# sleep 10

# kwin_x11 --replace &
}

compare_txt () {
    if [[ ! -f $1 || ! -f $2 ]]; then
        return
    fi

    while read line; do grep -Fq "$line" "$2" || printf '%s\n' "$line"; done <"$1"
}

update_dir () {
    declare in out

    in="$1"
    out="$2"

    if [[ ! -d $in || ! -d $out ]]; then
        return
    fi

    sudo rsync -Lacv --delete "${in}"/* "${out}"
}

update_flac () {
    declare in out

    in="${HOME}/Music/FLAC"
    out="/run/media/${USER}/SD_BTRFS/SD_BTRFS/Music/FLAC"

    update_dir "$in" "$out"
}

update_ps1 () {
    declare in out

    in="${HOME}/playstation"
    out="/run/media/${USER}/SD_BTRFS/SD_BTRFS/playstation"

    update_dir "$in" "$out"
}

arch_test_tree () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn
    declare -a ext_list_tmp files

    if_dn=$(readlink -f "$1")

    ext_list_tmp=('.dar' '.tar' '.z' '.gz' '.tgz' '.bz2' '.tbz' '.tbz2' '.txz' '.xz' '.zip' '.7z' '.rar' '.cab' '.lzh' '.lha' '.arj' '.iso')

    mapfile -t files < <(find "$if_dn" -type f)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        get_ext "$fn" 1

        for ext_tmp in "${ext_list_tmp[@]}"; do
            if [[ $ext != "$ext_tmp" ]]; then
                continue
            fi

            arch_test "$fn"
            break
        done
    done
}

zip_2_7z () {
    declare cwd if of
    declare -a files

    cwd="$PWD"

    mapfile -t files < <(compgen -G "*.zip")

    for (( i = 0; i < ${#files[@]}; i++ )); do
        if="${files[${i}]}"
        of="${if%.*}"
        mkdir "$of"
        cd "$of"
        arch_unpack ../"${if}" && rm ../"${if}"
        cd "$cwd"
        arch_pack "${of}.7z" "$of" && rm -rf "$of"
    done
}

dnf_perl_install () {
    for module in "$@"; do
        sudo dnf install "perl(${module})"
    done
}

sort_filetypes () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn dn_types dn_opensub dn fn
    declare -a types archives documents images media packages categories files

    if_dn=$(readlink -f "$1")

    dn_types="${if_dn}/Filetypes"
    dn_opensub="${dn_types}/zip/opensubtitles"

    types=('7z' 'apk' 'avi' 'bz2' 'deb' 'doc' 'exe' 'flac' 'flv' 'gif' 'gz' 'img' 'iso' 'jpg' 'jpeg' 'mkv' 'mpg' 'mpeg' 'm3u' 'mov' 'mp3' 'mp4' 'odt' 'ogg' 'pdf' 'pls' 'png' 'rar' 'rpm' 'rtf' 'srt' 'svg' 'tar' 'torrent' 'txt' 'wav' 'webm' 'xcf' 'zip' 'xspf' 'xz')
    archives=('7z' 'bz2' 'gz' 'rar' 'tar' 'zip' 'xz')
    documents=('doc' 'odt' 'pdf' 'rtf' 'txt')
    images=('gif' 'jpg' 'jpeg' 'png' 'svg' 'xcf')
    media=('avi' 'flac' 'flv' 'mkv' 'mpg' 'mpeg' 'mov' 'mp3' 'mp4' 'ogg' 'wav' 'webm')
    packages=('apk' 'deb' 'rpm')
    categories=('archives' 'documents' 'images' 'media' 'packages')

    categorize () {
        dn="${dn_types}/${category}/${type}"

        mapfile -t files < <(find "${dn_types}/${type}" -maxdepth 1 -type f 2>&-)

        for (( i = 0; i < ${#files[@]}; i++ )); do
            fn="${files[${i}]}"

            mkdir -p "$dn"
            mv -n "$fn" "$dn"
        done
    }

    mkdir -p "$if_dn"

    mapfile -t files < <(find "$if_dn" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        get_ext "$fn" 1

        for type in "${types[@]}"; do
            if [[ $ext != ".${type}" ]]; then
                continue
            fi

            dn="${dn_types}/${type}"

            mkdir -p "$dn"
            mv -n "$fn" "$dn"

            break
        done
    done

    mkdir -p "${dn_types}/jpg" "${dn_types}/mpg"

    mv -n "${dn_types}/jpeg"/* "${dn_types}/jpg" 2>&-
    mv -n "${dn_types}/mpeg"/* "${dn_types}/mpg" 2>&-

    for category in "${categories[@]}"; do
        mkdir -p "${dn_types}/${category}"

        case $category in
            'archives')
                for type in "${archives[@]}"; do
                    categorize
                done
            ;;
            'documents')
                for type in "${documents[@]}"; do
                    categorize
                done
            ;;
            'images')
                for type in "${images[@]}"; do
                    categorize
                done
            ;;
            'media')
                for type in "${media[@]}"; do
                    categorize
                done
            ;;
            'packages')
                for type in "${packages[@]}"; do
                    categorize
                done
            ;;
        esac
    done

    mapfile -t files < <(find "${dn_types}/archives/zip" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        if [[ ! $fn =~ ${regex[opensub]} ]]; then
            continue
        fi

        mkdir -p "$dn_opensub"
        mv -n "$fn" "$dn_opensub"
    done

    rm_empty_dirs "$dn_types"
}

# Creates a function, called 'get_ext', which will separate file names
# and extensions.
get_ext () {
    declare ext no_ext
    declare -a ext_list

    no_ext="$1"

    while [[ $no_ext =~ ${regex[fn]} ]]; do
        no_ext="${BASH_REMATCH[1]}"
        ext_list=("${BASH_REMATCH[2],,}" "${ext_list[@]}")

        if [[ ${#ext_list[@]} -eq $2 ]]; then
            break
        fi
    done

    ext=$(printf '.%s' "${ext_list[@]}")
}

recursive_extract () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn of_dn fn bn
    declare -a ext_list_tmp files

    if_dn=$(readlink -f "$1")

    cd "$if_dn"

    ext_list_tmp=('.dar' '.tar' '.z' '.gz' '.tgz' '.bz2' '.tbz' '.tbz2' '.txz' '.xz' '.zip' '.7z' '.rar' '.cab' '.lzh' '.lha' '.arj')

    mapfile -t files < <(find "$if_dn" -type f)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"
        bn=$(basename "$fn")

        get_ext "$fn" 1

        for ext_tmp in "${ext_list_tmp[@]}"; do
            if [[ $ext != "$ext_tmp" ]]; then
                continue
            fi

            of_dn="${no_ext}-${RANDOM}-${RANDOM}"

            mkdir -p "$of_dn"
            mv "$fn" "$of_dn"

            cd "$of_dn"
            arch_unpack "$bn"

            if [[ $? -eq 0 && -f $bn ]]; then
                rm -f "$bn"
            fi

            cd "$if_dn"

            break
        done
    done
}

rm_empty_dirs () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn dn
    declare -a dirs

    if_dn=$(readlink -f "$1")

    mapfile -t dirs < <(find "$if_dn" -type d -empty 2>&-)

    until [[ ${#dirs[@]} -eq 0 ]]; do
        for (( i = 0; i < ${#dirs[@]}; i++ )); do
            dn="${dirs[${i}]}"

            rm -rf "$dn"
        done

        mapfile -t dirs < <(find "$if_dn" -type d -empty 2>&-)
    done
}

rm_empty_files () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn size
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"
        size=$(stat -c '%s' "$fn")

        if [[ $size -eq 0 ]]; then
            rm -f "$fn"
        fi
    done
}

flatten_dn () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        mv -n "$fn" "$if_dn"
    done

    rm_empty_dirs "$if_dn"
}

unique_ext () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        if [[ $fn =~ ${regex[fn]} ]]; then
            printf '%s\n' "${BASH_REMATCH[2]}"
        fi
    done | sort -u
}

unique_type () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn info
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        info=$(file -b "$fn")
        printf '%s\n' "${info%%:*}"
    done | sort -u
}

lc_ext () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn if of
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        if="${files[${i}]}"

        get_ext "$if" 1

        of="${no_ext}.${ext}"

        if [[ $if != "$of" ]]; then
            mv -n "$if" "$of"
        fi
    done
}

fn2md5 () {
    if [[ ! -d $1 ]]; then
        return
    fi

    declare if_dn fn md5
    declare -a files

    if_dn=$(readlink -f "$1")

    mapfile -t files < <(find "$if_dn" -maxdepth 1 -type f 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        fn="${files[${i}]}"

        get_ext "$fn" 1

        md5=$(md5sum -b <<<"$fn")
        md5="${md5%% *}"

        mv -n "$fn" "${md5}.${ext}"
    done
}

git_link () {
    declare cwd local_bin git_repo script

    cwd="$PWD"

    local_bin="${HOME}/bin"
    git_repo="${local_bin}/git_repo"

    cd "${local_bin}/git_repo"

    while [[ $@ ]]; do
        script="${local_bin}/${1}"

        if [[ -f $script && ! -f $1 && ! -L $1 ]]; then
            printf '%s\n' "Link created: ${script}"
            ln ../"${1}" "${1}"
        fi

        shift
    done

    cd "$cwd"
}

git_push () {
    declare cwd local_bin git_repo

    cwd="$PWD"

    local_bin="${HOME}/bin"
    git_repo="${local_bin}/git_repo"

    cd "${local_bin}/git_repo"

    git add . && git commit -m "${1}"

    git push origin main

    cd "$cwd"
}

bin_backup () {
    declare of of_dn fn bn date
    declare -a files

    date=$(date '+%F')
    of="bin_${date}.tar.xz"
    of_dn="/run/media/${USER}/0d6b70fa-0c49-47d6-84c1-3f8509d52b58"

    rm_old () {
        declare dn

        dn="$1"

        mapfile -t files < <(find "$dn" -maxdepth 1 -type f -iname "bin_*.tar.xz*" 2>&-)

        for (( i = 0; i < ${#files[@]}; i++ )); do
            fn="${files[${i}]}"
            bn=$(basename "$fn")

            if [[ $bn =~ ${regex[bin_backup]} ]]; then
                rm -f "$fn"
            fi
        done
    }

    rm_old "$HOME"
    rm_old "$of_dn"

    cd "$HOME"

    arch_pack "$of" bin
    md5sum -b "$of" | tee "${of}.md5"
    cp -p "${of}"* "$of_dn"

    sync
}

sort_bin_archive () {
    declare local_bin if_dn if of date
    declare -a files

    local_bin="${HOME}/bin"
    if_dn="${local_bin}/archive"

    if [[ ! -d $if_dn ]]; then
        return
    fi

    rm_md5sum.sh "$if_dn"

    mapfile -t files < <(find "$if_dn" -type f -iname "*.sh" -o -iname "*.pl" -o -iname "*.php" 2>&-)

    for (( i = 0; i < ${#files[@]}; i++ )); do
        if="${files[${i}]}"
        date=$(stat -c '%y' "$if")
        date="${date%% *}"
        of="${if}.${date}"

        sudo "${local_bin}/reformat_script.sh" "$if"
        sudo "${local_bin}/reformat_script.sh" "$if"

        printf '%s\n' "$of"
        mv -n "$if" "$of"
    done

#   flatten_dn "$if_dn"
}

kill_gnome () {
    declare comm pid
    declare -a pids

    comm='/usr/libexec/xdg-desktop-portal-gnome'

    mapfile -t pids < <(pgrep -xf "$comm")

    for (( i = 0; i < ${#pids[@]}; i++ )); do
        pid="${pids[${i}]}"

        sudo kill -15 "$pid"
    done

    sleep 1

    killall -15 'gnome-shell'
}