argparser

#!/usr/bin/env bash

###############################################################################
#                                                                             #
# Copyright 2025-2026 Simon Brandt                                            #
#                                                                             #
# Licensed under the Apache License, Version 2.0 (the "License");             #
# you may not use this file except in compliance with the License.            #
# You may obtain a copy of the License at                                     #
#                                                                             #
#     http://www.apache.org/licenses/LICENSE-2.0                              #
#                                                                             #
# Unless required by applicable law or agreed to in writing, software         #
# distributed under the License is distributed on an "AS IS" BASIS,           #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.    #
# See the License for the specific language governing permissions and         #
# limitations under the License.                                              #
#                                                                             #
###############################################################################

# Author: Simon Brandt
# E-Mail: simon.brandt@uni-greifswald.de
# Last Modification: 2026-03-25

# TODO: Output a warning message when options in the configuration file
#       are set that don't correspond to Argparser environment
#       variables.
# TODO: Remove need for message parsing after argument parsing by using
#       nonlocal variables.

# Usage: Source this script with 'source argparser -- "$@"' inside the
# script whose arguments need to be parsed.  If ${ARGPARSER_READ_ARGS}
# is set to "true" (the default), the arguments will be parsed upon
# sourcing.  If ${ARGPARSER_SET_ARGS} is set to "true" (the default),
# the arguments will also be set to variables upon sourcing, else, the
# associative array which ${ARGPARSER_ARG_ARRAY_NAME} points to needs to
# be accessed.  Refer to the documentation for details.

# Purpose: Parse a script's arguments, giving proper error and warning
# messages for wrongly set arguments, assigning the values to the
# respective variables, as well as creating and printing a help, usage,
# and version message.  Refer to the documentation for details.

###############################################################################

# Define the Argparser functions to check that the Argparser is run by
# Bash 4.4 or higher, and execute them immediately, such that the rest
# of the script doesn't get parsed (which would create errors since it's
# written in Bash, not POSIX compliantly, and using Bash syntax not
# available prior Bash 4.4).
argparser_check_shell() {
    # Check that the current shell is a Bash instance.  Else, print an
    # error message.
    #
    # In order to have the function interpretable by shells other than
    # Bash, all commands are written in a POSIX-conformant form.

    # shellcheck disable=SC2292  # Intentional POSIX conformance.
    if [ -z "${BASH}" ]; then
        printf '%s: %s\n' "$0" \
            "Error: The Argparser requires Bash as executing shell." >&2
        exit 1
    fi
}
argparser_check_shell

function argparser_check_bash_version() {
    # Check that version of the current Bash instance is at least 4.4.
    # Else, print an error message.

    if (( BASH_VERSINFO[0] < 4 \
        || (BASH_VERSINFO[0] == 4 && BASH_VERSINFO[1] < 4) ))
    then
        printf '%s: %s\n' "$0" \
            "Error: The Argparser requires Bash 4.4 or higher." >&2
        exit 1
    fi
}
argparser_check_bash_version

# Define the Argparser function used for debugging.
function argparser_toggle_debugger() {
    # Start or stop the Argparser debugger.
    #
    # Arguments:
    # - $1: whether to start or stop the debugger ("start" or "stop")

    # Define the local variables.
    local status
    local trap_action

    status="$1"

    # shellcheck disable=SC2016  # Intentional single quotes around variables.
    # shellcheck disable=SC2064  # Intentional double-quoted trap action.
    if [[ "${status}" == "start" ]]; then
        # Print the current 4-digit line number, the currently executing
        # function's name, and the command to be executed, for any
        # command.
        trap_action='printf "Line %4d in %s:    %s\n" "${LINENO}" '
        trap_action+='"${FUNCNAME[0]:-main}" "${BASH_COMMAND}" >&2'
        trap "${trap_action}" DEBUG
        set -o functrace
    else
        # Reset the trap action.
        trap - DEBUG
    fi
}

# Define the Argparser functions used for general tests.
function argparser_in_array() {
    # Check if an element occurs in an array.
    #
    # Arguments:
    # - $1: the element to search for
    # - $@: the array to search through
    #
    # Return value:
    # - 0, if the element exists in the array
    # - 1, else

    # Define the local variables.
    local element
    local query

    # Read the query element and shift the arguments such that only the
    # array to search through remains.
    query="$1"
    shift

    # Iterate through the array and compare each element to the query.
    # Return 0 on success, else 1.
    for element in "$@"; do
        if [[ "${element}" == "${query}" ]]; then
            return 0
        fi
    done

    return 1
}

function argparser_is_alpha() {
    # Check if a variable's value is an alphabetical character.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is an alphabetical character
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == [[:alpha:]] ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_is_bool() {
    # Check if a variable's value is a Boolean.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is a Boolean
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == true || "${var}" == false ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_is_char() {
    # Check if a variable's value is a (printable) character.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is a character
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == [[:print:]] ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_is_float() {
    # Check if a variable's value is a floating-point number.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is a floating-point number
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == ?([+-])+([[:digit:]]).*([[:digit:]])
        || "${var}" == ?([+-])*([[:digit:]]).+([[:digit:]]) ]]
    then
        return 0
    else
        return 1
    fi
}

function argparser_is_identifier() {
    # Check if a variable's value is usable as Bash variable identifier.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is usable as identifier
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == [[:alpha:]_]*([[:word:]]) ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_is_int() {
    # Check if a variable's value is an integer.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is an integer
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == ?([+-])+([[:digit:]]) ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_is_uint() {
    # Check if a variable's value is an unsigned integer.
    #
    # Arguments:
    # - $1: the variable whose value to check
    #
    # Return value:
    # - 0, if the variable's value is an unsigned integer
    # - 1, else

    # Define the local variable.
    local var

    # Read the argument.
    var="$1"

    # Check the variable's value.
    if [[ "${var}" == +([[:digit:]]) ]]; then
        return 0
    else
        return 1
    fi
}

function argparser_check_styles() {
    # Check if the specified colors, text styles, and/or frame styles
    # are implemented for argparser_colorize.
    #
    # Arguments:
    # - $1: the array(s) to check ("colors", "text styles",
    #       "frame styles", "colors, text styles", or "colors, frame
    #       styles")
    # - $2: the colors and/or styles to use as
    #       ${ARGPARSER_ARG_DELIMITER_2}-separated list
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    #
    # Return value:
    # - 0, if all colors and/or styles are implemented
    # - 1, else

    # Define the local variables.
    local check_type
    local -a colors
    local -a corner_styles
    local -a line_styles
    local -a line_widths
    local request
    local -a requests
    local -a text_styles

    # Read the arguments.
    check_type="$1"
    requests="$2"

    # Define the arrays of implemented colors, text styles, and frame
    # styles (corner and line styles, as well as line widths).
    colors=(
        "black"
        "red"
        "green"
        "yellow"
        "blue"
        "magenta"
        "cyan"
        "white"
    )

    text_styles=(
        "normal"
        "bold"
        "faint"
        "italic"
        "underline"
        "double"
        "overline"
        "crossed-out"
        "blink"
        "reverse"
    )

    corner_styles=(
        "angular"
        "rounded"
        "double"
    )

    line_styles=(
        "solid"
        "double-dashed"
        "triple-dashed"
        "quadruple-dashed"
    )

    line_widths=(
        "thin"
        "thick"
        "double"
    )

    # Split the requested colors and/or styles on
    # ${ARGPARSER_ARG_DELIMITER_2} characters and check any.
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a requests <<< "${requests}"

    if [[ "${check_type}" == "colors" ]]; then
        if (( "${#requests[@]}" == 0 )); then
            return 1
        fi

        for request in "${requests[@]}"; do
            request="${request#bright_}"
            request="${request%@(_bg|_fg)}"
            if ! argparser_in_array "${request}" "${colors[@]}"; then
                return 1
            fi
        done
    elif [[ "${check_type}" == "text styles" ]]; then
        if (( "${#requests[@]}" == 0 )); then
            return 1
        fi

        for request in "${requests[@]}"; do
            if ! argparser_in_array "${request}" "${text_styles[@]}"; then
                return 1
            fi
        done
    elif [[ "${check_type}" == "frame styles" ]]; then
        for request in "${requests[@]}"; do
            if ! argparser_in_array "${request}" "${corner_styles[@]}" \
                "${line_styles[@]}" "${line_widths[@]}"
            then
                return 1
            fi
        done
    elif [[ "${check_type}" == "colors, text styles" ]]; then
        if (( "${#requests[@]}" == 0 )); then
            return 1
        fi

        for request in "${requests[@]}"; do
            if ! argparser_in_array "${request}" "${colors[@]}" \
                "${text_styles[@]}"
            then
                request="${request#bright_}"
                request="${request%@(_bg|_fg)}"
                if ! argparser_in_array "${request}" "${colors[@]}"; then
                    return 1
                fi
            fi
        done
    elif [[ "${check_type}" == "colors, frame styles" ]]; then
        for request in "${requests[@]}"; do
            if ! argparser_in_array "${request}" "${colors[@]}" \
                "${corner_styles[@]}" "${line_styles[@]}" "${line_widths[@]}"
            then
                request="${request#bright_}"
                request="${request%@(_bg|_fg)}"
                if ! argparser_in_array "${request}" "${colors[@]}"; then
                    return 1
                fi
            fi
        done
    fi

    return 0
}

function argparser_check_file() {
    # Check if a file exists, is a regular file, is readable, and has a
    # size greater than 0 bytes.
    #
    # Arguments:
    # - $1: the file to check
    #
    # Nonlocals:
    # - file_attributes: a bit mask with four bits set to 0 ("true") if
    #   the file exists (first bit), is a regular file (second bit), is
    #   readable (third bit), and/or has a size greater than 0 bytes
    #   (fourth bit), else set to 1 ("false")

    # Define the local variable.
    local file

    # Read the argument.
    file="$1"

    # Check the variable's value.
    if [[ -e "${file}" ]]; then
        file_attributes="0"
    else
        file_attributes="1"
    fi

    if [[ -f "${file}" ]]; then
        file_attributes+="0"
    else
        file_attributes+="1"
    fi

    if [[ -r "${file}" ]]; then
        file_attributes+="0"
    else
        file_attributes+="1"
    fi

    if [[ -s "${file}" ]]; then
        file_attributes+="0"
    else
        file_attributes+="1"
    fi
}

# Define the general Argparser utility functions.
function argparser_pad() {
    # Pad all elements of an array to the left or right to have the same
    # width.
    #
    # Arguments:
    # - $1: the pad side ("left" or "right")
    # - $2: the width to pad the array's elements to (an integer, or
    #       "auto" to compute the maximum width of the array's elements)
    # - $@: the array whose elements to pad
    #
    # Nonlocals:
    # - padded_array: the array with padded elements.

    # Define the local variables.
    local i
    local max_width
    local side
    local -a uncolorized_array
    local whitespace

    # Read the arguments.
    side="$1"
    max_width="$2"
    shift 2
    padded_array=("$@")

    # Possibly, get the maximum width of the array's elements.
    if [[ "${max_width}" == "auto" ]]; then
        argparser_get_max_width "${padded_array[@]}"
    fi

    # Pad the array's elements in-place.
    argparser_uncolorize "array" "${padded_array[@]}"
    if [[ "${side}" == "left" ]]; then
        for i in "${!padded_array[@]}"; do
            printf -v whitespace '%*s' \
                "$(( max_width - "${#uncolorized_array[i]}" ))" ""
            padded_array[i]="${whitespace}${padded_array[i]}"
        done
    else
        for i in "${!padded_array[@]}"; do
            printf -v whitespace '%*s' \
                "$(( max_width - "${#uncolorized_array[i]}" ))" ""
            padded_array[i]="${padded_array[i]}${whitespace}"
        done
    fi
}

function argparser_trim() {
    # Trim leading and trailing space characters from a string.
    #
    # Arguments:
    # - $1: the string to trim
    #
    # Nonlocals:
    # - trimmed_string: the trimmed string

    # Define the local variable.
    local string

    # Read the argument.
    string="$1"

    # Trim the string and set the nonlocal ${trimmed_string} to it.
    string="${string##+( )}"
    string="${string%%+( )}"
    trimmed_string="${string}"
}

function argparser_fold() {
    # Limit the width of an array's elements to the maximum width by
    # spltting them into separate elements.  Upon joining the array with
    # newline characters, these effectively become inserted line breaks.
    #
    # Arguments:
    # - $1: the characters to use as delimiters, joined to a single
    #       string
    # - $2: the maximum width a column may have
    # - $3: the amount of indentation after each line break
    # - $@: the array in which to insert line breaks
    #
    # Nonlocals:
    # - folded_array: the array with introduced line breaks

    # Define the local variables.
    local -a array
    local delimiters
    local element
    local i
    local indentation
    local is_style
    local max_width
    local pattern
    local style
    local -a uncolorized_array
    local whitespace
    local width
    local word
    local word_length
    local -a words

    # Read the arguments.
    delimiters="$1"
    max_width="$2"
    indentation="$3"
    shift 3
    array=("$@")

    # Empty ${folded_array} iff argparser_fold is not recursing due
    # to using secondary delimiters.  Iff in the first recursion level,
    # increment the indentation level.
    if (( "${#FUNCNAME[@]}" >= 1 )) \
        && [[ "${FUNCNAME[0]}" != "${FUNCNAME[1]}" ]]
    then
        folded_array=( )
    elif (( "${#FUNCNAME[@]}" >= 2 )) \
        && [[ "${FUNCNAME[0]}" != "${FUNCNAME[2]}" ]]
    then
        (( indentation += 4 ))
    fi

    # Set the indentation whitespace.
    printf -v whitespace '%*s' "${indentation}" ""

    # Split each (uncolorized) element (line) in the array word by word
    # on delimiters, such that line breaks aren't inserted into entire
    # words.
    pattern=$'(\e\[0[0-9;]+m)[^\e]*(\e\[0m)?$'
    for element in "${array[@]}"; do
        width=0

        # Add a new line iff the last line is non-empty, or the current
        # line is the first.  By this, multiple recursion levels don't
        # introduce a new line each whenever multiple subsequent
        # delimiters don't yield a short enough word.
        if (( "${#folded_array[@]}" == 0 )) || [[ -n "${folded_array[-1]}" ]]
        then
            folded_array+=("")
        fi

        # Split the element on the first (primary) delimiter, and
        # uncolorize the words.
        mapfile -d "${delimiters::1}" -t words <<< "${element}"
        words[-1]="${words[-1]%$'\n'}"
        argparser_uncolorize "array" "${words[@]}"

        # Wrap the lines.
        for i in "${!words[@]}"; do
            word="${words[i]}"
            word_length="${#uncolorized_array[i]}"

            if (( width == 0 )); then
                # For the first word in the line, add the word only and
                # set the width.
                if (( word_length > max_width )); then
                    # The word is too long to fit a single line, so try
                    # splitting it on secondary delimiters or put as
                    # many characters as possible on the line and the
                    # indented remainder as next array element.
                    if (( "${#delimiters}" > 1 )); then
                        # There are still secondary delimiters left, so
                        # split the word on them prior attempting to
                        # hard-wrap it.
                        argparser_fold "${delimiters:1}" "${max_width}" \
                            "${indentation}" "${word}"
                    elif [[ "${word}" == *$'\e'* ]]; then
                        # The word contains a style, whose length must
                        # not be taken into account for gauging the word
                        # length.  Thus, append one character at a time
                        # to the line, only increasing the word length
                        # when no style is being processed.  As soon as
                        # the word length approaches the maximum width,
                        # end the current line with the ANSI escape
                        # sequence for the end of colors and styles,
                        # append a backslash, and add the word's last
                        # pattern to the next line.  Finally, add the
                        # word's remainder to the next line.
                        word_length=0
                        is_style=false
                        style=""
                        for (( j = 0; j < "${#word}"; j++ )); do
                            folded_array[-1]+="${word:j:1}"

                            if [[ "${is_style}" == true ]]; then
                                if [[ "${word:j:1}" == "m" ]]; then
                                    is_style=false
                                fi
                                style+="${word:j:1}"
                                continue
                            fi

                            if [[ "${word:j:1}" == $'\e' ]]; then
                                is_style=true
                                style=$'\e'
                                continue
                            fi

                            (( word_length++ ))
                            if (( word_length == max_width - 1 )); then
                                if [[ "${style}" == *"0m" ]]; then
                                    folded_array[-1]+="\\"
                                    folded_array+=("${whitespace}")
                                else
                                    folded_array[-1]+=$'\e[0m\\'
                                    folded_array+=("${whitespace}${style}")
                                fi
                                break
                            fi
                        done
                        folded_array[-1]+="${word:j+1}"
                    else
                        # The word doesn't contain any style, so string
                        # slicing works correctly.
                        folded_array[-1]+="${word::max_width-1}\\"
                        folded_array+=("${whitespace}${word:max_width-1}")
                    fi
                    (( width = word_length - max_width + indentation ))
                else
                    # The word is short enough to fit the line, so add
                    # it directly.
                    folded_array[-1]+="${word}"
                    width="${word_length}"
                fi
            elif (( width + word_length + 1 > max_width )); then
                # As the line with the appended word (and the preceding
                # delimiter) would be too long, put the word as indented
                # next array element and set the width.  If the style
                # pattern matches, and the style doesn't end with the
                # line, end the current line with the ANSI escape
                # sequence for the end of colors and styles and add the
                # line's last pattern to the next line.  In both cases,
                # end the current line with the delimiter, if it isn't a
                # space.
                if [[ "${folded_array[-1]}" =~ ${pattern} \
                    && "${folded_array[-1]}" != *"0m" ]]
                then
                    style="${BASH_REMATCH[1]}"
                    if [[ "${delimiters::1}" == " " ]]; then
                        folded_array[-1]+=$'\e[0m'
                    else
                        folded_array[-1]+=$'\e[0m'"${delimiters::1}"
                    fi
                    folded_array+=("${whitespace}${style}${word}")
                else
                    if [[ "${delimiters::1}" != " " ]]; then
                        folded_array[-1]+="${delimiters::1}"
                    fi
                    folded_array+=("${whitespace}${word}")
                fi
                (( width = word_length + indentation ))
            else
                # For any other word, add the word and a leading
                # delimiter (otherwise, the words would be concatenated
                # without separation since the splitting removed any
                # delimiters).  Increase the width appropriately.
                folded_array[-1]+="${delimiters::1}${word}"
                (( width += word_length + 1 ))
            fi
        done
    done
}

function argparser_join() {
    # Join an array by delimiting characters.
    #
    # Arguments:
    # - $1: the separator used upon joining as delimiter
    # - $@: the array to join
    #
    # Nonlocals:
    # - joined_array: the joined array

    # Define the local variables.
    local array
    local delimiter

    # Read the arguments.
    delimiter="$1"
    shift
    array=("$@")

    # Join the array.
    printf -v joined_array '%s' "${array[@]/#/"${delimiter}"}"
    joined_array="${joined_array#"${delimiter}"}"
}

function argparser_seq() {
    # Create a sequence of integer or string values, ranging from the
    # start to the stop (inclusive), with a given step size.
    #
    # Arguments:
    # - $1: the argument identifier
    # - $2: the start value (as integer or string)
    # - $3: the stop value (as integer or string)
    # - $4: the step size (as integer, default: 1)
    #
    # Nonlocals:
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - sequence: the created sequence

    # Define the local variables.
    local arg_key
    local char
    local decimals
    local decimals_start
    local decimals_step
    local decimals_stop
    local error_message
    local i
    local number
    local offset
    local start
    local stop
    local step
    local translation

    # Read the arguments.
    arg_key="$1"
    start="$2"
    stop="$3"
    step="${4:-1}"

    if argparser_is_alpha "${start}" \
        && argparser_is_alpha "${stop}" \
        && argparser_is_int "${step}"
    then
        # For alphabetical character sequences, get the decimal value in
        # the ASCII table for the start and stop.
        printf -v start '%d' "'${start}"
        printf -v stop '%d' "'${stop}"
    elif argparser_is_int "${start}" \
        && argparser_is_int "${stop}" \
        && argparser_is_int "${step}"
    then
        # For entirely integer sequences, do nothing.  This is required
        # to simplify the subsequent comparisons.
        :
    elif (argparser_is_float "${start}" || argparser_is_int "${start}") \
        && (argparser_is_float "${stop}" || argparser_is_int "${stop}") \
        && (argparser_is_float "${step}" || argparser_is_int "${step}")
    then
        # For at least partially float sequences, get the decimal part
        # (after the period) and count its length.
        if [[ "${start}" == *.* ]]; then
            decimals_start="${start#*.}"
            decimals_start="${#decimals_start}"
        else
            decimals_start=0
        fi

        if [[ "${stop}" == *.* ]]; then
            decimals_stop="${stop#*.}"
            decimals_stop="${#decimals_stop}"
        else
            decimals_stop=0
        fi

        if [[ "${step}" == *.* ]]; then
            decimals_step="${step#*.}"
            decimals_step="${#decimals_step}"
        else
            decimals_step=0
        fi

        # Remove the period from the start, stop, and step values, as
        # well as any leading 0, to prevent the numbers being
        # interpreted as octal, instead of decimal.  These leading zeros
        # may result from the removal of the period, like "0.01" being
        # transformed to "001", instead of "1".
        start="${start/.}"
        start="${start##+(0)}"
        stop="${stop/.}"
        stop="${stop##+(0)}"
        step="${step/.}"
        step="${step##+(0)}"

        # Add as many trailing zeros to the start, stop, and step values
        # as required to make them the same length, in terms of decimal
        # digits.  By this, the sequence can be created as integer
        # sequence, below, and afterwards, by re-introducing the periods
        # as appropriate, the numbers can be converted back to floats.
        if (( decimals_start < decimals_step \
            && decimals_stop < decimals_step ))
        then
            (( decimals = decimals_step ))
            while (( decimals_start < decimals_step )); do
                start+="0"
                (( decimals_start++ ))
            done
            while (( decimals_stop < decimals_step )); do
                stop+="0"
                (( decimals_stop++ ))
            done
        elif (( decimals_start < decimals_stop )); then
            (( decimals = decimals_stop ))
            while (( decimals_start < decimals_stop )); do
                start+="0"
                (( decimals_start++ ))
            done
            while (( decimals_step < decimals_stop )); do
                step+="0"
                (( decimals_step++ ))
            done
        else
            (( decimals = decimals_start ))
            while (( decimals_stop < decimals_start )); do
                stop+="0"
                (( decimals_stop++ ))
            done
            while (( decimals_step < decimals_start )); do
                step+="0"
                (( decimals_step++ ))
            done
        fi
    else
        # For any other data type, output an error message.
        error_message="Error: The argument with the identifier \"\$1\" has "
        error_message+="choice values given with \"\$2\" as start, \"\$3\" as "
        error_message+="stop, and \"\$4\" as step size, while only integer, "
        error_message+="float, or letter sequences are supported."

        argparser_translate "Error arg def choice range" \
            "${error_message}" "${arg_key}" "${start}" "${stop}" "${step}"
        error_message="${translation}"
        error_messages+=("${error_message}")
        return
    fi

    # Create the actual sequence by iterating from the start to the stop
    # value, incrementing or decrementing by the given step size as
    # appropriate for the numerical order.
    sequence=( )
    if (( start <= stop )); then
        for (( i = start; i <= stop; i += step )); do
            sequence+=("${i}")
        done
    else
        for (( i = start; i >= stop; i -= step )); do
            sequence+=("${i}")
        done
    fi

    if argparser_is_alpha "$2"; then
        # If the start value (and, by this, also the stop and step
        # values) had been given as alphabetical character, convert each
        # number within the sequence to its hexadecimal representation
        # and subsequently to the respective character in the ASCII
        # table.
        for i in "${!sequence[@]}"; do
            char="${sequence[i]}"
            printf -v char '%x' "${char}"

            # shellcheck disable=SC2059  # Escape sequence in variable.
            printf -v char "\x${char}"
            sequence[i]="${char}"
        done
    elif argparser_is_float "$2" \
        || argparser_is_float "$3" \
        || argparser_is_float "$4"
    then
        # If either of the start, stop, and step value had been given as
        # float, convert the integers in the sequence to floats by
        # introducing a period at the decimal offset the most precise
        # number had (like two digits for start=1.0, stop=1.5, and
        # step=0.05).
        for i in "${!sequence[@]}"; do
            number="${sequence[i]}"
            (( offset = "${#number}" - decimals ))
            sequence[i]="${number::offset}.${number:offset}"
        done
    fi
}

function argparser_get_max() {
    # Get the maximum value of an array's elements.
    #
    # Arguments:
    # - $@: the array whose maximum value to find
    #
    # Nonlocals:
    # - max_value: the array's element with the maximum value

    # Define the local variables.
    local -a array
    local element

    # Read the arguments.
    array=("$@")

    # Get the maximum value of the array's elements.
    max_value="$1"
    for element in "${array[@]:1}"; do
        if (( element > max_value )); then
            max_value="${element}"
        fi
    done
}

function argparser_get_max_width() {
    # Get the maximum width of all elements of an array.
    #
    # Arguments:
    # - $@: the array whose elements to pad
    #
    # Nonlocals:
    # - max_width: the width of the array's widest element

    # Define the local variables.
    local element
    local -a uncolorized_array
    local width

    # Read the arguments.
    uncolorized_array=("$@")

    # Get the maximum width of the (uncolorized) array's elements.
    argparser_uncolorize "array" "${uncolorized_array[@]}"
    max_width=0
    for element in "${uncolorized_array[@]}"; do
        width="${#element}"
        if (( width > max_width )); then
            max_width="${width}"
        fi
    done
}

function argparser_count() {
    # Count the number of occurences of an element in an array.
    #
    # Arguments:
    # - $1: the element to count
    # - $@: the array where to count the element
    #
    # Nonlocals:
    # - count: the count of the element

    # Define the local variables.
    local element
    local query

    # Read the query element and shift the arguments such that only the
    # array to search through remains.
    query="$1"
    shift

    # Count the number of occurences.
    count=0
    for element in "$@"; do
        if [[ "${element}" == "${query}" ]]; then
            (( count++ ))
        fi
    done
}

function argparser_uniq() {
    # Filter adjacent duplicate entries from an array.
    #
    # Arguments:
    # - $@: the array to filter
    #
    # Nonlocals:
    # - filtered_array: the filtered array

    # Define the local variables.
    local array
    local element
    local prev_element

    # Read the arguments.
    array=("$@")

    # Filter the array and output it.
    prev_element="${array[0]}"
    filtered_array=("${array[0]}")
    for element in "${array[@]:1}"; do
        if [[ "${element}" != "${prev_element}" ]]; then
            filtered_array+=("${element}")
        fi
        prev_element="${element}"
    done
}

function argparser_quicksort() {
    # Sort an array using the recursive Quicksort algorithm with Tony
    # Hoare's partition scheme.
    #
    # Arguments:
    # - $1: the left boundary of the array bucket
    # - $2: the right boundary of the array bucket
    #
    # Nonlocals:
    # - array: the array to sort

    # Define the local variables.
    local i
    local j
    local left
    local pivot
    local pivot_point
    local right
    local swap

    # Read the arguments.
    left="$1"
    right="$2"

    # Sort the array by Quicksort.
    if (( left < right )); then
        # Set the start indices for the current bucket.  Take the
        # leftmost element as pivot.
        (( i = "${left}" - 1 ))
        (( j = "${right}" + 1 ))
        pivot="${array[left]}"

        while :; do
            # Traverse the array from the left, until a larger element
            # than the pivot has been found.
            (( i++ ))
            while [[ "${array[i]}" < "${pivot}" ]]; do
                (( i++ ))
            done

            # Traverse the array from the right, until a smaller element
            # than the pivot has been found.
            (( j-- ))
            while [[ "${array[j]}" > "${pivot}" ]]; do
                (( j-- ))
            done

            # If the indices have crossed each other, return.
            if (( i >= j )); then
                pivot_point="${j}"
                break
            fi

            # Swap the elements at the current indices.
            swap="${array[i]}"
            array[i]="${array[j]}"
            array[j]="${swap}"
        done

        # Recursively call the Quicksort algorithm to sort the buckets
        # individually.
        argparser_quicksort "${left}" "${pivot_point}"
        argparser_quicksort "$(( pivot_point + 1 ))" "${right}"
    fi
}

function argparser_sort() {
    # Sort an array, internally using the Quicksort algorithm.
    #
    # Arguments:
    # - $1: whether to reverse-sort the array
    # - $@: the array to sort
    #
    # Nonlocals:
    # - sorted_array: the sorted array

    # Define the local variables.
    local array
    local i
    local reverse

    # Read the arguments.
    reverse="$1"
    shift
    array=("$@")

    # Sort the array and output it, possibly after reversing it.
    argparser_quicksort 0 "$(( "${#array[@]}" - 1 ))"
    if [[ "${reverse}" == true ]]; then
        sorted_array=( )
        for (( i = "${#array[@]}" - 1; i >= 0; i-- )); do
            sorted_array+=("${array[i]}")
        done
    else
        sorted_array=("${array[@]}")
    fi
}

function argparser_colorize() {
    # Colorize and stylize an array's elements using ANSI escape
    # sequences.
    #
    # Arguments:
    # - $1: the colors and/or styles to use as
    #       ${ARGPARSER_ARG_DELIMITER_2}-separated list
    # - $2: the file descriptor to write to (1 or 2)
    # - $3: the variable to set the joined colorized array to; if set to
    #       "array", set the entire colorized array's elements to
    #       ${colorized_array}; if set to "print", print the joined
    #       colorized array instead
    # - $@: the array to colorize
    #
    # Nonlocals:
    # - $3: the joined colorized array (if $3 is neither set to "array"
    #       nor to "print")
    # - colorized_array: the colorized array (if $3 is set to "array")
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_USE_STYLES (read-only)
    #
    # Output:
    # - the colorized string (if $3 is set to "print")

    # Define the local variables.
    local ansi_code
    local -A colors_and_styles
    local file_descriptor
    local i
    local joined_array
    local style
    local style_request
    local -a style_requests
    local var

    # Read the arguments.
    style_requests="$1"
    file_descriptor="$2"
    var="$3"

    if [[ "${var}" != "array" ]]; then
        # Set ${colorized_array} as local instead of nonlocal variable,
        # since it's not used by the calling function (the joined
        # colorized array shall be printed or set to a variable,
        # instead).
        local -a colorized_array
    fi

    shift 3
    colorized_array=("$@")

    # Define the associative array with colors and styles, and their
    # corresponding Select Graphic Rendition (SGR) ANSI escape sequence
    # codes.
    colors_and_styles=(
        [black]=30
        [red]=31
        [green]=32
        [yellow]=33
        [blue]=34
        [magenta]=35
        [cyan]=36
        [white]=37
        [normal]=22
        [bold]=1
        [faint]=2
        [italic]=3
        [underline]=4
        [double]=21
        [overline]=53
        [crossed-out]=9
        [blink]=5
        [reverse]=7
    )

    # Split the requested color/style on ${ARGPARSER_ARG_DELIMITER_2}
    # characters and replace it with the corresponding escape sequence,
    # if they shall be used.  The test for writing to a terminal assumes
    # that argparser_colorize is never run through command substitution,
    # else [[ -t ${file_descriptor} ]] would always be false, i.e., it
    # would impossible to tell if the final STDOUT/STDERR goes to a
    # terminal.
    if [[ "${ARGPARSER_USE_STYLES}" == "always" \
        || ("${ARGPARSER_USE_STYLES}" == "file" && ! -t "${file_descriptor}") \
        || ("${ARGPARSER_USE_STYLES}" == "tty" && -t "${file_descriptor}") ]]
    then
        style=$'\e[0'
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a style_requests \
            <<< "${style_requests}"
        for style_request in "${style_requests[@]}"; do
            if [[ "${style_request}" == "bright_"*"_bg" ]]; then
                style_request="${style_request#bright_}"
                style_request="${style_request%_bg}"
                (( ansi_code = "${colors_and_styles[${style_request}]}" + 70 ))
            elif [[ "${style_request}" == "bright_"*"_fg" ]]; then
                style_request="${style_request#bright_}"
                style_request="${style_request%_fg}"
                (( ansi_code = "${colors_and_styles[${style_request}]}" + 60 ))
            elif [[ "${style_request}" == "bright_"* ]]; then
                style_request="${style_request#bright_}"
                (( ansi_code = "${colors_and_styles[${style_request}]}" + 60 ))
            elif [[ "${style_request}" == *"_bg" ]]; then
                style_request="${style_request%_bg}"
                (( ansi_code = "${colors_and_styles[${style_request}]}" + 10 ))
            elif [[ "${style_request}" == *"_fg" ]]; then
                style_request="${style_request%_fg}"
                ansi_code="${colors_and_styles[${style_request}]}"
            else
                ansi_code="${colors_and_styles[${style_request}]}"
            fi
            style+=";${ansi_code}"
        done
        style+="m"

        for i in "${!colorized_array[@]}"; do
            if [[ -n "${colorized_array[i]}" ]]; then
                colorized_array[i]="${style}${colorized_array[i]}"$'\e[0m'
            fi
        done
    fi

    # Join the colorized array, then print it or set it to the target
    # variable, using a name reference to the variable name given as
    # ${var} (i.e., as $3).
    if [[ "${var}" == "print" ]]; then
        argparser_join $'\n' "${colorized_array[@]}"
        printf '%s' "${joined_array}" >&"${file_descriptor}"
    elif [[ "${var}" != "array" ]]; then
        argparser_join $'\n' "${colorized_array[@]}"
        declare -n var="${var}"
        var="${joined_array}"
    fi
}

function argparser_uncolorize() {
    # Remove the colors and styles (in the form of ANSI escape
    # sequences) from an array's elements.
    #
    # Arguments:
    # - $1: the variable to set the joined uncolorized array to; if set
    #       to "array", set the entire uncolorized array's elements to
    #       ${uncolorized_array}; if set to "print", print the joined
    #       uncolorized array instead
    # - $2: the file descriptor to write to (1 or 2)
    # - $@: the array to uncolorize
    #
    # Nonlocals:
    # - $1: the joined uncolorized array (if $1 is neither set to
    #       "array" nor to "print")
    # - uncolorized_array: the uncolorized array (if $1 is set to
    #       "array")
    #
    # Output:
    # - the uncolorized string (if $1 is set to "print")

    # Define the local variables.
    local file_descriptor
    local joined_array
    local var

    # Read the arguments.
    var="$1"
    file_descriptor="$2"

    if [[ "${var}" != "array" ]]; then
        # Set ${uncolorized_array} as local instead of nonlocal
        # variable, since it's not used by the calling function (the
        # joined uncolorized array shall be printed or set to a
        # variable, instead).
        local -a uncolorized_array
    fi

    shift
    uncolorized_array=("$@")

    # Remove the Select Graphic Rendition (SGR) ANSI escape sequence
    # codes from the array's elements.  The sequences consist of an ESC
    # character, an opening bracket, and an arbitrary number of codes
    # with one to three digits, separated by semicolons, and finally
    # followed by an "m".
    uncolorized_array=("${uncolorized_array[@]//$'\e['+([0-9;])m}")

    # Join the uncolorized array, then print it or set it to the target
    # variable, using a name reference to the variable name given as
    # ${var} (i.e., as $1).
    if [[ "${var}" == "print" ]]; then
        argparser_join $'\n' "${uncolorized_array[@]}"
        printf '%s' "${joined_array}" >&"${file_descriptor}"
    elif [[ "${var}" != "array" ]]; then
        argparser_join $'\n' "${uncolorized_array[@]}"
        declare -n var="${var}"
        var="${joined_array}"
    fi
}

function argparser_draw_frame() {
    # Draw a colorized frame around an array's elements.
    #
    # Arguments:
    # - $1: the frame styles to use as
    #       ${ARGPARSER_ARG_DELIMITER_2}-separated list
    # - $2: the file descriptor to write to (1 or 2)
    # - $3: the variable to set the joined framed array to; if set to
    #       "array", set the entire framed array's elements to
    #       ${framed_array}; if set to "print", print the joined framed
    #       array instead
    # - $4: the frame's caption
    # - $@: the array to frame
    #
    # Nonlocals:
    # - $3: the joined framed array (if $3 is neither set to "array" nor
    #       to "print")
    # - framed_array: the framed array (if $3 is set to "array")
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    #
    # Output:
    # - the framed string (if $3 is set to "print")

    # Define the local variables.
    local caption
    local -a colors_arr
    local colors_str
    local corner_style
    local -a corner_styles
    local file_descriptor
    local -A frame_chars
    local frame_bottom
    local frame_top
    local frame_top_1
    local frame_top_2
    local frame_vertical
    local i
    local joined_array
    local line_style
    local -a line_styles
    local line_width
    local -a line_widths
    local style_request
    local -a style_requests
    local -a uncolorized_array
    local uncolorized_caption
    local var

    # Read the arguments.
    style_requests="$1"
    file_descriptor="$2"
    var="$3"
    caption="$4"

    if [[ "${var}" != "array" ]]; then
        # Set ${framed_array} as local instead of nonlocal variable,
        # since it's not used by the calling function (the joined framed
        # array shall be printed or set to a variable, instead).
        local -a framed_array
    fi

    shift 4
    framed_array=("$@")

    # Define the indexed arrays with frame styles, as well as their
    # default values.
    corner_style="angular"
    corner_styles=(
        "angular"
        "rounded"
        "double"
    )

    line_style="solid"
    line_styles=(
        "solid"
        "double-dashed"
        "triple-dashed"
        "quadruple-dashed"
    )

    line_width="thin"
    line_widths=(
        "thin"
        "thick"
        "double"
    )

    # Split the requested frame styles on ${ARGPARSER_ARG_DELIMITER_2}
    # characters and separate them by their purpose as corner style,
    # line style, line width modifier, or color.  Later styles override
    # the respective category's style specified earlier.
    colors_arr=( )
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a style_requests \
        <<< "${style_requests}"
    for style_request in "${style_requests[@]}"; do
        if argparser_in_array "${style_request}" "${corner_styles[@]}"; then
            corner_style="${style_request}"
        fi

        if argparser_in_array "${style_request}" "${line_styles[@]}"; then
            line_style="${style_request}"
        fi

        if argparser_in_array "${style_request}" "${line_widths[@]}"; then
            line_width="${style_request}"
        fi

        if argparser_check_styles "colors" "${style_request}"; then
            colors_arr+=("${style_request}")
        fi
    done

    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colors_arr[@]}"
    colors_str="${joined_array}"

    # Set the box drawing characters corresponding to the requested
    # frame styles per category.
    if [[ "${corner_style}" == "angular" ]]; then
        if [[ "${line_width}" == "thin" ]]; then
            frame_chars["top-left"]=$'\u250C'
            frame_chars["top-right"]=$'\u2510'
            frame_chars["bottom-left"]=$'\u2514'
            frame_chars["bottom-right"]=$'\u2518'
        elif [[ "${line_width}" == "thick" ]]; then
            frame_chars["top-left"]=$'\u250F'
            frame_chars["top-right"]=$'\u2513'
            frame_chars["bottom-left"]=$'\u2517'
            frame_chars["bottom-right"]=$'\u251B'
        elif [[ "${line_width}" == "double" ]]; then
            frame_chars["top-left"]=$'\u2554'
            frame_chars["top-right"]=$'\u2557'
            frame_chars["bottom-left"]=$'\u255A'
            frame_chars["bottom-right"]=$'\u255D'
        fi
    elif [[ "${corner_style}" == "rounded" ]]; then
        frame_chars["top-left"]=$'\u256D'
        frame_chars["top-right"]=$'\u256E'
        frame_chars["bottom-left"]=$'\u2570'
        frame_chars["bottom-right"]=$'\u256F'
    elif [[ "${corner_style}" == "double" ]]; then
        frame_chars["top-left"]=$'\u2554'
        frame_chars["top-right"]=$'\u2557'
        frame_chars["bottom-left"]=$'\u255A'
        frame_chars["bottom-right"]=$'\u255D'
    fi

    if [[ "${line_style}" == "solid" ]]; then
        if [[ "${line_width}" == "thin" ]]; then
            frame_chars["horizontal"]=$'\u2500'
            frame_chars["vertical"]=$'\u2502'
        elif [[ "${line_width}" == "thick" ]]; then
            frame_chars["horizontal"]=$'\u2501'
            frame_chars["vertical"]=$'\u2503'
        elif [[ "${line_width}" == "double" ]]; then
            frame_chars["horizontal"]=$'\u2550'
            frame_chars["vertical"]=$'\u2551'
        fi
    elif [[ "${line_style}" == "double-dashed" ]]; then
        if [[ "${line_width}" == "thin" ]]; then
            frame_chars["horizontal"]=$'\u254C'
            frame_chars["vertical"]=$'\u254E'
        elif [[ "${line_width}" == "thick" ]]; then
            frame_chars["horizontal"]=$'\u254D'
            frame_chars["vertical"]=$'\u254F'
        elif [[ "${line_width}" == "double" ]]; then
            frame_chars["horizontal"]=$'\u2550'
            frame_chars["vertical"]=$'\u2551'
        fi
    elif [[ "${line_style}" == "triple-dashed" ]]; then
        if [[ "${line_width}" == "thin" ]]; then
            frame_chars["horizontal"]=$'\u2504'
            frame_chars["vertical"]=$'\u2506'
        elif [[ "${line_width}" == "thick" ]]; then
            frame_chars["horizontal"]=$'\u2505'
            frame_chars["vertical"]=$'\u2507'
        elif [[ "${line_width}" == "double" ]]; then
            frame_chars["horizontal"]=$'\u2550'
            frame_chars["vertical"]=$'\u2551'
        fi
    elif [[ "${line_style}" == "quadruple-dashed" ]]; then
        if [[ "${line_width}" == "thin" ]]; then
            frame_chars["horizontal"]=$'\u2508'
            frame_chars["vertical"]=$'\u250A'
        elif [[ "${line_width}" == "thick" ]]; then
            frame_chars["horizontal"]=$'\u2509'
            frame_chars["vertical"]=$'\u250B'
        elif [[ "${line_width}" == "double" ]]; then
            frame_chars["horizontal"]=$'\u2550'
            frame_chars["vertical"]=$'\u2551'
        fi
    fi

    # Surround the array by a frame, if there were styles requested.
    if (( "${#style_requests[@]}" > 0 )); then
        # Create an uncolorized copy of the array to compute the line
        # length, below.  Then, surround the lines with (colorized)
        # vertical lines, separated by a space each.
        argparser_uncolorize "array" "${framed_array[@]}"
        argparser_colorize "${colors_str}" "${file_descriptor}" \
            frame_vertical "${frame_chars["vertical"]}"

        for i in "${!framed_array[@]}"; do
            framed_array[i]="${frame_vertical} ${framed_array[i]} ${frame_vertical}"
        done

        # Surround the entire array by (colorized) horizontal lines,
        # which are as long as any line in the uncolorized array, plus
        # the two spaces separation to the left and right between the
        # array's contents and the frame's vertical lines.  For the top
        # line, possibly add the caption (if non-empty) to the left of
        # the frame (after one frame character), which is already
        # surrounded by a space each.  Additionally, add the frame's
        # four corner characters.
        if [[ -n "${caption}" ]]; then
            argparser_colorize "${colors_str}" "${file_descriptor}" \
                frame_top_1 \
                "${frame_chars["top-left"]}${frame_chars["horizontal"]}"

            argparser_uncolorize uncolorized_caption "${caption}"
            printf -v frame_top_2 '%*s' \
                "$(( "${#uncolorized_array[0]}" - "${#uncolorized_caption}" \
                    + 1 ))" \
                ""
            frame_top_2="${frame_top_2// /${frame_chars["horizontal"]}}"

            argparser_colorize "${colors_str}" "${file_descriptor}" \
                frame_top_2 "${frame_top_2}${frame_chars["top-right"]}"

            frame_top="${frame_top_1}${caption}${frame_top_2}"
        else
            printf -v frame_top '%*s' "$(( "${#uncolorized_array[0]}" + 2 ))" \
                ""
            frame_top="${frame_top// /${frame_chars["horizontal"]}}"

            argparser_colorize "${colors_str}" "${file_descriptor}" frame_top \
                "${frame_chars["top-left"]}${frame_top}${frame_chars["top-right"]}"
        fi

        printf -v frame_bottom '%*s' "$(( "${#uncolorized_array[0]}" + 2 ))" ""
        frame_bottom="${frame_bottom// /${frame_chars["horizontal"]}}"

        argparser_colorize "${colors_str}" "${file_descriptor}" frame_bottom \
            "${frame_chars["bottom-left"]}${frame_bottom}${frame_chars["bottom-right"]}"

        framed_array=(
            "${frame_top}"
            "${framed_array[@]}"
            "${frame_bottom}"
        )
    fi

    # Join the framed array, then print it or set it to the target
    # variable, using a name reference to the variable name given as
    # ${var} (i.e., as $3).
    if [[ "${var}" == "print" ]]; then
        argparser_join $'\n' "${framed_array[@]}"
        printf '%s' "${joined_array}" >&"${file_descriptor}"
    elif [[ "${var}" != "array" ]]; then
        argparser_join $'\n' "${framed_array[@]}"
        declare -n var="${var}"
        var="${joined_array}"
    fi
}

# Define the Argparser functions for reading the configuration and
# setting and checking the environment variables.
function argparser_read_configuration() {
    # Read the configuration from the configuration file into the
    # environment variables.
    #
    # Environment:
    # ARGPARSER_ADD_HELP
    # ARGPARSER_ADD_USAGE
    # ARGPARSER_ADD_VERSION
    # ARGPARSER_ALLOW_ARG_INTERMIXING
    # ARGPARSER_ALLOW_FLAG_INVERSION
    # ARGPARSER_ALLOW_FLAG_NEGATION
    # ARGPARSER_ALLOW_OPTION_ABBREVIATION
    # ARGPARSER_ALLOW_OPTION_MERGING
    # ARGPARSER_ARG_ARRAY_NAME
    # ARGPARSER_ARG_DEF_FILE
    # ARGPARSER_ARG_DELIMITER_1
    # ARGPARSER_ARG_DELIMITER_2
    # ARGPARSER_CHECK_ARG_DEF
    # ARGPARSER_CHECK_ENV_VARS
    # ARGPARSER_CONFIG_FILE (read-only)
    # ARGPARSER_COUNT_FLAGS
    # ARGPARSER_ERROR_EXIT_CODE
    # ARGPARSER_ERROR_STYLE
    # ARGPARSER_HELP_ARG_GROUP
    # ARGPARSER_HELP_DESCRIPTION
    # ARGPARSER_HELP_EXIT_CODE
    # ARGPARSER_HELP_FILE
    # ARGPARSER_HELP_FILE_INCLUDE_CHAR
    # ARGPARSER_HELP_FILE_KEEP_COMMENTS
    # ARGPARSER_HELP_STYLE
    # ARGPARSER_LANGUAGE
    # ARGPARSER_MAX_COL_WIDTH_1
    # ARGPARSER_MAX_COL_WIDTH_2
    # ARGPARSER_MAX_COL_WIDTH_3
    # ARGPARSER_MAX_WIDTH
    # ARGPARSER_POSITIONAL_ARG_GROUP
    # ARGPARSER_READ_ARGS
    # ARGPARSER_SCRIPT_NAME
    # ARGPARSER_SET_ARGS
    # ARGPARSER_SET_ARRAYS
    # ARGPARSER_SILENCE_ERRORS
    # ARGPARSER_SILENCE_WARNINGS
    # ARGPARSER_STYLE_FILE
    # ARGPARSER_TRANSLATION_FILE
    # ARGPARSER_UNSET_ARGS
    # ARGPARSER_UNSET_ENV_VARS
    # ARGPARSER_UNSET_FUNCTIONS
    # ARGPARSER_USAGE_EXIT_CODE
    # ARGPARSER_USAGE_FILE
    # ARGPARSER_USAGE_FILE_INCLUDE_CHAR
    # ARGPARSER_USAGE_FILE_KEEP_COMMENTS
    # ARGPARSER_USAGE_MESSAGE_OPTION_TYPE
    # ARGPARSER_USAGE_MESSAGE_ORIENTATION
    # ARGPARSER_USAGE_STYLE
    # ARGPARSER_USE_LONG_OPTIONS
    # ARGPARSER_USE_SHORT_OPTIONS
    # ARGPARSER_USE_STYLES
    # ARGPARSER_USE_STYLES_IN_FILES
    # ARGPARSER_VERSION_EXIT_CODE
    # ARGPARSER_VERSION_NUMBER
    # ARGPARSER_VERSION_STYLE
    # ARGPARSER_WARNING_STYLE

    # Define the local variables.
    local error_message
    local -a error_messages
    local file_attributes
    local line
    local -a lines
    local trimmed_string
    local value
    local var

    # Check if the configuration file exists and is readable.  Else,
    # output an error message and exit.  Since at this point of
    # invokation, the environment variables aren't checked, yet, set the
    # needed ones to default values, if ${ARGPARSER_CHECK_ENV_VARS}
    # isn't set to "false" (and by this, the checking hasn't been
    # explicitly disabled).
    argparser_check_file "${ARGPARSER_CONFIG_FILE}"
    if [[ "${file_attributes}" != "0000" ]]; then
        error_message="Error: The environment variable \"\$1\" is set to "
        error_message+="\"\$2\", but the referenced file "
        case "${file_attributes}" in
            0001) error_message+="is empty." ;;
            0010) error_message+="is not readable." ;;
            0011) error_message+="is not readable and empty." ;;
            0100) error_message+="is not a regular file." ;;
            0101) error_message+="is not a regular file and empty." ;;
            0110) error_message+="is not a regular file and not readable." ;;
            0111)
                error_message+="is not a regular file, not readable, and "
                error_message+="empty."
                ;;
            1111) error_message+="does not exist." ;;
        esac

        error_message="${error_message/"\$1"/"ARGPARSER_CONFIG_FILE"}"
        error_message="${error_message/"\$2"/${ARGPARSER_CONFIG_FILE}}"

        if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
            argparser_set_env_var_defaults
        fi

        argparser_print_error_messages false true "${error_message}"
    fi

    # Read the configuration file.
    mapfile -t lines < "${ARGPARSER_CONFIG_FILE}"
    error_messages=( )

    for line in "${lines[@]}"; do
        if [[ -z "${line}" || "${line}" == \#* ]]; then
            # Ignore the empty or commented line.
            continue
        elif [[ "${line}" == *( )"args"*( )=* ]]; then
            # Output an error message when the line sets
            # ${ARGPARSER_ARGS}.
            error_message="Error: In the configuration file \"\$1\", the line "
            error_message+="\"\$2\" sets ARGPARSER_ARGS, which is an "
            error_message+="internal variable and must not be set."

            error_message="${error_message/"\$1"/"${ARGPARSER_CONFIG_FILE}"}"
            error_message="${error_message/"\$2"/"${line}"}"
            error_messages+=("${error_message}")
        elif [[ "${line}" == *=* ]]; then
            # Set the variable name as shortest part before an equals
            # sign ("="), strip leading and trailing spaces, replace
            # hyphens and spaces by underscores, capitalize the variable
            # name, and prepend the string "ARGPARSER_".  Then, extract
            # the value as longest part after the equals sign and strip
            # leading and trailing spaces and a double quote each.
            var="${line%%=*}"
            argparser_trim "${var}"
            var="${trimmed_string}"
            var="${var//-/_}"
            var="${var// /_}"
            var="ARGPARSER_${var^^}"

            value="${line#*=}"
            argparser_trim "${value}"
            value="${trimmed_string}"
            value="${value#\"}"
            value="${value%\"}"

            # Set the environment variable, as long as it isn't already
            # set by the calling script or environment to prevent
            # overriding it.
            if [[ ! -v "${var}" ]]; then
                declare -g "${var}"="${value}"
            fi
        else
            # Output an error message when the line doesn't contain an
            # equals sign ("=").
            error_message="Error: In the configuration file \"\$1\", the line "
            error_message+="\"\$2\" doesn't contain an equals sign (\"=\"), "
            error_message+="nor is it empty or commented."

            error_message="${error_message/"\$1"/"${ARGPARSER_CONFIG_FILE}"}"
            error_message="${error_message/"\$2"/"${line}"}"
            error_messages+=("${error_message}")
        fi
    done

    # If there are error messages, sort, filter, colorize, and print
    # them, then exit, as the environment variables should be correctly
    # read.
    if (( "${#error_messages[@]}" > 0 )) \
        && [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]
    then
        argparser_set_env_var_defaults
    fi

    argparser_print_error_messages true true "${error_messages[@]}"
}

function argparser_set_env_vars() {
    # Set the Argparser environment variables, as long as they aren't
    # already set by the calling script or environment to prevent
    # overriding them.
    #
    # Arguments:
    # - $@: the command line upon sourcing the Argparser
    #
    # Nonlocals:
    # - argparser_version: the Argparser's own version number
    # - script_args: the script's command line
    #
    # Environment:
    # ARGPARSER_ADD_HELP
    # ARGPARSER_ADD_USAGE
    # ARGPARSER_ADD_VERSION
    # ARGPARSER_ALLOW_ARG_INTERMIXING
    # ARGPARSER_ALLOW_FLAG_INVERSION
    # ARGPARSER_ALLOW_FLAG_NEGATION
    # ARGPARSER_ALLOW_OPTION_ABBREVIATION
    # ARGPARSER_ALLOW_OPTION_MERGING
    # ARGPARSER_ARG_ARRAY_NAME
    # ARGPARSER_ARG_DEF_FILE
    # ARGPARSER_ARG_DELIMITER_1
    # ARGPARSER_ARG_DELIMITER_2
    # ARGPARSER_ARGS
    # ARGPARSER_CHECK_ARG_DEF
    # ARGPARSER_CHECK_ENV_VARS
    # ARGPARSER_CONFIG_FILE
    # ARGPARSER_COUNT_FLAGS
    # ARGPARSER_CREATE_ARG_DEF
    # ARGPARSER_DEBUG
    # ARGPARSER_ERROR_EXIT_CODE
    # ARGPARSER_ERROR_STYLE
    # ARGPARSER_HELP_ARG_GROUP
    # ARGPARSER_HELP_DESCRIPTION
    # ARGPARSER_HELP_EXIT_CODE
    # ARGPARSER_HELP_FILE
    # ARGPARSER_HELP_FILE_INCLUDE_CHAR
    # ARGPARSER_HELP_FILE_KEEP_COMMENTS
    # ARGPARSER_HELP_OPTIONS
    # ARGPARSER_HELP_STYLE
    # ARGPARSER_LANGUAGE
    # ARGPARSER_MAX_COL_WIDTH_1
    # ARGPARSER_MAX_COL_WIDTH_2
    # ARGPARSER_MAX_COL_WIDTH_3
    # ARGPARSER_MAX_WIDTH
    # ARGPARSER_POSITIONAL_ARG_GROUP
    # ARGPARSER_READ_ARGS
    # ARGPARSER_SCRIPT_NAME
    # ARGPARSER_SET_ARGS
    # ARGPARSER_SET_ARRAYS
    # ARGPARSER_SILENCE_ERRORS
    # ARGPARSER_SILENCE_WARNINGS
    # ARGPARSER_STYLE_FILE
    # ARGPARSER_TRANSLATION_FILE
    # ARGPARSER_UNSET_ARGS
    # ARGPARSER_UNSET_ENV_VARS
    # ARGPARSER_UNSET_FUNCTIONS
    # ARGPARSER_USAGE_EXIT_CODE
    # ARGPARSER_USAGE_FILE
    # ARGPARSER_USAGE_FILE_INCLUDE_CHAR
    # ARGPARSER_USAGE_FILE_KEEP_COMMENTS
    # ARGPARSER_USAGE_MESSAGE_OPTION_TYPE
    # ARGPARSER_USAGE_MESSAGE_ORIENTATION
    # ARGPARSER_USAGE_OPTIONS
    # ARGPARSER_USAGE_STYLE
    # ARGPARSER_USE_LONG_OPTIONS
    # ARGPARSER_USE_SHORT_OPTIONS
    # ARGPARSER_USE_STYLES
    # ARGPARSER_USE_STYLES_IN_FILES
    # ARGPARSER_VERSION_EXIT_CODE
    # ARGPARSER_VERSION_NUMBER
    # ARGPARSER_VERSION_OPTIONS
    # ARGPARSER_VERSION_STYLE
    # ARGPARSER_WARNING_STYLE
    # ARGPARSER_WRITE_ARGS

    # Define the local variables.
    local arg
    local arg_key
    local -a args
    local value

    # As the Argparser can be sourced with command-line arguments,
    # separate them from the script's command line.  Any argument until
    # the first "--" is seen as argument to the Argparser.  Lastly,
    # shift also the "--" and set ${script_args} to the remainder of the
    # command line.
    # In order to show the need for the script's command line in the
    # Argparser's help and usage message, ${script_args} is added to the
    # Argparser's arguments definition as mandatory positional argument.
    # Since using its actual value would mean that upon parsing, a "++"
    # in the script's arguments would be interpreted as sign to
    # re-evaluate the arguments as keyword arguments for the Argparser
    # (and not for the script), set the string "argparser" as dummy
    # value for the positional argument.  As only keyword arguments are
    # set as environment variables, below, the actual value of
    # ${script_args} won't be overridden and kept as the script's
    # command line.
    args=( )

    # shellcheck disable=SC2190  # Indexed, not associative array.
    while (( "$#" > 0 )) && [[ -n "$1" && "$1" != "--" ]]; do
        args+=("$1")
        shift
    done
    if (( "$#" > 0 )) && [[ -n "$1" && "$1" == "--" ]]; then
        shift
    fi
    script_args=("$@")
    # shellcheck disable=SC2190  # Indexed, not associative array.
    args+=("--" "argparser")

    # Set all non-internal environment variables by reading the
    # Argparser's command line given upon sourcing the Argparser, using
    # the Argparser itself with default values for all environment
    # variables (which are yet to be set).
    ARGPARSER_ARGS=(
        "id                                  : long_opts                 : val_names    : defaults             : choices               : type : arg_no : arg_group                     : notes      : help                                                                                                                    "
        "ARGPARSER_ADD_HELP                  : add-help                  :              : true                 :                       : bool : 0      : General options               :            : add ARGPARSER_HELP_OPTIONS and --help as flags to call the help message                                                 "
        "ARGPARSER_ADD_USAGE                 : add-usage                 :              : true                 :                       : bool : 0      : General options               :            : add ARGPARSER_USAGE_OPTIONS and --usage as flags to call the usage message                                              "
        "ARGPARSER_ADD_VERSION               : add-version               :              : true                 :                       : bool : 0      : General options               :            : add ARGPARSER_VERSION_OPTIONS and --version as flags to call the version message                                        "
        "ARGPARSER_ALLOW_ARG_INTERMIXING     : allow-arg-intermixing     :              : true                 :                       : bool : 0      : Parsing options               :            : allow the user to intermix positional and keyword arguments                                                             "
        "ARGPARSER_ALLOW_FLAG_INVERSION      : allow-flag-inversion      :              : true                 :                       : bool : 0      : Parsing options               :            : allow the user to invert flags by prefixing them with \"+\" (short options) or \"++\" (long options)                    "
        "ARGPARSER_ALLOW_FLAG_NEGATION       : allow-flag-negation       :              : true                 :                       : bool : 0      : Parsing options               :            : allow the user to negate long-option flags by prefixing them with \"no-\"                                               "
        "ARGPARSER_ALLOW_OPTION_ABBREVIATION : allow-option-abbreviation :              : false                :                       : bool : 0      : Parsing options               :            : allow the user to give long option names in abbreviated form                                                            "
        "ARGPARSER_ALLOW_OPTION_MERGING      : allow-option-merging      :              : false                :                       : bool : 0      : Parsing options               :            : allow the user to give short option names in merged (concatenated) form                                                 "
        "ARGPARSER_ARG_ARRAY_NAME            : arg-array-name            : NAME         : args                 :                       : str  : 1      : Parsing options               :            : the indexed array for the raw arguments and the associative array for the parsed arguments                              "
        "ARGPARSER_ARG_DEF_FILE              : arg-def-file              : FILE         : ''                   :                       : file : 1      : General options               :            : the path to a file holding the definition of the arguments                                                              "
        "ARGPARSER_ARG_DELIMITER_1           : arg-delimiter-1           : CHAR         : |                    :                       : char : 1      : General options               :            : the primary delimiter that separates the fields in the arguments definition                                             "
        "ARGPARSER_ARG_DELIMITER_2           : arg-delimiter-2           : CHAR         : ,                    :                       : char : 1      : General options               :            : the secondary delimiter that separates the elements of sequences in the arguments definition                            "
        "ARGPARSER_CHECK_ARG_DEF             : check-arg-def             :              : false                :                       : bool : 0      : General options               :            : check if the arguments definition is consistent                                                                         "
        "ARGPARSER_CHECK_ENV_VARS            : check-env-vars            :              : false                :                       : bool : 0      : General options               :            : check if the Argparser environment variables accord to their definition                                                 "
        "ARGPARSER_CONFIG_FILE               : config-file               : FILE         : ''                   :                       : file : 1      : General options               :            : the path to a file holding the Argparser configuration                                                                  "
        "ARGPARSER_COUNT_FLAGS               : count-flags               :              : false                :                       : bool : 0      : Parsing options               :            : count flags instead of setting them to \"true\" or \"false\" based on the last prefix used on the command line          "
        "ARGPARSER_CREATE_ARG_DEF            : create-arg-def            :              : false                :                       : bool : 0      : General options               :            : create the arguments definition for a script                                                                            "
        "ARGPARSER_DEBUG                     : debug                     :              : false                :                       : bool : 0      : Miscellaneous options         :            : (EXPERT OPTION) run the Argparser in debug mode, writing the stack trace for each command to STDERR                     "
        "ARGPARSER_ERROR_EXIT_CODE           : error-exit-code           : INT          : 1                    :                       : int  : 1      : Error/warning message options :            : the exit code when errors occurred upon parsing                                                                         "
        "ARGPARSER_ERROR_STYLE               : error-style               : STYLE        : red,bold,reverse     :                       : str  : +      : Stylization options           : deprecated : the color and style specification for error messages, deprecated in favor of \"--style-file=FILE\"                      "
        "ARGPARSER_HELP_ARG_GROUP            : help-arg-group            : NAME         : Help options         :                       : str  : 1      : Help/usage message options    :            : the name of the argument group holding all help options, i.e., --help, --usage, and --version                           "
        "ARGPARSER_HELP_DESCRIPTION          : help-description          : TEXT         : ''                   :                       : str  : 1      : Help/usage message options    :            : the script's description (purpose) to show in help message                                                              "
        "ARGPARSER_HELP_EXIT_CODE            : help-exit-code            : INT          : 0                    :                       : int  : 1      : Help/usage message options    :            : the exit code for help messages                                                                                         "
        "ARGPARSER_HELP_FILE                 : help-file                 : FILE         : ''                   :                       : file : 1      : Help/usage message options    :            : the path to a file holding the extended help message                                                                    "
        "ARGPARSER_HELP_FILE_INCLUDE_CHAR    : help-file-include-char    : CHAR         : @                    :                       : char : 1      : Help/usage message options    :            : the character that introduces an include directive in an ARGPARSER_HELP_FILE                                            "
        "ARGPARSER_HELP_FILE_KEEP_COMMENTS   : help-file-keep-comments   :              : false                :                       : bool : 0      : Help/usage message options    :            : keep commented lines in the help file                                                                                   "
        "ARGPARSER_HELP_OPTIONS              : help-options              : CHAR         : h,?                  :                       : char : +      : Help/usage message options    :            : the short (single-character) option names to invoke the help message                                                    "
        "ARGPARSER_HELP_STYLE                : help-style                : STYLE        : italic               :                       : str  : +      : Stylization options           : deprecated : the color and style specification for help messages, deprecated in favor of \"--style-file=FILE\"                       "
        "ARGPARSER_LANGUAGE                  : language                  : LANG         : en                   :                       : str  : 1      : Localization options          :            : the language in which to localize the help and usage messages                                                           "
        "ARGPARSER_MAX_COL_WIDTH_1           : max-col-width-1           : INT          : 9                    :                       : uint : 1      : Stylization options           :            : the maximum column width of the first column in the help message                                                        "
        "ARGPARSER_MAX_COL_WIDTH_2           : max-col-width-2           : INT          : 33                   :                       : uint : 1      : Stylization options           :            : the maximum column width of the second column in the help message                                                       "
        "ARGPARSER_MAX_COL_WIDTH_3           : max-col-width-3           : INT          : 0                    :                       : uint : 1      : Stylization options           :            : the maximum column width of the third column in the help message                                                        "
        "ARGPARSER_MAX_WIDTH                 : max-width                 : INT          : 79                   :                       : uint : 1      : Stylization options           :            : the maximum width of the help message                                                                                   "
        "ARGPARSER_POSITIONAL_ARG_GROUP      : positional-arg-group      : NAME         : Positional arguments :                       : str  : 1      : General options               :            : the name of the argument group holding all positional arguments                                                         "
        "ARGPARSER_READ_ARGS                 : read-args                 :              : true                 :                       : bool : 0      : General options               :            : read the arguments and parse them to ARGPARSER_ARG_ARRAY_NAME                                                           "
        "ARGPARSER_SCRIPT_NAME               : script-name               : NAME         : ''                   :                       : str  : 1      : General options               :            : the script's name for the help, usage, version, error, and warning messages                                             "
        "ARGPARSER_SET_ARGS                  : set-args                  :              : true                 :                       : bool : 0      : General options               :            : set the arguments from ARGPARSER_ARG_ARRAY_NAME as variables in the script's scope                                      "
        "ARGPARSER_SET_ARRAYS                : set-arrays                :              : true                 :                       : bool : 0      : General options               :            : set arguments intended to have multiple values as indexed array                                                         "
        "ARGPARSER_SILENCE_ERRORS            : silence-errors            :              : false                :                       : bool : 0      : Error/warning message options :            : silence the emission (output) of error messages                                                                         "
        "ARGPARSER_SILENCE_WARNINGS          : silence-warnings          :              : false                :                       : bool : 0      : Error/warning message options :            : silence the emission (output) of warning messages                                                                       "
        "ARGPARSER_STYLE_FILE                : style-file                : FILE         : ''                   :                       : file : 1      : Stylization options           :            : the path to a file holding the style definitions for the messages                                                       "
        "ARGPARSER_TRANSLATION_FILE          : translation-file          : FILE         : ''                   :                       : file : 1      : Localization options          :            : the path to a simplified YAML file holding the translation to ARGPARSER_LANGUAGE                                        "
        "ARGPARSER_UNSET_ARGS                : unset-args                :              : true                 :                       : bool : 0      : General options               :            : unset (remove) all command-line arguments given to the script                                                           "
        "ARGPARSER_UNSET_ENV_VARS            : unset-env-vars            :              : true                 :                       : bool : 0      : General options               :            : unset (remove) the Argparser environment variables from the environment                                                 "
        "ARGPARSER_UNSET_FUNCTIONS           : unset-functions           :              : true                 :                       : bool : 0      : General options               :            : unset (remove) the Argparser functions from the environment                                                             "
        "ARGPARSER_USAGE_EXIT_CODE           : usage-exit-code           : INT          : 0                    :                       : int  : 1      : Help/usage message options    :            : the exit code for usage messages                                                                                        "
        "ARGPARSER_USAGE_FILE                : usage-file                : FILE         : ''                   :                       : file : 1      : Help/usage message options    :            : the path to a file holding the extended usage message                                                                   "
        "ARGPARSER_USAGE_FILE_INCLUDE_CHAR   : usage-file-include-char   : CHAR         : @                    :                       : char : 1      : Help/usage message options    :            : the character that introduces an include directive in an ARGPARSER_USAGE_FILE                                           "
        "ARGPARSER_USAGE_FILE_KEEP_COMMENTS  : usage-file-keep-comments  :              : false                :                       : bool : 0      : Help/usage message options    :            : keep commented lines in the usage file                                                                                  "
        "ARGPARSER_USAGE_MESSAGE_OPTION_TYPE : usage-message-option-type :              : short                : long,short            : str  : 1      : Help/usage message options    :            : use short or long option names in usage messages                                                                        "
        "ARGPARSER_USAGE_MESSAGE_ORIENTATION : usage-message-orientation :              : row                  : row,column            : str  : 1      : Help/usage message options    :            : output the positional and keyword arguments in usage messages in a row or in a column                                   "
        "ARGPARSER_USAGE_OPTIONS             : usage-options             : CHAR         : u                    :                       : char : +      : Help/usage message options    :            : the short (single-character) option names to invoke the usage message                                                   "
        "ARGPARSER_USAGE_STYLE               : usage-style               : STYLE        : italic               :                       : str  : +      : Stylization options           : deprecated : the color and style specification for usage messages, deprecated in favor of \"--style-file=FILE\"                      "
        "ARGPARSER_USE_LONG_OPTIONS          : use-long-options          :              : true                 :                       : bool : 0      : Parsing options               :            : use the long option names for parsing                                                                                   "
        "ARGPARSER_USE_SHORT_OPTIONS         : use-short-options         :              : true                 :                       : bool : 0      : Parsing options               :            : use the short option names for parsing                                                                                  "
        "ARGPARSER_USE_STYLES                : use-styles                :              : tty                  : always,never,file,tty : str  : 1      : Stylization options           :            : use the colors and styles \"always\", \"never\", or only when STDOUT/STDERR is (\"tty\") or is not (\"file\") a terminal"
        "ARGPARSER_USE_STYLES_IN_FILES       : use-styles-in-files       :              : false                :                       : bool : 0      : Stylization options           : deprecated : use the colors and styles when STDOUT/STDERR is not a terminal, deprecated in favor of \"--use-styles=always\"          "
        "ARGPARSER_VERSION_EXIT_CODE         : version-exit-code         : INT          : 0                    :                       : int  : 1      : Version message options       :            : the exit code for version messages                                                                                      "
        "ARGPARSER_VERSION_NUMBER            : version-number            : VERSION      : 1.0.0                :                       : str  : 1      : Version message options       :            : the script's version number for the version message                                                                     "
        "ARGPARSER_VERSION_OPTIONS           : version-options           : CHAR         : V                    :                       : char : +      : Version message options       :            : the short (single-character) option names to invoke the version message                                                 "
        "ARGPARSER_VERSION_STYLE             : version-style             : STYLE        : bold                 :                       : str  : +      : Stylization options           : deprecated : the color and style specification for version messages, deprecated in favor of \"--style-file=FILE\"                    "
        "ARGPARSER_WARNING_STYLE             : warning-style             : STYLE        : red,bold             :                       : str  : +      : Stylization options           : deprecated : the color and style specification for warning messages, deprecated in favor of \"--style-file=FILE\"                    "
        "ARGPARSER_WRITE_ARGS                : write-args                :              : false                :                       : bool : 0      : General options               :            : write the arguments from ARGPARSER_ARG_ARRAY_NAME to STDOUT                                                             "
        "script_args                         :                           : command_line :                      :                       : str  : +      : Positional arguments          :            : the indexed array in which the Argparser stores the script's command line upon parsing its own arguments                "
    )

    ARGPARSER_ADD_HELP=true \
        ARGPARSER_ADD_USAGE=true \
        ARGPARSER_ADD_VERSION=true \
        ARGPARSER_ALLOW_ARG_INTERMIXING=false \
        ARGPARSER_ALLOW_FLAG_INVERSION=true \
        ARGPARSER_ALLOW_FLAG_NEGATION=true \
        ARGPARSER_ALLOW_OPTION_ABBREVIATION=false \
        ARGPARSER_ALLOW_OPTION_MERGING=false \
        ARGPARSER_ARG_ARRAY_NAME="ARGPARSER_ARGS" \
        ARGPARSER_ARG_DEF_FILE="" \
        ARGPARSER_ARG_DELIMITER_1=":" \
        ARGPARSER_ARG_DELIMITER_2="," \
        ARGPARSER_CHECK_ARG_DEF=false \
        ARGPARSER_CHECK_ENV_VARS=false \
        ARGPARSER_CONFIG_FILE="" \
        ARGPARSER_COUNT_FLAGS=false \
        ARGPARSER_CREATE_ARG_DEF=false \
        ARGPARSER_ERROR_EXIT_CODE=1 \
        ARGPARSER_HELP_ARG_GROUP="Help options" \
        ARGPARSER_HELP_DESCRIPTION="" \
        ARGPARSER_HELP_EXIT_CODE=0 \
        ARGPARSER_HELP_FILE="" \
        ARGPARSER_HELP_FILE_INCLUDE_CHAR="@" \
        ARGPARSER_HELP_FILE_KEEP_COMMENTS=false \
        ARGPARSER_HELP_OPTIONS="h,?" \
        ARGPARSER_LANGUAGE="en" \
        ARGPARSER_MAX_COL_WIDTH_1=5 \
        ARGPARSER_MAX_COL_WIDTH_2=33 \
        ARGPARSER_MAX_COL_WIDTH_3=0 \
        ARGPARSER_MAX_WIDTH=79 \
        ARGPARSER_POSITIONAL_ARG_GROUP="Positional arguments" \
        ARGPARSER_READ_ARGS=true \
        ARGPARSER_SCRIPT_NAME="${BASH_SOURCE[0]##*/}" \
        ARGPARSER_SET_ARGS=false \
        ARGPARSER_SET_ARRAYS=false \
        ARGPARSER_SILENCE_ERRORS=false \
        ARGPARSER_SILENCE_WARNINGS=false \
        ARGPARSER_STYLE_FILE="" \
        ARGPARSER_TRANSLATION_FILE="" \
        ARGPARSER_UNSET_ARGS=true \
        ARGPARSER_UNSET_ENV_VARS=false \
        ARGPARSER_UNSET_FUNCTIONS=false \
        ARGPARSER_USAGE_EXIT_CODE=0 \
        ARGPARSER_USAGE_FILE="" \
        ARGPARSER_USAGE_FILE_INCLUDE_CHAR="@" \
        ARGPARSER_USAGE_FILE_KEEP_COMMENTS=false \
        ARGPARSER_USAGE_MESSAGE_OPTION_TYPE="long" \
        ARGPARSER_USAGE_MESSAGE_ORIENTATION="column" \
        ARGPARSER_USAGE_OPTIONS="u" \
        ARGPARSER_USE_LONG_OPTIONS=true \
        ARGPARSER_USE_SHORT_OPTIONS=false \
        ARGPARSER_USE_STYLES="tty" \
        ARGPARSER_VERSION_EXIT_CODE=0 \
        ARGPARSER_VERSION_NUMBER="${argparser_version}" \
        ARGPARSER_VERSION_OPTIONS="V" \
        ARGPARSER_WRITE_ARGS=false \
        argparser_parse_args "${args[@]}"

    # Set the environment variables that aren't set yet as global
    # variables.  For all environment variables that weren't given by
    # neither a config file, nor as an environment variable assignment,
    # nor as a command-line parameter to the Argparser, use the default
    # value the Argparser has assigned.  If the environment variable has
    # been given before, check if it was also given on the command line,
    # then override the previous value, else, keep the previous value.
    # By this, the command-line parameters have a higher importance than
    # environment variables.  For those environment variables whose
    # default is given as "''" (two single quotes), set the value to the
    # empty string.
    for arg_key in "${!ARGPARSER_ARGS[@]}"; do
        if [[ "${arg_key}" == "script_args" ]]; then
            # Skip ${script_args}, i.e., the command line.
            continue
        elif argparser_in_array "${arg_key}" "ARGPARSER_USE_STYLES_IN_FILES" \
            "ARGPARSER_HELP_STYLE" "ARGPARSER_USAGE_STYLE" \
            "ARGPARSER_VERSION_STYLE" "ARGPARSER_ERROR_STYLE" \
            "ARGPARSER_WARNING_STYLE"
        then
            # Skip the deprecated options that shall only come into
            # effect when explicitly given, not when using the default
            # values.
            continue
        elif [[ -v "${arg_key}" ]]; then
            # The environment variable has already been set.  Override
            # it if it was also given on the command line.
            for arg in "${args[@]}"; do
                # Set the variable name as shortest part before an
                # equals sign ("="), strip the leading hyphens, replace
                # inner hyphens by underscores, capitalize the variable
                # name, and prepend the string "ARGPARSER_".
                arg="${arg%%=*}"
                arg="${arg#--}"
                arg="${arg//-/_}"
                arg="ARGPARSER_${arg^^}"

                # If the command-line argument is the current
                # environment variable, override its value with the one
                # given on the command line, which was parsed by the
                # Argparser.
                if [[ "${arg}" == "${arg_key}" ]]; then
                    value="${ARGPARSER_ARGS[${arg_key}]}"
                    if [[ "${value}" == "''" ]]; then
                        value=""
                    fi
                    declare -g "${arg_key}"="${value}"
                    break
                fi
            done
        else
            # The environment variable is yet unset, so set it to the
            # value the Argparser has set upon parsing, i.e., either the
            # value from the command line, or, if absent, the default
            # value.
            value="${ARGPARSER_ARGS[${arg_key}]}"
            if [[ "${value}" == "''" ]]; then
                value=""
            fi
            declare -g "${arg_key}"="${value}"
        fi
    done
}

function argparser_set_env_var_defaults() {
    # Set the Argparser environment variables to their default values,
    # irrespective of being set on the command line, by the calling
    # script, in the environment, or at all.  This is mainly necessary
    # for coping with errors upon bootstrapping the Argparser before
    # having parsed the environment variables.  By setting the default
    # values upon errors, the error message printing functions can still
    # work as intended.
    #
    # Environment:
    # ARGPARSER_ADD_HELP
    # ARGPARSER_ADD_USAGE
    # ARGPARSER_ADD_VERSION
    # ARGPARSER_ALLOW_ARG_INTERMIXING
    # ARGPARSER_ALLOW_FLAG_INVERSION
    # ARGPARSER_ALLOW_FLAG_NEGATION
    # ARGPARSER_ALLOW_OPTION_ABBREVIATION
    # ARGPARSER_ALLOW_OPTION_MERGING
    # ARGPARSER_ARG_ARRAY_NAME
    # ARGPARSER_ARG_DEF_FILE
    # ARGPARSER_ARG_DELIMITER_1
    # ARGPARSER_ARG_DELIMITER_2
    # ARGPARSER_CHECK_ARG_DEF
    # ARGPARSER_CHECK_ENV_VARS
    # ARGPARSER_CONFIG_FILE
    # ARGPARSER_COUNT_FLAGS
    # ARGPARSER_CREATE_ARG_DEF
    # ARGPARSER_ERROR_EXIT_CODE
    # ARGPARSER_HELP_ARG_GROUP
    # ARGPARSER_HELP_DESCRIPTION
    # ARGPARSER_HELP_EXIT_CODE
    # ARGPARSER_HELP_FILE
    # ARGPARSER_HELP_FILE_INCLUDE_CHAR
    # ARGPARSER_HELP_FILE_KEEP_COMMENTS
    # ARGPARSER_HELP_OPTIONS
    # ARGPARSER_LANGUAGE
    # ARGPARSER_MAX_COL_WIDTH_1
    # ARGPARSER_MAX_COL_WIDTH_2
    # ARGPARSER_MAX_COL_WIDTH_3
    # ARGPARSER_MAX_WIDTH
    # ARGPARSER_POSITIONAL_ARG_GROUP
    # ARGPARSER_READ_ARGS
    # ARGPARSER_SCRIPT_NAME
    # ARGPARSER_SET_ARGS
    # ARGPARSER_SET_ARRAYS
    # ARGPARSER_SILENCE_ERRORS
    # ARGPARSER_SILENCE_WARNINGS
    # ARGPARSER_STYLE_FILE
    # ARGPARSER_TRANSLATION_FILE
    # ARGPARSER_UNSET_ARGS
    # ARGPARSER_UNSET_ENV_VARS
    # ARGPARSER_UNSET_FUNCTIONS
    # ARGPARSER_USAGE_EXIT_CODE
    # ARGPARSER_USAGE_FILE
    # ARGPARSER_USAGE_FILE_INCLUDE_CHAR
    # ARGPARSER_USAGE_FILE_KEEP_COMMENTS
    # ARGPARSER_USAGE_MESSAGE_OPTION_TYPE
    # ARGPARSER_USAGE_MESSAGE_ORIENTATION
    # ARGPARSER_USAGE_OPTIONS
    # ARGPARSER_USE_LONG_OPTIONS
    # ARGPARSER_USE_SHORT_OPTIONS
    # ARGPARSER_USE_STYLES
    # ARGPARSER_VERSION_EXIT_CODE
    # ARGPARSER_VERSION_NUMBER
    # ARGPARSER_VERSION_OPTIONS
    # ARGPARSER_WRITE_ARGS

    ARGPARSER_ADD_HELP=true
    ARGPARSER_ADD_USAGE=true
    ARGPARSER_ADD_VERSION=true
    ARGPARSER_ALLOW_ARG_INTERMIXING=false
    ARGPARSER_ALLOW_FLAG_INVERSION=true
    ARGPARSER_ALLOW_FLAG_NEGATION=true
    ARGPARSER_ALLOW_OPTION_ABBREVIATION=false
    ARGPARSER_ALLOW_OPTION_MERGING=false
    ARGPARSER_ARG_ARRAY_NAME="ARGPARSER_ARGS"
    ARGPARSER_ARG_DEF_FILE=""
    ARGPARSER_ARG_DELIMITER_1=":"
    ARGPARSER_ARG_DELIMITER_2=","
    ARGPARSER_CHECK_ARG_DEF=false
    ARGPARSER_CHECK_ENV_VARS=false
    ARGPARSER_CONFIG_FILE=""
    ARGPARSER_COUNT_FLAGS=false
    ARGPARSER_CREATE_ARG_DEF=false
    ARGPARSER_ERROR_EXIT_CODE=1
    ARGPARSER_HELP_ARG_GROUP="Help options"
    ARGPARSER_HELP_DESCRIPTION=""
    ARGPARSER_HELP_EXIT_CODE=0
    ARGPARSER_HELP_FILE=""
    ARGPARSER_HELP_FILE_INCLUDE_CHAR="@"
    ARGPARSER_HELP_FILE_KEEP_COMMENTS=false
    ARGPARSER_HELP_OPTIONS="h,?"
    ARGPARSER_LANGUAGE="en"
    ARGPARSER_MAX_COL_WIDTH_1=5
    ARGPARSER_MAX_COL_WIDTH_2=33
    ARGPARSER_MAX_COL_WIDTH_3=0
    ARGPARSER_MAX_WIDTH=79
    ARGPARSER_POSITIONAL_ARG_GROUP="Positional arguments"
    ARGPARSER_READ_ARGS=true
    ARGPARSER_SCRIPT_NAME="${BASH_SOURCE[0]##*/}"
    ARGPARSER_SET_ARGS=false
    ARGPARSER_SET_ARRAYS=false
    ARGPARSER_SILENCE_ERRORS=false
    ARGPARSER_SILENCE_WARNINGS=false
    ARGPARSER_STYLE_FILE=""
    ARGPARSER_TRANSLATION_FILE=""
    ARGPARSER_UNSET_ARGS=true
    ARGPARSER_UNSET_ENV_VARS=false
    ARGPARSER_UNSET_FUNCTIONS=false
    ARGPARSER_USAGE_EXIT_CODE=0
    ARGPARSER_USAGE_FILE=""
    ARGPARSER_USAGE_FILE_INCLUDE_CHAR="@"
    ARGPARSER_USAGE_FILE_KEEP_COMMENTS=false
    ARGPARSER_USAGE_MESSAGE_OPTION_TYPE="long"
    ARGPARSER_USAGE_MESSAGE_ORIENTATION="column"
    ARGPARSER_USAGE_OPTIONS="u"
    ARGPARSER_USE_LONG_OPTIONS=true
    ARGPARSER_USE_SHORT_OPTIONS=false
    ARGPARSER_USE_STYLES="tty"
    ARGPARSER_VERSION_EXIT_CODE=0
    ARGPARSER_VERSION_NUMBER="${argparser_version}"
    ARGPARSER_VERSION_OPTIONS="V"
    ARGPARSER_WRITE_ARGS=false
}

function argparser_modify_env_vars() {
    # Modify the Argparser environment variables with special values,
    # irrespective of being set on the command line, by the calling
    # script, or in the environment.
    #
    # Environment:
    # ARGPARSER_SCRIPT_NAME
    # ARGPARSER_USE_STYLES
    # ARGPARSER_USE_STYLES_IN_FILES (read-only)

    # For the deprecated ${ARGPARSER_USE_STYLES_IN_FILES}, set
    # ${ARGPARSER_USE_STYLES} to "always" or "tty".  Should the
    # (unchecked) ${ARGPARSER_USE_STYLES_IN_FILES} be neither "true" nor
    # "false", still assign the default value of "tty" without reporting
    # an error.
    if [[ -v ARGPARSER_USE_STYLES_IN_FILES ]]; then
        if [[ "${ARGPARSER_USE_STYLES_IN_FILES}" == true ]]; then
            ARGPARSER_USE_STYLES="always"
        else
            ARGPARSER_USE_STYLES="tty"
        fi
    fi

    # For ${ARGPARSER_SCRIPT_NAME}, set the value to the
    # basename of the script's $0, if an empty string is given.
    if [[ -z "${ARGPARSER_SCRIPT_NAME}" ]]; then
        ARGPARSER_SCRIPT_NAME="${0##*/}"
    fi
}

function argparser_check_env_vars() {
    # Check if the Argparser environment variables accord to their
    # definition.  This should always be true for production scripts,
    # but maybe not while testing, and also not if the user is allowed
    # to set the variables himself.
    #
    # The following environment variables are unchecked:
    # - ARGPARSER_ARGS (auto-set)
    # - ARGPARSER_HELP_ARG_GROUP (arbitrary value)
    # - ARGPARSER_HELP_DESCRIPTION (arbitrary value)
    # - ARGPARSER_LANGUAGE (arbitrary value)
    # - ARGPARSER_POSITIONAL_ARG_GROUP (arbitrary value)
    # - ARGPARSER_SCRIPT_NAME (arbitrary value)
    # - ARGPARSER_VERSION_NUMBER (arbitrary value)
    #
    # The following environment variables are only checked for mutual
    # exclusivity with other environment variables:
    # - ARGPARSER_CONFIG_FILE (checked earlier)
    # - ARGPARSER_TRANSLATION_FILE (checked earlier)
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_ALLOW_ARG_INTERMIXING (read-only)
    # - ARGPARSER_ALLOW_FLAG_INVERSION (read-only)
    # - ARGPARSER_ALLOW_FLAG_NEGATION (read-only)
    # - ARGPARSER_ALLOW_OPTION_ABBREVIATION (read-only)
    # - ARGPARSER_ALLOW_OPTION_MERGING (read-only)
    # - ARGPARSER_ARG_ARRAY_NAME (read-only)
    # - ARGPARSER_ARG_DEF_FILE (read-only)
    # - ARGPARSER_ARG_DELIMITER_1 (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_CHECK_ARG_DEF (read-only)
    # - ARGPARSER_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_COUNT_FLAGS (read-only)
    # - ARGPARSER_CREATE_ARG_DEF (read-only)
    # - ARGPARSER_DEBUG (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE
    # - ARGPARSER_ERROR_STYLE
    # - ARGPARSER_HELP_EXIT_CODE (read-only)
    # - ARGPARSER_HELP_FILE (read-only)
    # - ARGPARSER_HELP_FILE_INCLUDE_CHAR (read-only)
    # - ARGPARSER_HELP_FILE_KEEP_COMMENTS (read-only)
    # - ARGPARSER_HELP_OPTIONS (read-only)
    # - ARGPARSER_HELP_STYLE (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_1 (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_2 (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_3 (read-only)
    # - ARGPARSER_MAX_WIDTH (read-only)
    # - ARGPARSER_READ_ARGS (read-only)
    # - ARGPARSER_SET_ARGS (read-only)
    # - ARGPARSER_SET_ARRAYS (read-only)
    # - ARGPARSER_SILENCE_ERRORS (read-only)
    # - ARGPARSER_SILENCE_WARNINGS (read-only)
    # - ARGPARSER_UNSET_ARGS (read-only)
    # - ARGPARSER_UNSET_ENV_VARS (read-only)
    # - ARGPARSER_UNSET_FUNCTIONS (read-only)
    # - ARGPARSER_USAGE_EXIT_CODE (read-only)
    # - ARGPARSER_USAGE_FILE (read-only)
    # - ARGPARSER_USAGE_FILE_INCLUDE_CHAR (read-only)
    # - ARGPARSER_USAGE_FILE_KEEP_COMMENTS (read-only)
    # - ARGPARSER_USAGE_MESSAGE_OPTION_TYPE (read-only)
    # - ARGPARSER_USAGE_MESSAGE_ORIENTATION (read-only)
    # - ARGPARSER_USAGE_OPTIONS (read-only)
    # - ARGPARSER_USAGE_STYLE (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_USE_STYLES (read-only)
    # - ARGPARSER_VERSION_EXIT_CODE (read-only)
    # - ARGPARSER_VERSION_OPTIONS (read-only)
    # - ARGPARSER_VERSION_STYLE (read-only)
    # - ARGPARSER_WARNING_STYLE (read-only)
    # - ARGPARSER_WRITE_ARGS (read-only)

    # Define the local variables.
    local -A checked_short_options
    local -a colors_arr
    local colors_str
    local count
    local error_message
    local -a error_messages
    local file_attributes
    local i
    local short_option
    local -a short_options
    local -a text_styles_arr
    local text_styles_str
    local translation
    local value
    local -a values
    local var
    local var_1
    local var_2
    local -a vars

    # Check if all environment variables expected to be Booleans are
    # "true" or "false".  Else, output an error message.
    error_messages=( )
    vars=(
        ARGPARSER_ADD_HELP
        ARGPARSER_ADD_USAGE
        ARGPARSER_ADD_VERSION
        ARGPARSER_ALLOW_ARG_INTERMIXING
        ARGPARSER_ALLOW_FLAG_INVERSION
        ARGPARSER_ALLOW_FLAG_NEGATION
        ARGPARSER_ALLOW_OPTION_ABBREVIATION
        ARGPARSER_ALLOW_OPTION_MERGING
        ARGPARSER_CHECK_ARG_DEF
        ARGPARSER_CHECK_ENV_VARS
        ARGPARSER_COUNT_FLAGS
        ARGPARSER_CREATE_ARG_DEF
        ARGPARSER_DEBUG
        ARGPARSER_HELP_FILE_KEEP_COMMENTS
        ARGPARSER_READ_ARGS
        ARGPARSER_SET_ARGS
        ARGPARSER_SET_ARRAYS
        ARGPARSER_SILENCE_ERRORS
        ARGPARSER_SILENCE_WARNINGS
        ARGPARSER_UNSET_ARGS
        ARGPARSER_UNSET_ENV_VARS
        ARGPARSER_UNSET_FUNCTIONS
        ARGPARSER_USAGE_FILE_KEEP_COMMENTS
        ARGPARSER_USE_LONG_OPTIONS
        ARGPARSER_USE_SHORT_OPTIONS
        ARGPARSER_WRITE_ARGS
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values <<< "${!var}"
        for value in "${values[@]}"; do
            if ! argparser_is_bool "${value}"; then
                error_message="Error: The environment variable \"\$1\" is set "
                error_message+="to \"\$2\", but must be a Boolean, i.e., "
                error_message+="\"true\" or \"false\"."

                argparser_translate "Error env var bool" "${error_message}" \
                    "${var}" "${!var}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # Check if all environment variables expected to be characters are
    # one-character strings.  Else, output an error message.
    vars=(
        ARGPARSER_ARG_DELIMITER_1
        ARGPARSER_ARG_DELIMITER_2
        ARGPARSER_HELP_FILE_INCLUDE_CHAR
        ARGPARSER_HELP_OPTIONS
        ARGPARSER_USAGE_FILE_INCLUDE_CHAR
        ARGPARSER_USAGE_OPTIONS
        ARGPARSER_VERSION_OPTIONS
    )
    for var in "${vars[@]}"; do
        if [[ "${var}" == "ARGPARSER_ARG_DELIMITER_2" ]]; then
            values=("${!var}")
        else
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values <<< "${!var}"
        fi

        for value in "${values[@]}"; do
            if ! argparser_is_char "${value}"; then
                error_message="Error: The environment variable \"\$1\" is set "
                error_message+="to \"\$2\", but must be a character, i.e., a "
                error_message+="string comprising one printable ASCII "
                error_message+="character."

                argparser_translate "Error env var char" "${error_message}" \
                    "${var}" "${!var}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # Check if all environment variables to be used as Bash variable
    # identifiers start with a letter or underscore and contain only
    # letters, digits, and underscores.  Else, output an error message.
    vars=(
        ARGPARSER_ARG_ARRAY_NAME
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values <<< "${!var}"
        for value in "${values[@]}"; do
            if ! argparser_is_identifier "${value}"; then
                error_message="Error: The environment variable \"\$1\" is set "
                error_message+="to \"\$2\", but designed to be used as Bash "
                error_message+="variable identifier, i.e., its value must "
                error_message+="start with a letter or underscore and contain "
                error_message+="only letters, digits, and underscores."

                argparser_translate "Error env var identifier" \
                    "${error_message}" "${var}" "${!var}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # Check if all environment variables expected to be integers are
    # only digits, possibly with a leading sign.  Else, output an error
    # message.
    vars=(
        ARGPARSER_ERROR_EXIT_CODE
        ARGPARSER_HELP_EXIT_CODE
        ARGPARSER_USAGE_EXIT_CODE
        ARGPARSER_VERSION_EXIT_CODE
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values <<< "${!var}"
        for value in "${values[@]}"; do
            if ! argparser_is_int "${value}"; then
                error_message="Error: The environment variable \"\$1\" is set "
                error_message+="to \"\$2\", but must be an integer, i.e., "
                error_message+="comprise only digits and possibly a leading "
                error_message+="sign."

                argparser_translate "Error env var int" "${error_message}" \
                    "${var}" "${!var}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # Check if all environment variables expected to be unsigned
    # integers are only digits.  Else, output an error message.
    vars=(
        ARGPARSER_MAX_COL_WIDTH_1
        ARGPARSER_MAX_COL_WIDTH_2
        ARGPARSER_MAX_COL_WIDTH_3
        ARGPARSER_MAX_WIDTH
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values <<< "${!var}"
        for value in "${values[@]}"; do
            if ! argparser_is_uint "${value}"; then
                error_message="Error: The environment variable \"\$1\" is set "
                error_message+="to \"\$2\", but must be an unsigned integer, "
                error_message+="i.e., comprise only digits and no sign."

                argparser_translate "Error env var uint" "${error_message}" \
                    "${var}" "${!var}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # Check if all environment variables expected to point to files have
    # the referenced file existing, readable, and with a size greater
    # than 0 bytes.  Else, output an error message.
    vars=(
        ARGPARSER_ARG_DEF_FILE
        ARGPARSER_HELP_FILE
        ARGPARSER_STYLE_FILE
        ARGPARSER_USAGE_FILE
    )
    for var in "${vars[@]}"; do
        argparser_check_file "${!var}"
        if [[ -n "${!var}" && "${file_attributes}" != "0000" ]]; then
            error_message="Error: The environment variable \"\$1\" is set to "
            error_message+="\"\$2\", but the referenced file "
            case "${file_attributes}" in
                0001) error_message+="is empty." ;;
                0010) error_message+="is not readable." ;;
                0011) error_message+="is not readable and empty." ;;
                0100) error_message+="is not a regular file." ;;
                0101) error_message+="is not a regular file and empty." ;;
                0110)
                    error_message+="is not a regular file and not readable."
                    ;;
                0111)
                    error_message+="is not a regular file, not readable, and "
                    error_message+="empty."
                    ;;
                1111) error_message+="does not exist." ;;
            esac

            argparser_translate "Error env var file ${file_attributes}" \
                "${error_message}" "${var}" "${!var}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi
    done

    # Check if all environment variables with a limited set of allowed
    # values have their values lying in them.  Else, output an error
    # message.
    # First, check that the argument definition delimiters don't use the
    # reserved characters.
    vars=(
        ARGPARSER_ARG_DELIMITER_1
        ARGPARSER_ARG_DELIMITER_2
    )
    for var in "${vars[@]}"; do
        if argparser_in_array "${!var}" "-" "+" "*" "?"; then
            error_message="Error: The environment variable \"\$1\" is set to "
            error_message+="\"\$2\", but hyphens, plus signs, asterisks, and "
            error_message+="question marks are reserved characters."

            argparser_translate "Error env var delimiters reserved" \
                "${error_message}" "${var}" "${!var}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi
    done

    # Then, check if all (existing, i.e., given though deprecated)
    # environment variables for styles only have values supported by
    # argparser_colorize.
    vars=(
        ARGPARSER_ERROR_STYLE
        ARGPARSER_HELP_STYLE
        ARGPARSER_USAGE_STYLE
        ARGPARSER_VERSION_STYLE
        ARGPARSER_WARNING_STYLE
    )
    for var in "${vars[@]}"; do
        if [[ -v "${var}" ]] \
            && ! argparser_check_styles "colors, text styles" "${!var}"
        then
            colors_arr=(
                "black"
                "red"
                "green"
                "yellow"
                "blue"
                "magenta"
                "cyan"
                "white"
            )
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colors_arr[@]}"
            colors_str="${joined_array}"

            text_styles_arr=(
                "normal"
                "bold"
                "faint"
                "italic"
                "underline"
                "double"
                "overline"
                "crossed-out"
                "blink"
                "reverse"
            )
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${text_styles_arr[@]}"
            text_styles_str="${joined_array}"

            error_message="Error: The environment variable \"\$1\" is set to "
            error_message+="\"\$2\", but the values must lie in {\$3} for "
            error_message+="colors and in {\$4} for styles.  Colors, only, "
            error_message+="may be prefixed by \"bright_\" or suffixed by "
            error_message+="\"_fg\" or \"_bg\"."

            argparser_translate "Error env var styles" "${error_message}" \
                "${var}" "${!var}" "${colors_str}" "${text_styles_str}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi
    done

    # Then, check the style usage occasions.
    if ! argparser_in_array "${ARGPARSER_USE_STYLES}" "always" "never" "file" \
        "tty"
    then
        styles_arr=(
            "always"
            "never"
            "file"
            "tty"
        )
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
            "${styles_arr[@]}"
        styles_str="${joined_array}"

        error_message="Error: The environment variable "
        error_message+="\"ARGPARSER_USE_STYLES\" must be in {\$1}, but is "
        error_message+="\"\$2\"."

        argparser_translate "Error env var style usage" "${error_message}" \
            "${styles_str}" "${ARGPARSER_USE_STYLES}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    # Then, check the option type for usage messages.
    if [[ "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" != "long" \
        && "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" != "short" ]]
    then
        error_message="Error: The environment variable "
        error_message+="\"ARGPARSER_USAGE_MESSAGE_OPTION_TYPE\" must be "
        error_message+="either set to \"long\" or \"short\", but is \"\$1\"."

        argparser_translate "Error env var option type" "${error_message}" \
            "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    # Then, check the orientation for usage messages.
    if [[ "${ARGPARSER_USAGE_MESSAGE_ORIENTATION}" != "row" \
        && "${ARGPARSER_USAGE_MESSAGE_ORIENTATION}" != "column" ]]
    then
        error_message="Error: The environment variable "
        error_message+="\"ARGPARSER_USAGE_MESSAGE_ORIENTATION\" must be "
        error_message+="either set to \"row\" or \"column\", but is \"\$1\"."

        argparser_translate "Error env var orientation" "${error_message}" \
            "${ARGPARSER_USAGE_MESSAGE_ORIENTATION}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    # Check the environment variables with mutually exclusive values.
    # First, check that the argument definition delimiters are
    # different.
    # shellcheck disable=SC2153  # No misspelling for variable names.
    if [[ "${ARGPARSER_ARG_DELIMITER_1}" == "${ARGPARSER_ARG_DELIMITER_2}" ]]
    then
        error_message="Error: The environment variables "
        error_message+="\"ARGPARSER_ARG_DELIMITER_1\" and "
        error_message+="\"ARGPARSER_ARG_DELIMITER_2\" must have different "
        error_message+="values, but are both \"\$1\"."

        argparser_translate "Error env var delimiters identical" \
            "${error_message}" "${ARGPARSER_ARG_DELIMITER_1}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    # Then, check the short option names for help, usage, and version
    # messages.
    vars=(
        ARGPARSER_HELP_OPTIONS
        ARGPARSER_USAGE_OPTIONS
        ARGPARSER_VERSION_OPTIONS
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
            <<< "${!var}"

        # If more than one short option name is given, check if any is
        # the empty string, which must only once be used as placeholder
        # for missing short options.  Then, check if any short option
        # name is longer than one character, and if it is given multiple
        # times in the current environment variable's value or across
        # all yet investigated environment variables' values.  If only
        # one short option name is given, the empty string is a legit
        # value, so don't check this.
        if (( "${#short_options[@]}" > 1 )) \
            && argparser_in_array "" "${short_options[@]}"
        then
            # Check if the empty string is included in the short option
            # names.
            error_message="Error: The environment variable \"\$1\" has an "
            error_message+="empty string given as one of the \$2 short option "
            error_message+="names, instead of a legit name."

            argparser_translate "Error env var short name empty" \
                "${error_message}" "${var}" "${#short_options[@]}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        for short_option in "${short_options[@]}"; do
            if [[ -z "${short_option}" ]]; then
                continue
            fi

            # Check if a short option name is more than one character
            # long.
            if (( "${#short_option}" > 1 )); then
                error_message="Error: The environment variable \"\$1\" has "
                error_message+="the short option \"-\$2\" defined with more "
                error_message+="than 1 character length."

                argparser_translate "Error env var short name length" \
                    "${error_message}" "${var}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi

            # Check if the short option name is given multiple times
            # in the current environment variable's value.
            argparser_count "${short_option}" "${short_options[@]}"
            if (( count > 1 )); then
                error_message="Error: The environment variable \"\$1\" has "
                error_message+="the short option \"-\$2\" given \$3 times."

                argparser_translate "Error env var short name duplication 1" \
                    "${error_message}" "${var}" "${short_option}" "${count}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi

            # Check if the short option name is already given in
            # another environment variable's value.
            if [[ -n "${checked_short_options[${short_option}]+set}" \
                && "${checked_short_options[${short_option}]}" != "${var}" ]]
            then
                error_message="Error: The environment variable \"\$1\" has "
                error_message+="the short option \"-\$2\" given, but that is "
                error_message+="already in use by \"\$3\"."

                argparser_translate "Error env var short name duplication 2" \
                    "${error_message}" "${var}" "${short_option}" \
                    "${checked_short_options[${short_option}]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi

            # Add the short option name to the associative array of
            # all short option names.
            checked_short_options[${short_option}]="${var}"
        done
    done

    # Then, check that the preference for short/long options doesn't
    # collide with them being ignored.
    if [[ "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "short" \
        && "${ARGPARSER_USE_SHORT_OPTIONS}" == false ]]
    then
        error_message="Error: The environment variable "
        error_message+="\"ARGPARSER_USAGE_MESSAGE_OPTION_TYPE\" requests the "
        error_message+="usage of short option names, but "
        error_message+="\"ARGPARSER_USE_SHORT_OPTIONS\" turns them off."

        argparser_translate "Error env var short options" "${error_message}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    if [[ "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "long" \
        && "${ARGPARSER_USE_LONG_OPTIONS}" == false ]]
    then
        error_message="Error: The environment variable "
        error_message+="\"ARGPARSER_USAGE_MESSAGE_OPTION_TYPE\" requests the "
        error_message+="usage of long option names, but "
        error_message+="\"ARGPARSER_USE_LONG_OPTIONS\" turns them off."

        argparser_translate "Error env var long options" "${error_message}"
        error_message="${translation}"
        error_messages+=("${error_message}")
    fi

    # Then, check that the arguments definition file, the configuration
    # file, the help file, the style file, the translation file, and the
    # usage file are different from each other, if given.
    vars=(
        ARGPARSER_ARG_DEF_FILE
        ARGPARSER_CONFIG_FILE
        ARGPARSER_HELP_FILE
        ARGPARSER_STYLE_FILE
        ARGPARSER_TRANSLATION_FILE
        ARGPARSER_USAGE_FILE
    )
    for i in "${!vars[@]}"; do
        var_1="${vars[i]}"
        for var_2 in "${vars[@]:i+1}"; do
            if [[ -n "${!var_1}" && "${!var_1}" == "${!var_2}" ]]; then
                error_message="Error: The environment variables \"\$1\" and "
                error_message+="\"\$2\" point to the same file."

                argparser_translate "Error env var files" "${error_message}" \
                    "${var_1}" "${var_2}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done

    # If there are error messages, sort, filter, colorize, and print
    # them, then exit, as parsing the arguments with a faulty
    # environment variable configuration might be impossible.
    if (( "${#error_messages[@]}" > 0 )) \
        && [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]
    then
        argparser_set_env_var_defaults
    fi

    argparser_print_error_messages true true "${error_messages[@]}"
}

# Define the Argparser functions for reading the translation and
# translating strings.
function argparser_read_translation() {
    # Read the translation of the auto-generated text for help and usage
    # messages from the YAML file into an associative array.
    #
    # Nonlocals:
    # - dictionary: the associative array containing the translations
    #
    # Environment:
    # - ARGPARSER_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_LANGUAGE (read-only)
    # - ARGPARSER_TRANSLATION_FILE (read-only)

    # Define the local variables.
    local -a error_lines
    local error_message
    local -a error_messages
    local file_attributes
    local group
    local is_continued
    local language
    local line
    local -a lines
    local translation

    # Check if the translation file exists and is readable.  Else,
    # output an error message and exit.  Since at this point of
    # invokation, the environment variables aren't checked, yet, set the
    # needed ones to default values, if ${ARGPARSER_CHECK_ENV_VARS}
    # isn't set to "false" (and by this, the checking hasn't been
    # explicitly disabled).
    argparser_check_file "${ARGPARSER_TRANSLATION_FILE}"
    if [[ "${file_attributes}" != "0000" ]]; then
        error_message="Error: The environment variable \"\$1\" is set to "
        error_message+="\"\$2\", but the referenced file "
        case "${file_attributes}" in
            0001) error_message+="is empty." ;;
            0010) error_message+="is not readable." ;;
            0011) error_message+="is not readable and empty." ;;
            0100) error_message+="is not a regular file." ;;
            0101) error_message+="is not a regular file and empty." ;;
            0110) error_message+="is not a regular file and not readable." ;;
            0111)
                error_message+="is not a regular file, not readable, and "
                error_message+="empty."
                ;;
            1111) error_message+="does not exist." ;;
        esac

        error_message="${error_message/"\$1"/"ARGPARSER_TRANSLATION_FILE"}"
        error_message="${error_message/"\$2"/${ARGPARSER_TRANSLATION_FILE}}"

        if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
            argparser_set_env_var_defaults
        fi

        argparser_print_error_messages false true "${error_message}"
    fi

    # Read the translation file.  Use "?" as sentinel to denote the
    # absence of a translation, to be overridden by the actual
    # translation, once read.
    mapfile -t lines < "${ARGPARSER_TRANSLATION_FILE}"
    group=""
    language=""
    translation="?"
    is_continued=false
    error_lines=( )
    error_messages=( )

    for line in "${lines[@]}"; do
        if [[ -z "${line}" || "${line}" == \#* ]]; then
            # The line is empty or commented.
            continue
        elif [[ "${line}" == "---" || "${line}" == "..." ]]; then
            # The line denotes the start or end of a YAML block.
            continue
        elif [[ "${line}" == "  ${ARGPARSER_LANGUAGE}: >" ]]; then
            # The line starts the translation to the desired language.
            language="${ARGPARSER_LANGUAGE}"
            translation="?"
            is_continued=true
        elif [[ "${line}" == "  ${ARGPARSER_LANGUAGE}:" ]]; then
            # The line contains the translation to the desired language
            # for an empty translation.
            language="${ARGPARSER_LANGUAGE}"
            translation=""
        elif [[ "${line}" == "  ${ARGPARSER_LANGUAGE}: "* ]]; then
            # The line contains the translation to the desired language.
            language="${ARGPARSER_LANGUAGE}"
            translation="${line#*: }"
        elif [[ "${line}" == "  "*": >" ]]; then
            # The line start the translation to another language, which
            # can be ignored, along all following lines until the start
            # of a new YAML key.
            language="${line#* }"
            language="${language%:*}"
            is_continued=true
        elif [[ "${line}" == "  "*([^ ])":" || "${line}" == "  "*([^ ])": "* ]]
        then
            # The line contains the translation to another language,
            # which can be ignored.
            language="${line#* }"
            language="${language%:*}"
        elif [[ "${line}" == "    "* \
            && "${language}" == "${ARGPARSER_LANGUAGE}" \
            && "${is_continued}" == true ]]
        then
            # The line continues the translation from the previous line.
            if [[ "${translation}" == "?" ]]; then
                translation="${line#    }"
            else
                translation+=" ${line#    }"
            fi
        elif [[ "${line}" == "    "* && "${is_continued}" == true ]]; then
            # The line continues the translation to another language,
            # from the previous line, which can be ignored.
            continue
        elif [[ "${line}" == *: && "${line::1}" != " " ]]; then
            # The line starts a new group of translations.  Save the
            # previous translation under the previous group name, then
            # extract the new one.
            if [[ -n "${group}" ]]; then
                dictionary[${group}]="${translation}"
            fi
            group="${line%:}"
            translation="?"
            is_continued=false
        else
            # The line uses a YAML feature not supported by the
            # Argparser, thus, output an error message.  The message
            # must not yet be translated, as the translation requires
            # translation identifiers that may not have been read, yet.
            # This would lead to a warning message complaining that the
            # identifier would be missing, despite being present.  For
            # the necessary interpolation, below, save the current line.
            error_message="Error: The YAML line \"\$1\" could not be "
            error_message+="recognized."
            error_messages+=("${error_message}")
            error_lines+=("${line}")
        fi
    done

    # Add the last group to the dictionary.
    if [[ -n "${group}" ]]; then
        dictionary[${group}]="${translation}"
    fi

    # If there are error messages, sort, filter, colorize, translate,
    # and print them.
    if (( "${#error_messages[@]}" > 0 )) \
        && [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]
    then
        argparser_set_env_var_defaults
    fi

    for i in "${!error_messages[@]}"; do
        error_message="${error_messages[i]}"
        line="${error_lines[i]}"
        argparser_translate "Error YAML" "${error_message}" "${line}"
        error_message="${translation}"
        error_messages[i]="${error_message}"
    done

    argparser_print_error_messages true false "${error_messages[@]}"
}

function argparser_translate() {
    # Translate the given string.
    #
    # Arguments:
    # - $1: the key (identifier) of the string in the dictionary
    # - $2: the string to use as fallback if no translation file is
    #       given or the key does not exist
    # - $@: the variable names to use for interpolation of "$n" format
    #       specifiers in the string
    #
    # Nonlocals:
    # - dictionary: the associative array containing the translations
    # - translation: the translated string
    #
    # Environment:
    # - ARGPARSER_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_TRANSLATION_FILE (read-only)

    # Define the local variables.
    local i
    local key
    local string
    local -a vars
    local warning_message

    # Read the arguments.
    key="$1"
    string="$2"
    shift 2
    vars=("$@")

    # If an ${ARGPARSER_TRANSLATION_FILE} was given (and thus the
    # translation was requested), translate the string by fetching its
    # translation from the associative array ${dictionary}.  Else,
    # output the untranslated string.  If the key or string does not
    # exist in ${dictionary}, output a warning message and the
    # untranslated string.  Translate the warning message only if the
    # key is not the one required for translation, else, an infinite
    # loop would arise by trying to fetch the inexistent translation
    # over and over.
    if [[ -n "${ARGPARSER_TRANSLATION_FILE}" ]]; then
        if [[ -z "${dictionary[${key}]+set}" ]]; then
            warning_message="Warning: In the translation file \"\$1\", the "
            warning_message+="identifier \"\$2\" is missing.  For "
            warning_message+="convenience, the untranslated string is used, "
            warning_message+="instead."

            if [[ "${key}" == "Warning" ]]; then
                translation="${key}"
                return
            elif [[ "${key}" == "Warning no identifier" ]]; then
                warning_message="${warning_message/"\$1"/${ARGPARSER_TRANSLATION_FILE}}"
                warning_message="${warning_message/"\$2"/${key}}"
            else
                argparser_translate "Warning no identifier" \
                    "${warning_message}" "${ARGPARSER_TRANSLATION_FILE}" \
                        "${key}"
                warning_message="${translation}"
            fi

            if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
                argparser_set_env_var_defaults
            fi

            argparser_print_warning_messages false "${warning_message}"
        elif [[ "${dictionary[${key}]}" == "?" ]]; then
            warning_message="Warning: In the translation file \"\$1\", the "
            warning_message+="translation to \"\$2\" for the identifier "
            warning_message+="\"\$3\" is missing.  For convenience, the "
            warning_message+="untranslated string is used, instead."

            if [[ "${key}" == "Warning" ]]; then
                translation="${key}"
                return
            elif [[ "${key}" == "Warning no translation" ]]; then
                warning_message="${warning_message/"\$1"/${ARGPARSER_TRANSLATION_FILE}}"
                warning_message="${warning_message/"\$2"/${ARGPARSER_LANGUAGE}}"
                warning_message="${warning_message/"\$3"/${key}}"
            else
                argparser_translate "Warning no translation" \
                    "${warning_message}" "${ARGPARSER_TRANSLATION_FILE}" \
                    "${ARGPARSER_LANGUAGE}" "${key}"
                warning_message="${translation}"
            fi

            if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
                argparser_set_env_var_defaults
            fi

            argparser_print_warning_messages false "${warning_message}"
        else
            string="${dictionary[${key}]}"
        fi
    fi

    # Replace the format specifiers in the string and assign
    # ${translation} to it.
    for i in "${!vars[@]}"; do
        string="${string/"\$$(( i + 1 ))"/"${vars[i]}"}"
    done
    translation="${string}"
}

# Define the Argparser function for reading the styles.
function argparser_read_styles() {
    # Read the styles for the messages from the configuration file into
    # an associative array.
    #
    # Nonlocals:
    # - styles: the associative array containing the styles
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_STYLE_FILE (read-only)

    # Define the local variables.
    local -a colors_arr
    local colors_str
    local error_message
    local -a error_messages
    local file_attributes
    local -a frame_styles_arr
    local frame_styles_str
    local line
    local -a lines
    local name
    local style
    local -a text_styles_arr
    local text_styles_str
    local translation
    local trimmed_string
    local warning_message
    local -a warning_messages

    # Check if the style file exists and is readable.  Else, output an
    # error message and exit.  Since at this point of invokation, the
    # environment variables aren't checked, yet, set the needed ones to
    # default values, if ${ARGPARSER_CHECK_ENV_VARS} isn't set to
    # "false" (and by this, the checking hasn't been explicitly
    # disabled).
    argparser_check_file "${ARGPARSER_STYLE_FILE}"
    if [[ "${file_attributes}" != "0000" ]]; then
        error_message="Error: The environment variable \"\$1\" is set to "
        error_message+="\"\$2\", but the referenced file "
        case "${file_attributes}" in
            0001) error_message+="is empty." ;;
            0010) error_message+="is not readable." ;;
            0011) error_message+="is not readable and empty." ;;
            0100) error_message+="is not a regular file." ;;
            0101) error_message+="is not a regular file and empty." ;;
            0110) error_message+="is not a regular file and not readable." ;;
            0111)
                error_message+="is not a regular file, not readable, and "
                error_message+="empty."
                ;;
            1111) error_message+="does not exist." ;;
        esac

        argparser_translate "Error env var file ${file_attributes}" \
            "${error_message}" "ARGPARSER_STYLE_FILE" "${ARGPARSER_STYLE_FILE}"
        error_message="${translation}"

        if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
            argparser_set_env_var_defaults
        fi

        argparser_print_error_messages false true "${error_message}"
    fi

    # Read the style file.
    mapfile -t lines < "${ARGPARSER_STYLE_FILE}"
    error_messages=( )

    for line in "${lines[@]}"; do
        if [[ -z "${line}" || "${line}" == \#* ]]; then
            # Ignore the empty or commented line.
            continue
        elif [[ "${line}" == *=* ]]; then
            # Get the style name as shortest part before an equals sign
            # ("="), and strip leading and trailing spaces.
            name="${line%%=*}"
            argparser_trim "${name}"
            name="${trimmed_string}"

            if [[ -n "${styles[${name}]+set}" ]]; then
                # The style name exists, so extract the style as longest
                # part after the equals sign and strip leading and
                # trailing spaces and a double quote each.
                style="${line#*=}"
                argparser_trim "${style}"
                style="${trimmed_string}"
                style="${style#\"}"
                style="${style%\"}"

                styles[${name}]="${style}"
            else
                # Output a warning message when the style name doesn't
                # exist.
                warning_message="Warning: In the style file \"\$1\", the line "
                warning_message+="\"\$2\" sets a non-existent message key."

                argparser_translate "Warning style file message key" \
                    "${warning_message}" "${ARGPARSER_STYLE_FILE}" "${line}"
                warning_message="${translation}"
                warning_messages+=("${warning_message}")
            fi
        else
            # Output an error message when the line doesn't contain an
            # equals sign ("=").
            error_message="Error: In the style file \"\$1\", the line \"\$2\" "
            error_message+="doesn't contain an equals sign (\"=\"), nor is it "
            error_message+="empty or commented."

            argparser_translate "Error style file equals sign" \
                "${error_message}" "${ARGPARSER_STYLE_FILE}" "${line}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi
    done

    # Check if the styles only have values supported by
    # argparser_colorize.
    for name in "${!styles[@]}"; do
        style="${styles[${name}]}"
        if [[ "${name}" == *"_frame" ]]; then
            if ! argparser_check_styles "colors, frame styles" "${style}"; then
                colors_arr=(
                    "black"
                    "red"
                    "green"
                    "yellow"
                    "blue"
                    "magenta"
                    "cyan"
                    "white"
                )
                argparser_join "${ARGPARSER_ARG_DELIMITER_2:-","}" \
                    "${colors_arr[@]}"
                colors_str="${joined_array}"

                frame_styles_arr=(
                    "thin"
                    "thick"
                    "double"
                    "angular"
                    "rounded"
                    "solid"
                    "double-dashed"
                    "triple-dashed"
                    "quadruple-dashed"
                )
                argparser_join "${ARGPARSER_ARG_DELIMITER_2:-","}" \
                    "${frame_styles_arr[@]}"
                frame_styles_str="${joined_array}"

                error_message="Error: The style \"\$1\" is set to \"\$2\", "
                error_message+="but the values must lie in {\$3} for colors "
                error_message+="and in {\$4} for frame styles.  Colors, only, "
                error_message+="may be prefixed by \"bright_\" or suffixed by "
                error_message+="\"_fg\" or \"_bg\"."

                argparser_translate "Error style file frame styles" \
                    "${error_message}" "${name}" "${style}" "${colors_str}" \
                    "${frame_styles_str}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        else
            if ! argparser_check_styles "colors, text styles" "${style}"; then
                colors_arr=(
                    "black"
                    "red"
                    "green"
                    "yellow"
                    "blue"
                    "magenta"
                    "cyan"
                    "white"
                )
                argparser_join "${ARGPARSER_ARG_DELIMITER_2:-","}" \
                    "${colors_arr[@]}"
                colors_str="${joined_array}"

                text_styles_arr=(
                    "normal"
                    "bold"
                    "faint"
                    "italic"
                    "underline"
                    "double"
                    "overline"
                    "crossed-out"
                    "blink"
                    "reverse"
                )
                argparser_join "${ARGPARSER_ARG_DELIMITER_2:-","}" \
                    "${text_styles_arr[@]}"
                text_styles_str="${joined_array}"
                
                error_message="Error: The style \"\$1\" is set to \"\$2\", "
                error_message+="but the values must lie in {\$3} for colors "
                error_message+="and in {\$4} for text styles.  Colors, only, "
                error_message+="may be prefixed by \"bright_\" or suffixed by "
                error_message+="\"_fg\" or \"_bg\"."

                argparser_translate "Error style file text styles" \
                    "${error_message}" "${name}" "${style}" "${colors_str}" \
                    "${text_styles_str}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        fi
    done

    # If there are error or warning messages, sort, filter, colorize,
    # and print them, then exit (for error messages only).
    if (( "${#error_messages[@]}" > 0 || "${#warning_messages[@]}" > 0)) \
        && [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]
    then
        argparser_set_env_var_defaults
    fi

    argparser_print_error_messages true false "${error_messages[@]}"
    argparser_print_warning_messages true "${warning_messages[@]}"

    if (( "${#error_messages[@]}" > 0 )); then
        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    fi
}

# Define the Argparser functions for creating, reading, parsing, and
# checking the arguments definition.
function argparser_create_args_definition() {
    # Create the arguments definition from user input and write it to a
    # file.
    #
    # Environment:
    # - ARGPARSER_MAX_WIDTH (read-only)

    # Define the local variables.
    local arg_group
    local arg_key
    local arg_number
    local -a args
    local -a args_definition
    local choice_values
    local -a col_arg_groups
    local -a col_arg_keys
    local -a col_arg_numbers
    local -a col_choice_values
    local -a col_default_values
    local -a col_help_texts
    local -a col_long_options
    local -a col_notes
    local -a col_short_options
    local -a col_types
    local -a col_value_names
    local default_values
    local delimiter
    local drop_arg_group
    local drop_arg_number
    local drop_choice_values
    local drop_default_values
    local drop_help_text
    local drop_long_options
    local drop_note
    local drop_short_options
    local drop_type
    local drop_value_names
    local file
    local -a folded_array
    local help_text
    local i
    local line
    local long_options
    local message
    local note
    local -a padded_array
    local separator
    local shell
    local short_options
    local type
    local value_names

    # Set the horizontal separator.
    printf -v separator '%*s' "${ARGPARSER_MAX_WIDTH}" ""
    separator="${separator// /-}"
    argparser_colorize "green,bold" 1 separator "${separator}"

    # Get the target shell from user input.
    message="Does your script use Bash (y) or only a POSIX-compliant shell "
    message+="(n)?"
    argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 "${message}"
    argparser_colorize "blue,bold" 1 message "${folded_array[@]}"
    printf '%s\n\n' "${message}"

    while read -r -e -p "Bash usage (y/n):  " shell 2>&1; do
        if [[ "${shell}" == "y" ]]; then
            shell="Bash"
            break
        elif [[ "${shell}" == "n" ]]; then
            shell="POSIX"
            break
        fi
        printf 'Please answer with "y" or "n".\n'
    done

    printf '%s\n' "${separator}"

    # Get the target file from user input.
    message="Which file shall the arguments definition be written to?"
    argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 "${message}"
    argparser_colorize "blue,bold" 1 message "${folded_array[@]}"
    printf '%s\n\n' "${message}"

    read -r -e -p "Target file:  " file 2>&1

    printf '%s\n' "${separator}"

    # Get the arguments definition delimiters from user input.
    message="Which character do you want to use as primary arguments "
    message+="definition delimiter?"
    argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 "${message}"
    argparser_colorize "blue,bold" 1 message "${folded_array[@]}"
    printf '%s\n\n' "${message}"

    read -r -e -p "Primary delimiter:  " delimiter 2>&1

    printf '%s\n' "${separator}"

    # Get the arguments definition fields from user input.
    col_arg_keys=("id")
    col_short_options=("short_opts")
    col_long_options=("long_opts")
    col_value_names=("val_names")
    col_default_values=("defaults")
    col_choice_values=("choices")
    col_types=("type")
    col_arg_numbers=("arg_no")
    col_arg_groups=("arg_group")
    col_notes=("notes")
    col_help_texts=("help")

    message="Enter the fields for each argument.  Submit an empty argument "
    message+="identifier to end the input."
    argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 "${message}"
    argparser_colorize "blue,bold" 1 message "${folded_array[@]}"
    printf '%s\n\n' "${message}"

    while :; do
        read -r -e -p "Argument identifier:  " arg_key 2>&1
        if [[ -z "${arg_key}" ]]; then
            break
        fi

        {
            read -r -e -p "Short option names:   " short_options
            read -r -e -p "Long option names:    " long_options
            read -r -e -p "Value names:          " value_names
            read -r -e -p "Default values:       " default_values
            read -r -e -p "Choice values:        " choice_values
            read -r -e -p "Data type:            " type
            read -r -e -p "Argument number:      " arg_number
            read -r -e -p "Argument group:       " arg_group
            read -r -e -p "Notes:                " note
            read -r -e -p "Help text:            " help_text
        } 2>&1

        col_arg_keys+=("${arg_key}")
        col_short_options+=("${short_options}")
        col_long_options+=("${long_options}")
        col_value_names+=("${value_names}")
        col_default_values+=("${default_values}")
        col_choice_values+=("${choice_values}")
        col_types+=("${type}")
        col_arg_numbers+=("${arg_number}")
        col_arg_groups+=("${arg_group}")
        col_notes+=("${note}")
        col_help_texts+=("${help_text}")

        printf '%s\n' "${separator}"
    done

    # Set each field in a column to the same width by right-padding with
    # spaces.
    argparser_pad "right" "auto" "${col_arg_keys[@]}"
    col_arg_keys=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_short_options[@]}"
    col_short_options=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_long_options[@]}"
    col_long_options=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_value_names[@]}"
    col_value_names=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_default_values[@]}"
    col_default_values=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_choice_values[@]}"
    col_choice_values=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_types[@]}"
    col_types=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_arg_numbers[@]}"
    col_arg_numbers=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_arg_groups[@]}"
    col_arg_groups=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_notes[@]}"
    col_notes=("${padded_array[@]}")

    argparser_pad "right" "auto" "${col_help_texts[@]}"
    col_help_texts=("${padded_array[@]}")

    # Set flags for empty columns to be dropped.  Thereby, any column
    # but the argument identifier may be empty, i.e., all elements but
    # the header only consist of spaces, there.
    for short_options in "${col_short_options[@]:1}"; do
        if [[ ! "${short_options}" =~ ^" "+$ ]]; then
            drop_short_options=false
            break
        fi
        drop_short_options=true
    done

    for long_options in "${col_long_options[@]:1}"; do
        if [[ ! "${long_options}" =~ ^" "+$ ]]; then
            drop_long_options=false
            break
        fi
        drop_long_options=true
    done

    for value_names in "${col_value_names[@]:1}"; do
        if [[ ! "${value_names}" =~ ^" "+$ ]]; then
            drop_value_names=false
            break
        fi
        drop_value_names=true
    done

    for default_values in "${col_default_values[@]:1}"; do
        if [[ ! "${default_values}" =~ ^" "+$ ]]; then
            drop_default_values=false
            break
        fi
        drop_default_values=true
    done

    for choice_values in "${col_choice_values[@]:1}"; do
        if [[ ! "${choice_values}" =~ ^" "+$ ]]; then
            drop_choice_values=false
            break
        fi
        drop_choice_values=true
    done

    for type in "${col_types[@]:1}"; do
        if [[ ! "${type}" =~ ^" "+$ ]]; then
            drop_type=false
            break
        fi
        drop_type=true
    done

    for arg_number in "${col_arg_numbers[@]:1}"; do
        if [[ ! "${arg_number}" =~ ^" "+$ ]]; then
            drop_arg_number=false
            break
        fi
        drop_arg_number=true
    done

    for arg_group in "${col_arg_groups[@]:1}"; do
        if [[ ! "${arg_group}" =~ ^" "+$ ]]; then
            drop_arg_group=false
            break
        fi
        drop_arg_group=true
    done

    for note in "${col_notes[@]:1}"; do
        if [[ ! "${note}" =~ ^" "+$ ]]; then
            drop_note=false
            break
        fi
        drop_note=true
    done

    for help_text in "${col_help_texts[@]:1}"; do
        if [[ ! "${help_text}" =~ ^" "+$ ]]; then
            drop_help_text=false
            break
        fi
        drop_help_text=true
    done

    # Join the individual columns to the arguments definition table,
    # dropping the fields of empty columns.
    args=()
    for i in "${!col_arg_keys[@]}"; do
        # shellcheck disable=SC2190  # Indexed, not associative array.
        args+=("${col_arg_keys[i]}")

        if [[ "${drop_short_options}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_short_options[i]}"
        fi

        if [[ "${drop_long_options}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_long_options[i]}"
        fi

        if [[ "${drop_value_names}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_value_names[i]}"
        fi

        if [[ "${drop_default_values}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_default_values[i]}"
        fi

        if [[ "${drop_choice_values}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_choice_values[i]}"
        fi

        if [[ "${drop_type}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_types[i]}"
        fi

        if [[ "${drop_arg_number}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_arg_numbers[i]}"
        fi

        if [[ "${drop_arg_group}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_arg_groups[i]}"
        fi

        if [[ "${drop_note}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_notes[i]}"
        fi

        if [[ "${drop_help_text}" == false ]]; then
            args[-1]+=" ${delimiter} ${col_help_texts[i]}"
        fi
    done

    # Output the arguments definition table either as Bash array or
    # POSIX multi-line string with subsequent help/usage/version flag
    # checking.  Possibly, precede the table with the needed environment
    # variables.
    args_definition=( )
    if [[ "${shell}" == "Bash" ]]; then
        if [[ "${delimiter}" != "${ARGPARSER_ARG_DELIMITER_1}" ]]; then
            args_definition+=("ARGPARSER_ARG_DELIMITER_1=\"${delimiter}\"")
        fi

        args_definition+=('args=(')

        for line in "${args[@]}"; do
            args_definition+=("    \"${line}\"")
        done

        args_definition+=(
            ')'
            'source argparser -- "$@"'
        )
    else
        # shellcheck disable=SC2016  # Intentional single-quoted expressions.
        args_definition+=(
            'export ARGPARSER_SCRIPT_NAME="${0##*/}"'
            'export ARGPARSER_WRITE_ARGS=true'
        )

        if [[ "${delimiter}" != "${ARGPARSER_ARG_DELIMITER_1}" ]]; then
            args_definition+=("export ARGPARSER_ARG_DELIMITER_1=\"${delimiter}\"")
        fi

        args_definition+=('args='\')

        for line in "${args[@]}"; do
            args_definition+=("    ${line}")
        done

        # shellcheck disable=SC1003  # Literal backslash before single quotes.
        # shellcheck disable=SC2016  # Intentional single-quoted expressions.
        args_definition+=(
            \'
            ''
            'if [ "$1" = "-h" ] || [ "$1" = "--help" ] \'
            '    || [ "$1" = "-u" ] || [ "$1" = "--usage" ] \'
            '    || [ "$1" = "-V" ] || [ "$1" = "--version" ]'
            'then'
            '    printf '\''%s'\'' "${args}" | argparser -- "$@"'
            'else'
            '    eval "$(printf '\''%s'\'' "${args}" | argparser -- "$@" | tee /dev/stderr)"'
            'fi'
        )
    fi

    printf '%s\n' "${args_definition[@]}" > "${file}"
}

function argparser_read_args_definition() {
    # Read the arguments definition from the script and arguments
    # definition file, if provided.
    #
    # Arguments:
    # - $@: the arguments known to the script
    #
    # Nonlocals:
    # - messages: the read arguments definition as message or an error
    #   message, starting with "File: ", "Script: ", or "Error: "
    #   (translated), as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DEF_FILE (read-only)
    # - ARGPARSER_ARG_DELIMITER_1 (read-only)

    # Define the local variables.
    local arg
    local arg_key
    local -a args
    local error_message
    local header
    local line
    local lines
    local translation
    local trimmed_string

    # Read the arguments.
    # shellcheck disable=SC2190  # Indexed, not associative array.
    args=("$@")

    # Read and output the header for a possible arguments definition in
    # the script.
    header="${args[0]}"
    messages+=("Script: ${header}")

    # If ${ARGPARSER_ARG_DEF_FILE} isn't set to the empty string, read
    # the arguments definition file and output the header.
    if [[ -n "${ARGPARSER_ARG_DEF_FILE}" ]]; then
        mapfile -t lines < "${ARGPARSER_ARG_DEF_FILE}"
        header="${lines[0]}"
        messages+=("File: ${header}")
    fi

    # Get the definition for each argument (excluding the header as
    # zeroth element in ${args}).  These arguments may either be defined
    # in the script, where they're given in the columnar Argparser
    # syntax, or in a separate arguments definition file, so they're
    # only given as their key.  If the structure differs, and no header
    # is given (so columns may be omitted), output an error message.
    for arg in "${args[@]:1}"; do
        if [[ "${arg}" != *"${ARGPARSER_ARG_DELIMITER_1}"* \
            && -n "${ARGPARSER_ARG_DEF_FILE}" ]]
        then
            # The argument contains no ${ARGPARSER_ARG_DELIMITER_1} and
            # thus only the key, and an arguments definition file is
            # given. Iterate over all arguments definition lines from
            # the file.  When the argument key in one line matches the
            # given key, output the key and definition, then continue
            # the outer loop (with index 2).  If the inner loop doesn't
            # get aborted by the continuation, it means that no fitting
            # argument definition has been found.  Thus, output an error
            # message.
            for line in "${lines[@]:1}"; do
                arg_key="${line%%"${ARGPARSER_ARG_DELIMITER_1}"*}"
                argparser_trim "${arg_key}"
                arg_key="${trimmed_string}"

                if [[ "${arg_key}" == "${arg}" ]]; then
                    messages+=("File: ${line}")
                    continue 2
                fi
            done
            error_message="Error: No argument definition for \"\$1\"."
            argparser_translate "Error no arg def" "${error_message}" "${arg}"
            error_message="${translation}"
            messages+=("${error_message}")
        else
            # The argument contains an ${ARGPARSER_ARG_DELIMITER_1} and
            # thus potentially an entire definition.  Output this.
            messages+=("Script: ${arg}")
        fi
    done
}

function argparser_parse_args_definition() {
    # Parse the arguments definition into an associative array per CSV
    # column.
    #
    # Arguments:
    # - $1: the origin of the arguments definition ("script" or "file")
    # - $@: the indexed array holding the arguments definition, the
    #       first line of which being the header
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups
    # - all_arg_numbers: the associative array holding the argument
    #   numbers
    # - all_choice_values: the associative array holding the choice
    #   values
    # - all_default_values: the associative array holding the default
    #   values
    # - all_help_texts: the associative array holding the help texts
    # - all_long_options: the associative array holding the long option
    #   names
    # - all_notes: the associative array holding the notes
    # - all_positional_args: the indexed array holding the positional
    #   argument names
    # - all_resolved_choice_values: the associative array holding the
    #   resolved (range-expanded) choice values
    # - all_short_options: the associative array holding the short
    #   option names
    # - all_types: the associative array holding the argument types
    # - all_value_names: the associative array holding the value names
    #
    # Environment:
    # - ARGPARSER_ARG_DEF_FILE (read-only)
    # - ARGPARSER_ARG_DELIMITER_1 (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_POSITIONAL_ARG_GROUP (read-only)
    # - ARGPARSER_SCRIPT_NAME (read-only)

    # Define the local variables.
    local arg_group
    local arg_key
    local arg_number
    local -a args_definition
    local -a choice_values_arr
    local choice_values_str
    local column_index
    local -A column_indices
    local default_values
    local definition_type
    local error_message
    local -a error_messages
    local field
    local -a fields
    local -a header
    local help_text
    local joined_array
    local -a line
    local long_options
    local notes
    local range
    local range_start
    local range_step
    local range_stop
    local -a resolved_choice_values_arr
    local resolved_choice_values_str
    local sequence
    local short_options
    local translation
    local trimmed_string
    local type
    local value_names

    # Read the arguments.
    definition_type="$1"
    shift
    args_definition=("$@")

    # Read the first line (the header) of ${args_definition} to get the
    # column indices for the fields.  Strip leading and trailing spaces.
    IFS="${ARGPARSER_ARG_DELIMITER_1}" read -r -a header \
        <<< "${args_definition[0]}"
    for column_index in "${!header[@]}"; do
        argparser_trim "${header[column_index]}"
        header[column_index]="${trimmed_string}"
    done

    # Get the column indices of all fields.
    column_indices=(
        [id]=""
        [short_opts]=""
        [long_opts]=""
        [val_names]=""
        [defaults]=""
        [choices]=""
        [type]=""
        [arg_no]=""
        [arg_group]=""
        [notes]=""
        [help]=""
    )

    for field in "${!column_indices[@]}"; do
        for column_index in "${!header[@]}"; do
            if [[ "${header[column_index]}" == "${field}" ]]; then
                column_indices[${field}]="${column_index}"
            fi
        done
    done

    # If the column with the argument identifiers isn't given, output an
    # error message.
    error_messages=( )
    if [[ -z "${column_indices[id]}" ]]; then
        if [[ "${definition_type}" == "script" ]]; then
            error_message="Error: In the arguments definition in \"\$1\", "
            error_message+="the column \"id\" is missing."

            argparser_translate "Error arg def id" "${error_message}" \
                "${ARGPARSER_SCRIPT_NAME}"
            error_message="${translation}"
        else
            error_message="Error: In the arguments definition file "
            error_message+="\"\$1\", the column \"\$2\" is missing."

            argparser_translate "Error arg def file id" \
                "${error_message}" "${ARGPARSER_ARG_DEF_FILE}"
            error_message="${translation}"
        fi
        error_messages+=("${error_message}")
    fi

    # If there are error messages, sort, colorize, and print them, then
    # exit.
    argparser_print_error_messages false true "${error_messages[@]}"

    # Read all lines of the arguments definition and save the fields in
    # an associative array per column, using the argument identifier as
    # key and the definition in the field (or a default value) as value.
    # If neither a short nor a long option name is given, interpret the
    # argument as positional and add it to the respective indexed array.
    # If only short or long option names shall be accepted, set the
    # respective other value to the empty string, indicating absence of
    # an option name.  Skip arguments that have no short or long option
    # name, if only the other one is accepted, since these can never be
    # given.
    for line in "${args_definition[@]:1}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_1}" read -r -a fields <<< "${line}"

        # If the line has more or less columns than the header, output
        # an error message.
        if [[ "${#fields[@]}" != "${#header[@]}" ]]; then
            if [[ "${definition_type}" == "script" ]]; then
                error_message="Error: In the arguments definition in \"\$1\", "
                error_message+="the field count of the line \"\$2\" (\$3) "
                error_message+="doesn't match the header's field count (\$4)."

                argparser_translate "Error arg def field count" \
                    "${error_message}" "${ARGPARSER_SCRIPT_NAME}" "${line}" \
                    "${#fields[@]}" "${#header[@]}"
                error_message="${translation}"
            else
                error_message="Error: In the arguments definition file "
                error_message+="\"\$1\", the field count of the line \"\$2\" "
                error_message+="(\$3) doesn't match the header's field count "
                error_message+="(\$4)."

                argparser_translate "Error arg def file field count" \
                    "${error_message}" "${ARGPARSER_ARG_DEF_FILE}" "${line}" \
                    "${#fields[@]}" "${#header[@]}"
                error_message="${translation}"
            fi
            error_messages+=("${error_message}")
        fi

        # Get the argument identifier.
        argparser_trim "${fields[${column_indices["id"]}]}"
        arg_key="${trimmed_string}"

        # Get the short option names.
        if [[ -n "${column_indices["short_opts"]}" ]]; then
            argparser_trim "${fields[${column_indices["short_opts"]}]}"
            short_options="${trimmed_string}"
        else
            short_options=""
        fi

        # Get the long option names.
        if [[ -n "${column_indices["long_opts"]}" ]]; then
            argparser_trim "${fields[${column_indices["long_opts"]}]}"
            long_options="${trimmed_string}"
        else
            long_options=""
        fi

        # Save the option names.
        if [[ -z "${short_options}" && -z "${long_options}" ]]; then
            all_positional_args+=("${arg_key}")
        elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true \
            && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]
        then
            all_short_options[${arg_key}]="${short_options}"
            all_long_options[${arg_key}]="${long_options}"
        elif [[ -n "${short_options}" \
            && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]
        then
            all_short_options[${arg_key}]="${short_options}"
            all_long_options[${arg_key}]=""
        elif [[ -n "${long_options}" \
            && "${ARGPARSER_USE_LONG_OPTIONS}" == true ]]
        then
            all_short_options[${arg_key}]=""
            all_long_options[${arg_key}]="${long_options}"
        else
            continue
        fi

        # Get the value names.
        if [[ -n "${column_indices["val_names"]}" ]]; then
            argparser_trim "${fields[${column_indices["val_names"]}]}"
            value_names="${trimmed_string}"
        else
            value_names=""
        fi
        all_value_names[${arg_key}]="${value_names}"

        # Get the default values.
        if [[ -n "${column_indices["defaults"]}" ]]; then
            argparser_trim "${fields[${column_indices["defaults"]}]}"
            default_values="${trimmed_string}"
        else
            default_values=""
        fi
        all_default_values[${arg_key}]="${default_values}"

        # Get the choice values.  Resolve ranges in the individual
        # elements.
        if [[ -n "${column_indices["choices"]}" ]]; then
            argparser_trim "${fields[${column_indices["choices"]}]}"
            choice_values_str="${trimmed_string}"

            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
                <<< "${choice_values_str}"
            resolved_choice_values_arr=( )
            for range in "${choice_values_arr[@]}"; do
                if [[ "${range}" == *-*-*-* ]]; then
                    error_message="Error: The argument with the identifier "
                    error_message+="\"\$1\" has more hyphens in the choice "
                    error_message+="values given than supported (2)."

                    argparser_translate "Error arg def choice range hyphens" \
                        "${error_message}" "${arg_key}"
                    error_messages+=("${error_message}")
                elif [[ "${range}" == *-*-* ]]; then
                    range_start="${range%%-*}"
                    range_stop="${range#*-}"
                    range_step="${range_stop#*-}"
                    range_stop="${range_stop%%-*}"

                    argparser_seq "${arg_key}" "${range_start}" \
                        "${range_stop}" "${range_step}"
                    resolved_choice_values_arr+=("${sequence[@]}")
                elif [[ "${range}" == *-* ]]; then
                    range_start="${range%-*}"
                    range_stop="${range#*-}"

                    argparser_seq "${arg_key}" "${range_start}" "${range_stop}"
                    resolved_choice_values_arr+=("${sequence[@]}")
                else
                    resolved_choice_values_arr+=("${range}")
                fi
            done

            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${resolved_choice_values_arr[@]}"
            resolved_choice_values_str="${joined_array}"
        else
            choice_values_str=""
            resolved_choice_values_str=""
        fi

        all_choice_values[${arg_key}]="${choice_values_str}"
        all_resolved_choice_values[${arg_key}]="${resolved_choice_values_str}"

        # Get the data type.
        if [[ -n "${column_indices["type"]}" ]]; then
            argparser_trim "${fields[${column_indices["type"]}]}"
            type="${trimmed_string}"
        else
            type="str"
        fi
        all_types[${arg_key}]="${type}"

        # Get the argument number.
        if [[ -n "${column_indices["arg_no"]}" ]]; then
            argparser_trim "${fields[${column_indices["arg_no"]}]}"
            arg_number="${trimmed_string}"
        else
            arg_number=1
        fi
        all_arg_numbers[${arg_key}]="${arg_number}"

        # Get the argument group.
        if [[ -n "${column_indices["arg_group"]}" ]]; then
            argparser_trim "${fields[${column_indices["arg_group"]}]}"
            arg_group="${trimmed_string}"
        else
            arg_group="${ARGPARSER_POSITIONAL_ARG_GROUP}"
        fi
        all_arg_groups[${arg_key}]="${arg_group}"

        # Get the notes.
        if [[ -n "${column_indices["notes"]}" ]]; then
            argparser_trim "${fields[${column_indices["notes"]}]}"
            notes="${trimmed_string}"
        else
            notes=""
        fi
        all_notes[${arg_key}]="${notes}"

        # Get the help text.
        if [[ -n "${column_indices["help"]}" ]]; then
            argparser_trim "${fields[${column_indices["help"]}]}"
            help_text="${trimmed_string}"
        else
            help_text=""
        fi
        all_help_texts[${arg_key}]="${help_text}"
    done

    # If there are error messages, sort, colorize, and print them, then
    # exit.
    argparser_print_error_messages false true "${error_messages[@]}"
}

function argparser_check_args_definition_names() {
    # Check if the script's arguments' definition is consistent
    # regarding the short and long option names.  This should always be
    # true for production scripts, but maybe not while testing.
    #
    # Nonlocals:
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_HELP_OPTIONS (read-only)
    # - ARGPARSER_USAGE_OPTIONS (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_VERSION_OPTIONS (read-only)

    # Define the local variables.
    local arg_key
    local -a arg_keys
    local count
    local -A checked_long_options
    local -A checked_short_options
    local error_message
    local -a help_options
    local long_option
    local -a long_options
    local short_option
    local -a short_options
    local -a sorted_array
    local translation
    local -a usage_options
    local -a version_options

    # Read the short help, usage, and version option names.
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a help_options \
        <<< "${ARGPARSER_HELP_OPTIONS}"
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a usage_options \
        <<< "${ARGPARSER_USAGE_OPTIONS}"
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a version_options \
        <<< "${ARGPARSER_VERSION_OPTIONS}"

    # Get and sort all argument keys (identifiers), such that the
    # following loop is performed in alphabetical order of the
    # arguments, such that the error messages for duplicate option names
    # refer to the lexicographically earlier argument.
    argparser_sort false "${!all_short_options[@]}"
    arg_keys=("${sorted_array[@]}")

    # Check that no short or long option is given twice for the same
    # argument or among multiples.
    for arg_key in "${arg_keys[@]}"; do
        # Read the argument's definition.
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
            <<< "${all_short_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
            <<< "${all_long_options[${arg_key}]}"

        # If more than one short option name is given, check if any is
        # the empty string, which must only once be used as placeholder
        # for missing short options.  Then, check if any short option
        # name is longer than one character, and if it is given multiple
        # times in the current argument's definition or across all yet
        # investigated arguments' definitions.  If only one short option
        # name is given, the empty string is a legit value, so don't
        # check this.
        if (( "${#short_options[@]}" > 1 )) \
            && argparser_in_array "" "${short_options[@]}"
        then
            # Check if the empty string is included in the short option
            # names.
            error_message="Error: The short option with the identifier "
            error_message+="\"\$1\" has an empty string given as one of the "
            error_message+="\$2 short option names, instead of a legit name."

            argparser_translate "Error arg def short name empty" \
                "${error_message}" "${arg_key}" "${#short_options[@]}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        for short_option in "${short_options[@]}"; do
            if [[ "${ARGPARSER_ADD_HELP}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]] \
                && argparser_in_array "${short_option}" "${help_options[@]}"
            then
                # Check if a short option name uses the reserved flag
                # for the help message.
                error_message="Error: The short option with the identifier "
                error_message+="\"\$1\" has the short option \"-\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="help message."

                argparser_translate "Error arg def short name help" \
                    "${error_message}" "${arg_key}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_USAGE}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]] \
                && argparser_in_array "${short_option}" "${usage_options[@]}"
            then
                # Check if a short option name uses the reserved flag
                # for the usage message.
                error_message="Error: The short option with the identifier "
                error_message+="\"\$1\" has the short option \"-\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="usage message."

                argparser_translate "Error arg def short name usage" \
                    "${error_message}" "${arg_key}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_VERSION}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]] \
                && argparser_in_array "${short_option}" "${version_options[@]}"
            then
                # Check if a short option name uses the reserved flag
                # for the version message.
                error_message="Error: The short option with the identifier "
                error_message+="\"\$1\" has the short option \"-\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="version message."

                argparser_translate "Error arg def short name version" \
                    "${error_message}" "${arg_key}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ -n "${short_option}" ]]; then
                # Check if a short option name is more than one
                # character long.
                if (( "${#short_option}" > 1 )); then
                    error_message="Error: The short option with the "
                    error_message+="identifier \"\$1\" has the short option "
                    error_message+="\"-\$2\" defined with more than 1 "
                    error_message+="character length."

                    argparser_translate "Error arg def short name length" \
                        "${error_message}" "${arg_key}" "${short_option}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Check if the short option name is given multiple times
                # in the current argument's definition.
                argparser_count "${short_option}" "${short_options[@]}"
                if (( count > 1 )); then
                    error_message="Error: The short option with the "
                    error_message+="identifier \"\$1\" has the short option "
                    error_message+="\"-\$2\" given \$3 times."

                    argparser_translate \
                        "Error arg def short name duplication 1" \
                        "${error_message}" "${arg_key}" "${short_option}" \
                        "${count}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Check if the short option name is already given in
                # another argument's definition.
                if [[ -n "${checked_short_options[${short_option}]+set}" \
                    && "${checked_short_options[${short_option}]}" \
                        != "${arg_key}" ]]
                then
                    error_message="Error: The short option with the "
                    error_message+="identifier \"\$1\" has the short option "
                    error_message+="\"-\$2\" given, but that is already in "
                    error_message+="use by \"\$3\"."

                    argparser_translate \
                        "Error arg def short name duplication 2" \
                        "${error_message}" "${arg_key}" "${short_option}" \
                        "${checked_short_options[${short_option}]}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Add the short option name to the associative array of
                # all short option names.
                checked_short_options[${short_option}]="${arg_key}"
            fi
        done

        # Perform the same tests for the long option names for having
        # the empty string among the long option names or if any long
        # option name is shorter than two characters, and if it is given
        # multiple times in the current argument's definition or across
        # all yet investigated arguments' definitions.
        if (( "${#long_options[@]}" > 1 )) \
            && argparser_in_array "" "${long_options[@]}"
        then
            # Check if the empty string is included in the long option
            # names.
            error_message="Error: The long option with the identifier \"\$1\" "
            error_message+="has an empty string given as one of the \$2 long "
            error_message+="option names, instead of a legit name."

            argparser_translate "Error arg def long name empty" \
                "${error_message}" "${arg_key}" "${#long_options[@]}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        for long_option in "${long_options[@]}"; do
            if [[ "${ARGPARSER_ADD_HELP}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true \
                && "${long_option}" == "help" ]]
            then
                # Check if a long option name uses the reserved flag for
                # the help message.
                error_message="Error: The long option with the identifier "
                error_message+="\"\$1\" has the long option \"--help\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="help message."

                argparser_translate "Error arg def long name help" \
                    "${error_message}" "${arg_key}" "${long_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_USAGE}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true \
                && "${long_option}" == "usage" ]]
            then
                # Check if a long option name uses the reserved flag for
                # the usage message.
                error_message="Error: The long option with the identifier "
                error_message+="\"\$1\" has the long option \"--usage\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="usage message."

                argparser_translate "Error arg def long name usage" \
                    "${error_message}" "${arg_key}" "${long_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_VERSION}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true \
                && "${long_option}" == "version" ]]
            then
                # Check if a long option name uses the reserved flag for
                # the version message.
                error_message="Error: The long option with the identifier "
                error_message+="\"\$1\" has the long option \"--version\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="version message."

                argparser_translate "Error arg def long name version" \
                    "${error_message}" "${arg_key}" "${long_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ -n "${long_option}" ]]; then
                # Check if a long option name is less than two
                # characters long.
                if (( "${#long_option}" < 2 )); then
                    error_message="Error: The long option with the identifier "
                    error_message+="\"\$1\" has the long option \"--\$2\" "
                    error_message+="defined with less than 2 characters "
                    error_message+="length."

                    argparser_translate "Error arg def long name length" \
                        "${error_message}" "${arg_key}" "${long_option}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Check if the long option name is given multiple times
                # in the current argument's definition.
                argparser_count "${long_option}" "${long_options[@]}"
                if (( count > 1 )); then
                    error_message="Error: The long option with the identifier "
                    error_message+="\"\$1\" has the long option \"--\$2\" "
                    error_message+="given \$3 times."

                    argparser_translate \
                        "Error arg def long name duplication 1" \
                        "${error_message}" "${arg_key}" "${long_option}" \
                        "${count}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Check if the long option name is already given in
                # another argument's definition.
                if [[ -n "${checked_long_options[${long_option}]+set}"
                    && "${checked_long_options[${long_option}]}" \
                        != "${arg_key}" ]]
                then
                    error_message="Error: The long option with the identifier "
                    error_message+="\"\$1\" has the long option \"--\$2\" "
                    error_message+="given, but that is already in use by "
                    error_message+="\"\$3\"."

                    argparser_translate \
                        "Error arg def long name duplication 2" \
                        "${error_message}" "${arg_key}" "${long_option}" \
                        "${checked_long_options[${long_option}]}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                fi

                # Add the long option name to the associative array of
                # all long option names.
                checked_long_options[${long_option}]="${arg_key}"
            fi
        done
    done
}

function argparser_check_args_definition_positional_values() {
    # Check if the script's arguments' definition is consistent
    # regarding the default and choice values, as well as the number of
    # arguments for positional arguments.  This should always be true
    # for production scripts, but maybe not while testing.
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_choice_values: the associative array holding the choice
    #   values (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_notes: the associative array holding the notes (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - all_resolved_choice_values: the associative array holding the
    #   resolved (range-expanded) choice values (read-only)
    # - all_types: the associative array holding the argument types
    #   (read-only)
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local choice_value
    local choice_values_str
    local default_value
    local -a default_values_arr
    local default_values_str
    local error_message
    local infinite_arg_number_arg
    local note
    local -a notes
    local optional_arg
    local -a resolved_choice_values_arr
    local resolved_choice_values_str
    local translation
    local type

    # Check the consistency of all positional arguments.
    infinite_arg_number_arg=""
    optional_arg=""
    for arg_key in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
            <<< "${default_values_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
            resolved_choice_values_arr \
                <<< "${resolved_choice_values_str}"
        type="${all_types[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_key}]}"

        # Check if the default value for arguments that can be used as
        # flags, if given, is either "true" or "false".
        if argparser_in_array "${arg_number}" "*" "?" \
            && [[ -n "${default_values_str}" ]] \
            && ! argparser_in_array "${default_values_str}" true false
        then
            error_message="Error: The positional argument with the identifier "
            error_message+="\"\$1\" must be \"true\" or \"false\", but has "
            error_message+="{\$2} given as default."

            argparser_translate "Error arg def pos default flag" \
                "${error_message}" "${arg_key}" "${default_values_str}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        # Check if the number of default values equals the number of
        # required values.  Else, output an error message.
        if ! argparser_in_array "${arg_number}" "+" "*" "?" \
            && [[ -n "${default_values_str}" \
                && "${#default_values_arr[@]}" != "${arg_number}" ]]
        then
            if [[ "${arg_number}" == 1 ]]; then
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" requires 1 value, but has "
                error_message+="\$2 given as default."

                argparser_translate "Error arg def pos default 1" \
                    "${error_message}" "${arg_key}" "${#default_values_arr[@]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            else
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" requires \$2 values, but "
                error_message+="has \$3 given as default."

                argparser_translate "Error arg def pos default 2" \
                    "${error_message}" "${arg_key}" "${arg_number}" \
                    "${#default_values_arr[@]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        fi

        # Check if the default values accord to the choice values, i.e.,
        # if each default value lies within the array of choice values.
        # Else, output an error message.
        if [[ -n "${resolved_choice_values_str}" ]]; then
            # Check that "true" and "false" aren't choice values.
            for choice_value in "${resolved_choice_values_arr[@]}"; do
                if [[ "${choice_value}" == true \
                    || "${choice_value}" == false ]]
                then
                    error_message="Error: The positional argument with the "
                    error_message+="identifier \"\$1\" has {\$2} given as "
                    error_message+="choice values, while \"true\" and "
                    error_message+="\"false\" cannot be any."

                    argparser_translate "Error arg def pos choice true" \
                        "${error_message}" "${arg_key}" "${choice_values_str}"
                    error_message="${translation}"
                    error_messages+=("${error_message}")
                    break
                fi
            done

            # Check the default values, separately for flag-like and
            # "normal" arguments.
            for default_value in "${default_values_arr[@]}"; do
                if [[ -z "${default_value}" ]]; then
                    continue
                fi

                if argparser_in_array "${arg_number}" "*" "?"; then
                    if ! argparser_in_array "${default_value}" \
                        "${resolved_choice_values_arr[@]}" true false
                    then
                        error_message="Error: The positional argument with "
                        error_message+="the identifier \"\$1\" accepts only "
                        error_message+="the choice values {\$2}, but has "
                        error_message+="{\$3} given as default."

                        argparser_translate \
                            "Error arg def pos choice default" \
                            "${error_message}" "${arg_key}" \
                            "${choice_values_str}" "${default_values_str}"
                        error_message="${translation}"
                        error_messages+=("${error_message}")
                        break
                    fi
                else
                    if ! argparser_in_array "${default_value}" \
                        "${resolved_choice_values_arr[@]}"
                    then
                        error_message="Error: The positional argument with "
                        error_message+="the identifier \"\$1\" accepts only "
                        error_message+="the choice values {\$2}, but has "
                        error_message+="{\$3} given as default."

                        argparser_translate \
                            "Error arg def pos choice default" \
                            "${error_message}" "${arg_key}" \
                            "${choice_values_str}" "${default_values_str}"
                        error_message="${translation}"
                        error_messages+=("${error_message}")
                        break
                    fi
                fi
            done
        fi

        # Check the number of arguments with default values.
        if [[ -n "${default_values_str}" ]]; then
            # Check that no two positional arguments are optional, which
            # would be impossible to parse.
            if [[ -n "${optional_arg}" ]]; then
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" is optional, as is "
                error_message+="\"\$2\", which renders parsing impossible."

                argparser_translate "Error arg def pos optionals" \
                    "${error_message}" "${arg_key}" "${optional_arg}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            else
                optional_arg="${arg_key}"
            fi

            # Likewise, check that there is no positional argument
            # accepting an infinite number of values along the optional
            # one, which would also be impossible to parse.
            if [[ -n "${infinite_arg_number_arg}" ]]; then
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" is optional, while \"\$2\" "
                error_message+="accepts an infinite number of values, which "
                error_message+="renders parsing impossible."

                argparser_translate "Error arg def pos optional infinite" \
                    "${error_message}" "${arg_key}" \
                    "${infinite_arg_number_arg}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        fi

        # Check the number of arguments.
        if [[ "${arg_number}" == 0 ]]; then
            # Since positional arguments can't be flags, output an error
            # message.
            error_message="Error: The positional argument with the identifier "
            error_message+="\"\$1\" accepts 0 arguments and thus can never be "
            error_message+="given on the command line."

            argparser_translate "Error arg def pos flag" "${error_message}" \
                "${arg_key}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        elif [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
            # Check that no two positional arguments accept an infinite
            # number of values, which would be impossible to parse.
            if [[ -n "${infinite_arg_number_arg}" ]]; then
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" accepts an infinite number "
                error_message+="of values, as does \"\$2\", which renders "
                error_message+="parsing impossible."

                argparser_translate "Error arg def pos infinites" \
                    "${error_message}" "${arg_key}" \
                    "${infinite_arg_number_arg}"
                error_messages+=("${error_message}")
            else
                infinite_arg_number_arg="${arg_key}"
            fi

            # Likewise, check that there is no optional positional
            # argument along the one accepting an infinite number of
            # values, which would also be impossible to parse.
            if [[ -n "${optional_arg}" ]]; then
                if [[ "${optional_arg}" == "${arg_key}" ]]; then
                    # The argument being both optional and accepting an
                    # infinite number of values is the same (the current
                    # one), which is not supported.
                    error_message="Error: The positional argument with the "
                    error_message+="identifier \"\$1\" accepts an infinite "
                    error_message+="number of values, while being optional, "
                    error_message+="which is not supported."

                    argparser_translate \
                        "Error arg def pos infinite optional 1" \
                        "${error_message}" "${arg_key}"
                    error_message="${translation}"
                else
                    # Both arguments are different, which is impossible
                    # to parse.
                    error_message="Error: The positional argument with the "
                    error_message+="identifier \"\$1\" accepts an infinite "
                    error_message+="number of values, while \"\$2\" is "
                    error_message+="optional, which renders parsing "
                    error_message+="impossible."

                    argparser_translate \
                        "Error arg def pos infinite optional 2" \
                        "${error_message}" "${arg_key}" "${optional_arg}"
                    error_message="${translation}"
                fi
                error_messages+=("${error_message}")
            fi
        fi

        # Check the data type.
        if ! argparser_in_array "${type}" "bool" "char" "float" "file" "int" \
            "str" "uint"
        then
            error_message="Error: The positional argument with the identifier "
            error_message+="\"\$1\" has \"\$2\" given as data type, but only "
            error_message+="\"bool\", \"char\", \"float\", \"file\", \"int\", "
            error_message+="\"str\", and \"uint\" are supported."

            argparser_translate "Error arg def pos type" "${error_message}" \
                "${arg_key}" "${type}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        # Check if the choice values accord to the type.
        for choice_value in "${resolved_choice_values_arr[@]}"; do
            if [[ -z "${choice_value}" ]]; then
                # No choice value is given, so abort the loop.
                break
            fi

            if [[ "${type}" == "bool" ]] \
                && ! argparser_is_bool "${choice_value}"
            then
                # Check if the choice value is a Boolean.
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as "
                error_message+="choice value, which must be a Boolean, i.e., "
                error_message+="\"true\" or \"false\"."

                argparser_translate "Error arg def pos bool" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "char" ]] \
                && ! argparser_is_char "${choice_value}"
            then
                # Check if the choice value is a character.
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as "
                error_message+="choice value, which must be a character, "
                error_message+="i.e., a string comprising one printable ASCII "
                error_message+="character."

                argparser_translate "Error arg def pos char" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "float" ]] \
                && ! argparser_is_float "${choice_value}"
            then
                # Check if the choice value is a floating-point number.
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as "
                error_message+="choice value, which must be a floating-point "
                error_message+="number, i.e., comprise only digits, a dot, "
                error_message+="and possibly a leading sign."

                argparser_translate "Error arg def pos float" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "int" ]] \
                && ! argparser_is_int "${choice_value}"
            then
                # Check if the choice value is an integer.
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as "
                error_message+="choice value, which must be an integer, i.e., "
                error_message+="comprise only digits and possibly a leading "
                error_message+="sign."

                argparser_translate "Error arg def pos int" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "uint" ]] \
                && ! argparser_is_uint "${choice_value}"
            then
                # Check if the choice value is an unsigned integer.
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as "
                error_message+="choice value, which must be an unsigned "
                error_message+="integer, i.e., comprise only digits and no "
                error_message+="sign."

                argparser_translate "Error arg def pos uint" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done

        # Check the notes.
        for note in "${notes[@]}"; do
            if [[ -n "${note}" && "${note}" != "deprecated" ]]; then
                error_message="Error: The positional argument with the "
                error_message+="identifier \"\$1\" has \"\$2\" given as note, "
                error_message+="but only \"deprecated\" is supported."

                argparser_translate "Error arg def pos note" \
                    "${error_message}" "${arg_key}" "${note}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done
}

function argparser_check_args_definition_option_values() {
    # Check if the script's arguments' definition is consistent
    # regarding the default and choice values, as well as the number of
    # arguments for options (keyword arguments).  This should always be
    # true for production scripts, but maybe not while testing.
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_choice_values: the associative array holding the choice
    #   values (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_notes: the associative array holding the notes (read-only)
    # - all_resolved_choice_values: the associative array holding the
    #   resolved (range-expanded) choice values (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - all_types: the associative array holding the argument types
    #   (read-only)
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local choice_value
    local choice_values_str
    local default_value
    local -a default_values_arr
    local default_values_str
    local error_message
    local note
    local -a notes
    local -a resolved_choice_values_arr
    local resolved_choice_values_str
    local translation
    local type

    # Check the consistency of all keyword arguments.
    for arg_key in "${!all_short_options[@]}"; do
        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
            <<< "${default_values_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
            resolved_choice_values_arr \
                <<< "${resolved_choice_values_str}"
        type="${all_types[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_key}]}"

        # Check if the default value for flags (or arguments that can be
        # used as such), if given, is either "true" or "false".
        if argparser_in_array "${arg_number}" "*" "?" 0 \
            && [[ -n "${default_values_str}" ]] \
            && ! argparser_in_array "${default_values_str}" true false
        then
            error_message="Error: The option with the identifier \"\$1\" must "
            error_message+="be \"true\" or \"false\", but has {\$2} given as "
            error_message+="default."

            argparser_translate "Error arg def option default flag" \
                "${error_message}" "${arg_key}" "${default_values_str}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        # Check if the number of default values equals the number of
        # required values.  Else, output an error message.
        if ! argparser_in_array "${arg_number}" "+" "*" "?" 0 \
            && [[ -n "${default_values_str}" \
                && "${#default_values_arr[@]}" != "${arg_number}" ]]
        then
            if [[ "${arg_number}" == 1 ]]; then
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="requires 1 value, but has \$2 given as "
                error_message+="default."

                argparser_translate "Error arg def option default 1" \
                    "${error_message}" "${arg_key}" "${#default_values_arr[@]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            else
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="requires \$2 values, but has \$3 given as "
                error_message+="default."

                argparser_translate "Error arg def option default 2" \
                    "${error_message}" "${arg_key}" "${arg_number}" \
                    "${#default_values_arr[@]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        fi

        # Check if the default values accord to the choice values, i.e.,
        # if each default value lies within the array of choice values.
        # Else, output an error message.
        if [[ -n "${resolved_choice_values_str}" ]]; then
            # Check that flags have no choice value and that "true" and
            # "false" aren't choice values.
            if [[ "${arg_number}" == 0 ]]; then
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="accepts no choice values, but has {\$2} given."

                argparser_translate "Error arg def option choice flag" \
                    "${error_message}" "${arg_key}" "${choice_values_str}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            else
                for choice_value in "${resolved_choice_values_arr[@]}"; do
                    if [[ "${choice_value}" == true \
                        || "${choice_value}" == false ]]
                    then
                        error_message="Error: The option with the identifier "
                        error_message+="\"\$1\" has {\$2} given as choice "
                        error_message+="values, while \"true\" and \"false\" "
                        error_message+="cannot be any."

                        argparser_translate \
                            "Error arg def option choice true" \
                            "${error_message}" "${arg_key}" \
                            "${choice_values_str}"
                        error_message="${translation}"
                        error_messages+=("${error_message}")
                        break
                    fi
                done

            fi

            # Check the default values, separately for flag-like and
            # "normal" arguments.
            for default_value in "${default_values_arr[@]}"; do
                if [[ -z "${default_value}" ]]; then
                    continue
                fi

                if argparser_in_array "${arg_number}" "*" "?"; then
                    if ! argparser_in_array "${default_value}" \
                        "${resolved_choice_values_arr[@]}" true false
                    then
                        error_message="Error: The option with the identifier "
                        error_message+="\"\$1\" accepts only the choice "
                        error_message+="values {\$2}, but has {\$3} given as "
                        error_message+="default."

                        argparser_translate \
                            "Error arg def option choice default" \
                            "${error_message}" "${arg_key}" \
                            "${choice_values_str}" "${default_values_str}"
                        error_message="${translation}"
                        error_messages+=("${error_message}")
                        break
                    fi
                else
                    if ! argparser_in_array "${default_value}" \
                        "${resolved_choice_values_arr[@]}"
                    then
                        error_message="Error: The option with the identifier "
                        error_message+="\"\$1\" accepts only the choice "
                        error_message+="values {\$2}, but has {\$3} given as "
                        error_message+="default."

                        argparser_translate \
                            "Error arg def option choice default" \
                            "${error_message}" "${arg_key}" \
                            "${choice_values_str}" "${default_values_str}"
                        error_message="${translation}"
                        error_messages+=("${error_message}")
                        break
                    fi
                fi
            done
        fi

        # Check the data type.
        if ! argparser_in_array "${type}" "bool" "char" "float" "file" "int" \
            "str" "uint"
        then
            error_message="Error: The option with the identifier \"\$1\" has "
            error_message+="\"\$2\" given as data type, but only \"bool\", "
            error_message+="\"char\", \"float\", \"file\", \"int\", \"str\", "
            error_message+="and \"uint\" are supported."

            argparser_translate "Error arg def option type" \
                "${error_message}" "${arg_key}" "${type}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi

        # Check if the choice values accord to the type.
        for choice_value in "${resolved_choice_values_arr[@]}"; do
            if [[ -z "${choice_value}" ]]; then
                # No choice value is given, so abort the loop.
                break
            fi

            if [[ "${type}" == "bool" ]] \
                && ! argparser_is_bool "${choice_value}"
            then
                # Check if the choice value is a Boolean.
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as choice value, which must "
                error_message+="be a Boolean, i.e., \"true\" or \"false\"."

                argparser_translate "Error arg def option bool" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "char" ]] \
                && ! argparser_is_char "${choice_value}"
            then
                # Check if the choice value is a character.
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as choice value, which must "
                error_message+="be a character, i.e., a string comprising one "
                error_message+="printable ASCII character."

                argparser_translate "Error arg def option char" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "float" ]] \
                && ! argparser_is_float "${choice_value}"
            then
                # Check if the choice value is a floating-point number.
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as choice value, which must "
                error_message+="be a floating-point number, i.e., comprise "
                error_message+="only digits, a dot, and possibly a leading "
                error_message+="sign."

                argparser_translate "Error arg def option float" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "int" ]] \
                && ! argparser_is_int "${choice_value}"
            then
                # Check if the choice value is an integer.
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as choice value, which must "
                error_message+="be an integer, i.e., comprise only digits and "
                error_message+="possibly a leading sign."

                argparser_translate "Error arg def option int" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${type}" == "uint" ]] \
                && ! argparser_is_uint "${choice_value}"
            then
                # Check if the choice value is an unsigned integer.
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as choice value, which must "
                error_message+="be an unsigned integer, i.e., comprise only "
                error_message+="digits and no sign."

                argparser_translate "Error arg def option uint" \
                    "${error_message}" "${arg_key}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done

        # Check the notes.
        for note in "${notes[@]}"; do
            if [[ -n "${note}" && "${note}" != "deprecated" ]]; then
                error_message="Error: The option with the identifier \"\$1\" "
                error_message+="has \"\$2\" given as note, but only "
                error_message+="\"deprecated\" is supported."

                argparser_translate "Error arg def option note" \
                    "${error_message}" "${arg_key}" "${note}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done
    done
}

function argparser_add_args_definition_help_options() {
    # Add the help, usage, and/or version message options to the
    # arguments definition's associative arrays.
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups
    # - all_arg_numbers: the associative array holding the argument
    #   numbers
    # - all_choice_values: the associative array holding the choice
    #   values
    # - all_default_values: the associative array holding the default
    #   values
    # - all_help_texts: the associative array holding the help texts
    # - all_long_options: the associative array holding the long option
    #   names
    # - all_notes: the associative array holding the notes
    # - all_resolved_choice_values: the associative array holding the
    #   resolved (range-expanded) choice values
    # - all_short_options: the associative array holding the short
    #   option names
    # - all_types: the associative array holding the argument types
    # - all_value_names: the associative array holding the value names
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_HELP_OPTIONS (read-only)
    # - ARGPARSER_USAGE_OPTIONS (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_VERSION_OPTIONS (read-only)

    # Define the local variables.
    local arg_key
    local -a arg_keys
    local -a help_texts
    local i
    local -a long_options
    local -a short_options
    local translation
    local value
    local var
    local -a vars

    # Set the definition fields for the help, usage, and version message
    # options.  Translate the strings for the help texts.
    arg_keys=(
        "help"
        "usage"
        "version"
    )
    short_options=(
        "${ARGPARSER_HELP_OPTIONS}"
        "${ARGPARSER_USAGE_OPTIONS}"
        "${ARGPARSER_VERSION_OPTIONS}"
    )
    long_options=(
        "help"
        "usage"
        "version"
    )

    help_texts=()
    argparser_translate "--help" "display this help and exit"
    help_texts+=("${translation}")

    argparser_translate "--usage" "display the usage and exit"
    help_texts+=("${translation}")

    argparser_translate "--version" "display the version and exit"
    help_texts+=("${translation}")

    # If requested, add the help, usage, and version message options to
    # the arguments definition's associative arrays.
    vars=(
        ARGPARSER_ADD_HELP
        ARGPARSER_ADD_USAGE
        ARGPARSER_ADD_VERSION
    )
    for i in "${!vars[@]}"; do
        var="${vars[i]}"
        value="${!var}"
        if [[ "${value}" == true ]]; then
            arg_key="${arg_keys[i]}"

            if [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]
            then
                all_short_options[${arg_key}]="${short_options[i]}"
                all_long_options[${arg_key}]="${long_options[i]}"
            elif [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]; then
                all_short_options[${arg_key}]="${short_options[i]}"
                all_long_options[${arg_key}]=""
            elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true ]]; then
                all_short_options[${arg_key}]=""
                all_long_options[${arg_key}]="${long_options[i]}"
            fi

            all_value_names[${arg_key}]=""
            all_default_values[${arg_key}]="false"
            all_choice_values[${arg_key}]=""
            all_resolved_choice_values[${arg_key}]=""
            all_types[${arg_key}]="bool"
            all_arg_numbers[${arg_key}]="0"
            all_arg_groups[${arg_key}]="${ARGPARSER_HELP_ARG_GROUP}"
            all_notes[${arg_key}]=""
            all_help_texts[${arg_key}]="${help_texts[i]}"
        fi
    done
}

# Define the Argparser functions for the argument parsing.
function argparser_get_arg_key() {
    # Get the argument identifier (key) for a given short or long option
    # name.
    #
    # Arguments:
    # - $1: whether the option is expected to be a short or long option
    #   ("short" or "long")
    # - $2: the option name
    #
    # Nonlocals:
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - arg_key: the argument identifier, if the key exists, or the
    #   empty string, else (when the option name is erroneous)
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local long_option
    local -a long_options
    local mode
    local option_name
    local short_option
    local -a short_options

    # Read the arguments.
    mode="$1"
    option_name="$2"

    # Get the argument identifier.
    if [[ "${mode}" == "short" ]]; then
        for arg_key in "${!all_short_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
                <<< "${all_short_options[${arg_key}]}"

            # Ignore arguments without a short option name.
            if [[ -z "${short_options[0]}" ]]; then
                continue
            fi

            # Check the short options.
            for short_option in "${short_options[@]}"; do
                if [[ "${option_name}" == "${short_option}" ]]; then
                    return
                fi
            done
        done
    else
        for arg_key in "${!all_long_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                <<< "${all_long_options[${arg_key}]}"

            # Ignore arguments without a long option name.
            if [[ -z "${long_options[0]}" ]]; then
                continue
            fi

            # Check the long options.
            for long_option in "${long_options[@]}"; do
                if [[ "${option_name}" == "${long_option}" ]]; then
                    return
                fi
            done
        done
    fi

    arg_key=""
}

function argparser_get_option_names() {
    # Concatenate the name of all short and long options.
    #
    # Arguments:
    # - $1: the argument's name (key)
    # - $2: the order of the options ("short-long", "long-short",
    #       "short", or "long")
    # - $3: whether to colorize the option names by argparser_colorize
    #
    # Nonlocals:
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - all_value_names: the associative array holding the value names
    #   (read-only)
    # - option_names: the name of all short and long options as
    #   ${ARGPARSER_ARG_DELIMITER_2}-separated string
    # - styles: the associative array containing the styles (read-only)
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_key
    local colorize
    local -a colorized_array
    local joined_array
    local long_option_names
    local -a long_options
    local order
    local short_option_names
    local -a short_options
    local value_names

    # Read the arguments.
    arg_key="$1"
    order="$2"
    colorize="$3"

    # Read the argument's definition.  As positional arguments aren't
    # included in ${all_short_options} and ${all_long_options}, assign
    # them the default value of the empty string, indicating absence.
    # For the option name below, use the value name, of which positional
    # arguments can only have one (thus using a string, not an array).
    if [[ -n "${all_short_options[${arg_key}]+set}" ]]; then
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
            <<< "${all_short_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
            <<< "${all_long_options[${arg_key}]}"
    else
        short_options=("")
        long_options=("")
    fi
    value_names="${all_value_names[${arg_key}]}"

    # Concatenate the names of all short and long options, including the
    # leading hyphen(s).  Possibly, colorize them, including the value
    # names.
    if [[ "${colorize}" == true ]]; then
        argparser_colorize "${styles["short_options"]}" 1 "array" \
            "${short_options[@]/#/-}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        short_option_names="${joined_array}"

        argparser_colorize "${styles["long_options"]}" 1 "array" \
            "${long_options[@]/#/--}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        long_option_names="${joined_array}"

        argparser_colorize "${styles["value_names"]}" 1 value_names \
            "${value_names}"
    else
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${short_options[@]/#/-}"
        short_option_names="${joined_array}"

        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${long_options[@]/#/--}"
        long_option_names="${joined_array}"
    fi

    # Merge the names of all short and long options, if any is given, or
    # use the value names as fallback.
    if [[ -n "${short_options[0]}" && -n "${long_options[0]}" ]]; then
        if [[ "${order}" == "short-long" ]]; then
            option_names="${short_option_names}${ARGPARSER_ARG_DELIMITER_2}"
            option_names+="${long_option_names}"
        elif [[ "${order}" == "long-short" ]]; then
            option_names="${long_option_names}${ARGPARSER_ARG_DELIMITER_2}"
            option_names+="${short_option_names}"
        elif [[ "${order}" == "short" ]]; then
            option_names="${short_option_names}"
        elif [[ "${order}" == "long" ]]; then
            option_names="${long_option_names}"
        fi
    elif [[ -n "${short_options[0]}" ]]; then
        option_names="${short_option_names}"
    elif [[ -n "${long_options[0]}" ]]; then
        option_names="${long_option_names}"
    else
        option_names="${value_names}"
    fi
}

function argparser_parse_arg() {
    # Parse an argument given to the script.
    #
    # Arguments:
    # - $1: the argument to parse
    #
    # Nonlocals:
    # - is_positional_only: whether the positional arguments delimiter
    #   "--" has already been set and has not been unset by "++"
    #   (read-only)
    # - is_self_parsing: whether the Argparser currently parses its own
    #   arguments (read-only)
    # - messages: the parsed argument as message or an error message,
    #   starting with "Help", "Usage", "Version", "Logo",
    #   "Positional_Start", "Positional_End", "Error: " (translated),
    #   "Argument: ", "Prefix: ", or "Value: ", as indexed array
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_ALLOW_FLAG_INVERSION (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)

    # Define the local variables.
    local error_message
    local given_arg
    local translation

    # Read the argument.
    given_arg="$1"

    # Output the argument, split into option names and values, or an
    # error message.  In the latter case, output also the given
    # argument, such that values following the unknown argument are
    # assigned to this argument, not the last known one that got parsed.
    if [[ "${given_arg}" != "++"* \
        && ("${given_arg}" != [-+]* || "${is_positional_only}" == true) ]]
    then
        # The argument doesn't start with a hyphen ("-") or plus sign
        # ("+"), so deem it a value to a previous keyword argument or a
        # positional argument.  Likewise, if the positional arguments
        # delimiter "--" has already been set and has neither been unset
        # by "++" nor the current argument is this "++", then deem any
        # value a positional argument.
        messages+=("Value: ${given_arg}")
    elif [[ "${given_arg}" == "--" ]]; then
        # The argument is the positional arguments delimiter "--".
        messages+=("Positional_Start")
    elif [[ "${given_arg}" == "--="* ]]; then
        # The argument is the positional arguments delimiter "--", but
        # followed by an illegal equals sign ("=").
        error_message="Error: The special option \"--\" takes no value."
        argparser_translate "Error arg double hyphen" "${error_message}"
        error_message="${translation}"
        messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    elif [[ "${given_arg}" == "++" ]]; then
        # The argument is the positional arguments delimiter "++".
        messages+=("Positional_End")
    elif [[ "${given_arg}" == "++="* ]]; then
        # The argument is the positional arguments delimiter "++", but
        # followed by an illegal equals sign ("=").
        error_message="Error: The special option \"++\" takes no value."
        argparser_translate "Error arg double plus" "${error_message}"
        error_message="${translation}"
        messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    elif [[ "${given_arg}" == "--argparser" && "${is_self_parsing}" == true ]]
    then
        # The argument is the magic string for the Argparser, which was
        # directly called and not run from another script.  Since the
        # Argparser accepts only long options by design, no test for
        # ${ARGPARSER_USE_LONG_OPTIONS} is necessary.
        messages+=("Logo")
    elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true \
        && ("${given_arg::2}" == "--" \
            || ("${ARGPARSER_ALLOW_FLAG_INVERSION}" == true \
                && "${given_arg::2}" == "++")) ]]
    then
        # The argument is a long option, with a double hyphen or an
        # activated doubled plus sign as prefix, so check whether the
        # given argument is defined.
        argparser_parse_long_option "${given_arg}"
    elif [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true \
        && ("${given_arg::2}" == -[!-+] \
            || ("${ARGPARSER_ALLOW_FLAG_INVERSION}" == true \
                && "${given_arg::2}" == +[!-+])) ]]
    then
        # The argument is a short option, so check whether the given
        # argument is defined.
        argparser_parse_short_option "${given_arg}"
    elif [[ "${given_arg::2}" == +[!-] ]]; then
        # The argument is given with a deactivated plus sign (possibly
        # doubled) as prefix.
        error_message="Error: Inverting flags with a \"+\" prefix is "
        error_message+="deactivated."
        argparser_translate "Error arg inversion" "${error_message}"
        error_message="${translation}"
        messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    else
        # The argument hasn't been matched by any condition, so deem it
        # unknown.  This is true if the prefix is neither "--", "++", a
        # single "-" nor a single "+", but e.g. "+-" or "-+".  This is
        # also true if the argument is a short option, but only long
        # options shall be accepted, or vice versa.
        error_message="Error: The argument \"\$1\" is unknown."
        argparser_translate "Error arg unknown" "${error_message}" \
            "${given_arg%%=*}"
        error_message="${translation}"
        messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    fi
}

function argparser_parse_long_option() {
    # Parse a long-option argument given to the script.
    #
    # Arguments:
    # - $1: the argument to parse
    #
    # Nonlocals:
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - messages: the parsed argument as message or an error message,
    #   starting with "Error: " (translated), "Argument: ", "Prefix: ",
    #   or "Value: ", as indexed array
    #
    # Environment:
    # - ARGPARSER_ALLOW_FLAG_NEGATION (read-only)
    # - ARGPARSER_ALLOW_OPTION_ABBREVIATION (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local abbr_long_option
    local -a abbr_long_options
    local actual_prefix
    local arg_key
    local count
    local error_message
    local given_arg
    local is_negated
    local long_option
    local -a long_options
    local option_name
    local prefix
    local translation
    local value
    local -a values

    # Read the argument.
    given_arg="$1"

    # Get the prefix, option name, and possibly values for the given
    # argument.
    prefix="${given_arg::1}"
    option_name="${given_arg:2}"
    if [[ "${given_arg}" == *=* ]]; then
        option_name="${option_name%%=*}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values \
            <<< "${given_arg#*=}"
    else
        values=("")
    fi
    argparser_get_arg_key "long" "${option_name}"

    # If no argument identifier for the entire option name has been
    # found, the option name starts with "no-", and flag negation is
    # enabled, trim the "no-" prefix, convert it to a "+", and set the
    # option name's remainder as new option name.
    if [[ "${ARGPARSER_ALLOW_FLAG_NEGATION}" == true \
        && -z "${arg_key}" \
        && "${option_name::3}" == "no-" ]]
    then
        is_negated=true
        option_name="${option_name:3}"
        argparser_get_arg_key "long" "${option_name}"

        actual_prefix="${prefix}"
        if [[ "${prefix}" == "-" ]]; then
            prefix="+"
        else
            prefix="-"
        fi
    fi

    # Output the argument, split into the option name and values, or an
    # error message.  In the latter case, output also the given
    # argument, such that values following the unknown argument are
    # assigned to this argument, not the last known one that got parsed.
    if [[ "${ARGPARSER_ALLOW_OPTION_ABBREVIATION}" == true \
        && -z "${arg_key}" ]]
    then
        # Check if the argument is an abbreviated long option, since no
        # argument identifier for the entire option name has been found.
        abbr_long_options=( )
        for arg_key in "${!all_long_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                <<< "${all_long_options[${arg_key}]}"

            # Abbreviate the long option names by shortening them to the
            # length of the given option name and add them to the
            # indexed array.  Ignore arguments without long option name.
            for long_option in "${long_options[@]}"; do
                if [[ -n "${long_option}" ]]; then
                    abbr_long_options+=("${long_option::${#option_name}}")
                fi
            done
        done

        # Count the number of matches of the argument among the
        # abbreviated long option names. If it matches once, output the
        # argument identifier and possibly the values following the
        # equals sign ("=").  If multiple or no option names are
        # matched, output an error message, instead.
        argparser_count "${option_name}" "${abbr_long_options[@]}"
        if (( count == 1 )); then
            # Get the argument identifier for the abbreviated argument.
            for arg_key in "${!all_long_options[@]}"; do
                # Read the argument's definition.
                IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                    <<< "${all_long_options[${arg_key}]}"

                # Abbreviate the long option names by shortening them to
                # the length of the given option name.  Ignore arguments
                # without long option name.  As soon as the abbreviated
                # option name matches the given one, the argument
                # identifier has been found, so break both loops.
                for long_option in "${long_options[@]}"; do
                    if [[ -z "${long_option}" ]]; then
                        continue
                    fi

                    abbr_long_option="${long_option::${#option_name}}"
                    if [[ "${option_name}" == "${abbr_long_option}"* ]]; then
                        break 2
                    fi
                done
            done

            if [[ -n "${values[0]}" ]]; then
                # Output the argument identifier, the prefix, and the
                # values.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
            fi
        elif (( count > 1 )); then
            # Since multiple option names have been found in the
            # definition, output an error message and the argument.
            error_message="Error: The long option \"\$1\" matches multiple "
            error_message+="long options."

            argparser_translate "Error long option match" "${error_message}" \
                "${given_arg%%=*}"
            error_message="${translation}"
            messages+=("${error_message}")
            messages+=("Argument: ${given_arg}")
        else
            # Since the argument hasn't been found in the definition,
            # output an error message and the argument.
            if [[ "${is_negated}" == true ]]; then
                error_message="Error: The long option \"\$1\" is negated, but "
                error_message+="its affirmative version \"\$2\" is unknown."
                argparser_translate "Error long option negation" \
                    "${error_message}" "${given_arg%%=*}" \
                    "${actual_prefix}${actual_prefix}${option_name}"
                error_message="${translation}"
                messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
            else
                error_message="Error: The long option \"\$1\" is unknown."
                argparser_translate "Error long option unknown" \
                    "${error_message}" "${given_arg%%=*}"
                error_message="${translation}"
                messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
            fi
        fi
    else
        if [[ -n "${arg_key}" ]]; then
            if [[ -n "${values[0]}" ]]; then
                # Output the argument identifier, the prefix, and the
                # values.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
            fi
        else
            # Since the argument hasn't been found in the definition,
            # output an error message and the argument.
            if [[ "${is_negated}" == true ]]; then
                error_message="Error: The long option \"\$1\" is negated, but "
                error_message+="its affirmative version \"\$2\" is unknown."
                argparser_translate "Error long option negation" \
                    "${error_message}" "${given_arg%%=*}" \
                    "${actual_prefix}${actual_prefix}${option_name}"
                error_message="${translation}"
                messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
            else
                error_message="Error: The long option \"\$1\" is unknown."
                argparser_translate "Error long option unknown" \
                    "${error_message}" "${given_arg%%=*}"
                error_message="${translation}"
                messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
            fi
        fi
    fi
}

function argparser_parse_short_option() {
    # Parse a short-option argument given to the script.
    #
    # Arguments:
    # - $1: the argument to parse
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - messages: the parsed argument as message or an error message,
    #   starting with "Error: " (translated), "Argument: ", "Prefix: ",
    #   or "Value: ", as indexed array
    #
    # Environment:
    # - ARGPARSER_ALLOW_OPTION_MERGING (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local char
    local error_message
    local given_arg
    local i
    local option_name
    local prefix
    local translation
    local value
    local -a values

    # Read the argument.
    given_arg="$1"

    # Get the prefix, option name, and possibly values for the given
    # argument.
    prefix="${given_arg::1}"
    option_name="${given_arg:1}"
    if [[ "${given_arg}" == *=* ]]; then
        option_name="${option_name%%=*}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values \
            <<< "${given_arg#*=}"
    else
        values=("")
    fi
    argparser_get_arg_key "short" "${option_name}"

    # Get the argument identifier for the given (and perhaps merged)
    # argument and output it, possibly along with the values following
    # the equals sign ("=").
    if [[ "${ARGPARSER_ALLOW_OPTION_MERGING}" == true ]]; then
        # Split the combined short option name, which may end in a
        # merged value, after any character.
        for (( i = 0; i < "${#option_name}"; i++ )); do
            char="${option_name:i:1}"
            argparser_get_arg_key "short" "${char}"
            if [[ -z "${arg_key}" ]]; then
                # Since the argument hasn't been found in the
                # definition, output an error message and the argument.
                error_message="Error: The short option \"\$1\$2\" is unknown."
                argparser_translate "Error short option merge" \
                    "${error_message}" "${prefix}" "${char}"
                error_message="${translation}"
                messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
                return
            fi

            # Output the argument identifier and the prefix for the
            # short option name character.
            messages+=("Argument: ${arg_key}")
            messages+=("Prefix: ${prefix}")

            # Get the number of required arguments to judge whether the
            # following character is an argument to the current option
            # or another option (i.e., the current option is a flag).
            # If there is no following character, the value must have
            # been given as next whitespace-delimited argument, thus
            # don't output anything.
            arg_number="${all_arg_numbers[${arg_key}]}"
            if [[ "${arg_number}" != 0 ]] && (( i < "${#option_name}" - 1 ))
            then
                # Output the value, which is the argument's rest.
                messages+=("Value: ${option_name:i+1}")
                return
            fi
        done

        if [[ -n "${values[0]}" ]]; then
            # Output the values, which are given after an equals sign
            # ("=").
            for value in "${values[@]}"; do
                messages+=("Value: ${value}")
            done
        fi
    else
        if [[ -n "${arg_key}" ]]; then
            if [[ -n "${values[0]}" ]]; then
                # Output the argument identifier, the prefix, and the
                # values.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_key}")
                messages+=("Prefix: ${prefix}")
            fi
        else
            # Since the argument hasn't been found in the definition,
            # output an error message and the argument.
            error_message="Error: The short option \"\$1\" is unknown."
            argparser_translate "Error short option unknown" \
                "${error_message}" "${given_arg%%=*}"
            error_message="${translation}"
            messages+=("${error_message}")
            messages+=("Argument: ${given_arg}")
        fi
    fi
}

function argparser_parse_positional_args() {
    # Parse all positional arguments given to the script.
    #
    # Arguments:
    # - $@: the arguments to parse
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - messages: the parsed argument as message or an error message,
    #   starting with "Error: " (translated), "Argument: ", or
    #   "Value: ", as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local args_count
    local default_args_count
    local -a default_values_arr
    local default_values_str
    local error_message
    local given_arg
    local -a given_args
    local i
    local index
    local required_args_count
    local translation
    local -a values

    # Read the arguments and split the values on
    # ${ARGPARSER_ARG_DELIMITER_2} characters.
    values=( )
    for given_arg in "$@"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a given_args \
            <<< "${given_arg}"
        values+=("${given_args[@]}")
    done

    # Count the defined positional arguments with default values and
    # those without.
    default_args_count=0
    required_args_count=0
    for arg_key in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # For the counting, consider the number of values for "+" as 1
        # and for "*" or "?" as 0, i.e., the minimum number that can be
        # given in each case.
        if [[ "${arg_number}" == "+" ]]; then
            arg_number=1
        elif [[ "${arg_number}" == "*" || "${arg_number}" == "?" ]]; then
            arg_number=0
        fi

        # Increment the respective count.
        if [[ -z "${default_values_str}" ]]; then
            (( required_args_count += arg_number ))
        else
            (( default_args_count += arg_number ))
        fi
    done

    # Based on the number of given, default, and required positional
    # arguments, judge whether values for arguments with default values
    # are given.  Since there cannot be arguments with an arbitrary
    # number of values defined when there are arguments with default
    # values defined, a higher number of given values than required
    # means that either some values for arguments with default values
    # are given (then, their count exceeds zero), or that an argument
    # accepting an arbitrary number of values is given as last one
    # (then, the count of arguments with default values is zero).  This
    # allows to distinguish these two cases.
    args_count="${#values[@]}"
    if (( args_count > required_args_count && default_args_count > 0 )); then
        # There are arguments having default values given.  Get the
        # argument identifiers for all given arguments and output them,
        # along with the values.
        index=0
        for arg_key in "${all_positional_args[@]}"; do
            # Read the argument's definition.
            arg_number="${all_arg_numbers[${arg_key}]}"

            # Output as many given arguments as requested.
            messages+=("Argument: ${arg_key}")
            for (( i = index; i < arg_number + index && i < args_count; i++ ))
            do
                messages+=("Value: ${values[i]}")
            done
            (( index += arg_number ))
        done
    else
        # There are no arguments having default values given.  Get the
        # argument identifiers for all given arguments and output them,
        # along with the values.
        index=0
        for arg_key in "${all_positional_args[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
                <<< "${all_default_values[${arg_key}]}"
            arg_number="${all_arg_numbers[${arg_key}]}"

            # Skip the defined arguments having default values, but
            # which aren't given.
            if [[ -n "${default_values_arr[0]}" ]]; then
                continue
            fi

            # If the positional argument accepts an arbitrary number of
            # values, output all remaining given arguments.  For "?",
            # output one argument, if existing, or else zero.  Else,
            # output only as many arguments as requested.
            messages+=("Argument: ${arg_key}")
            if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
                for (( i = index; i < args_count; i++ )); do
                    messages+=("Value: ${values[i]}")
                done
                index="${args_count}"

                break
            elif [[ "${arg_number}" == "?" ]]; then
                if (( index < args_count)); then
                    messages+=("Value: ${values[index]}")
                    (( index++ ))
                fi
            else
                for (( i = index; i < arg_number + index && i < args_count; \
                    i++ ))
                do
                    messages+=("Value: ${values[i]}")
                done
                (( index += arg_number ))
            fi
        done
    fi

    # If there are positional arguments remaining that haven't been
    # consumed by a defined argument, output an error message.
    if (( index < args_count )); then
        if (( index == 1 )); then
            error_message="Error: 1 positional argument is required, but \$1 "
            error_message+="are given."

            argparser_translate "Error pos arg count 1" "${error_message}" \
                "${args_count}"
            error_message="${translation}"
        else
            error_message="Error: \$1 positional arguments are required, but "
            error_message+="\$2 are given."

            argparser_translate "Error pos arg count 2" "${error_message}" \
                "${index}" "${args_count}"
            error_message="${translation}"
        fi
        messages+=("${error_message}")
    fi
}

function argparser_check_arg_values() {
    # Check if a script's argument accords to its definition.
    #
    # Arguments:
    # - $1: the argument's name (key)
    # - $2: the argument's prefixes ("-", "+", or "")
    # - $3: the argument's values
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_choice_values: the associative array holding the choice
    #   values (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_notes: the associative array holding the notes (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - all_resolved_choice_values: the associative array holding the
    #   resolved (range-expanded) choice values (read-only)
    # - all_types: the associative array holding the argument types
    #   (read-only)
    # - messages: the parsed argument as message or an error or warning
    #   message, starting with "Error: " (translated), "Warning: "
    #   (translated), or "Value: ", as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_COUNT_FLAGS (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local choice_values_str
    local count
    local count_hyphen
    local count_plus
    local default_values_str
    local error_message
    local i
    local joined_array
    local note
    local -a notes
    local option_names
    local prefix
    local -a prefixes
    local -a resolved_choice_values_arr
    local resolved_choice_values_str
    local translation
    local type
    local value
    local -a values_arr
    local values_str
    local warning_message

    # Read the arguments.  Since positional arguments have no prefix,
    # use an empty array as default value, such that testing on its
    # value is possible, below.
    arg_key="$1"
    if argparser_in_array "${arg_key}" "${all_positional_args[@]}"; then
        prefixes=( )
    else
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a prefixes <<< "$2"
    fi

    if [[ "${arg_key}" == "ARGPARSER_ARG_DELIMITER_2" ]]; then
        if [[ -n "$3" ]]; then
            values_str="$3"
            values_arr=("${values_str}")
        else
            values_str=""
            values_arr=( )
        fi

        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_key}]}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_key}]}"
        resolved_choice_values_arr=("${resolved_choice_values_str}")
        type="${all_types[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"
        notes=("${all_notes[${arg_key}]}")
    else
        values_str="$3"
        if [[ "${values_str}" == "${ARGPARSER_ARG_DELIMITER_2}" ]]; then
            # If there is no actual value for the argument, i.e., just
            # the ${ARGPARSER_ARG_DELIMITER_2} character introduced to
            # discern non-flag arguments given multiple times and partly
            # without value, remove it.  This allows non-flag-like
            # arguments given without any value not to raise the error
            # of being used as flag, but as missing a value, below.
            values_str=""
        fi
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a values_arr \
            <<< "${values_str}"

        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_key}]}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
            resolved_choice_values_arr \
                <<< "${resolved_choice_values_str}"
        type="${all_types[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_key}]}"
    fi

    # Concatenate the name of all short and long options for the error
    # and warning messages.
    argparser_get_option_names "${arg_key}" "short-long" false

    # Check the notes.
    for note in "${notes[@]}"; do
        if [[ "${note}" == "deprecated" && "${#prefixes[@]}" != 0 ]]; then
            # Only output a deprecation warning if the argument had been
            # given (and thus the prefix is non-empty), not when its
            # default value will be used.
            warning_message="Warning: The argument \"\$1\" is deprecated and "
            warning_message+="will be removed in the future."

            argparser_translate "Warning deprecation" "${warning_message}" \
                "${option_names}"
            warning_message="${translation}"
            messages+=("${warning_message}")
        fi
    done

    # If the argument is used as flag, but is none (nor can be used as
    # such), output an error message.  In this case, there are empty
    # strings among the values.
    for value in "${values_arr[@]}"; do
        if ! argparser_in_array "${arg_number}" "*" "?" 0 \
            && [[ -z "${value}" ]]
        then
            error_message="Error: The option \"\$1\" is no flag and thus "
            error_message+="needs a value after the option name."

            argparser_translate "Error arg no flag 1" "${error_message}" \
                "${option_names}"
            error_message="${translation}"
            messages+=("${error_message}")
            messages+=("${error_message}")
            return
        fi
    done

    # Remove the empty fields.  This is necessary to allow true flags to
    # be given multiple times without considering the empty field an
    # (illegal) value.
    for i in "${!values_arr[@]}"; do
        if [[ -z "${values_arr[i]}" ]]; then
            unset 'values_arr[i]'
        fi
    done

    values_arr=("${values_arr[@]}")
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${values_arr[@]}"
    values_str="${joined_array}"

    # If a "+" (or equivalent "no-") prefix is given and the argument is
    # no flag (or not used as such), output an error message.
    for prefix in "${prefixes[@]}"; do
        if [[ "${prefix}" == "-" || "${arg_number}" == 0 ]]; then
            continue
        fi

        if [[ "${arg_number}" == "*" || "${arg_number}" == "?" ]] \
            && (( "${#values_arr[@]}" > 0 ))
        then
            error_message="Error: The option \"\$1\" is not used as a flag "
            error_message+="(it has a value given) and thus cannot be given "
            error_message+="with a \"+\" or \"no-\" prefix."

            argparser_translate "Error arg no flag 2" "${error_message}" \
                "${option_names}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif ! argparser_in_array "${arg_number}" "*" "?" 0; then
            error_message="Error: The option \"\$1\" is no flag and thus "
            error_message+="cannot be given with a \"+\" or \"no-\" prefix."

            argparser_translate "Error arg no flag 3" "${error_message}" \
                "${option_names}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        fi
    done

    # Check if the correct number of values is given.  If an argument
    # hadn't been given, both its value and prefix are empty, but if it
    # was given without value, the prefix is non-empty, allowing to
    # distinguish both cases.
    if (( "${#values_arr[@]}" == 0 && "${#prefixes[@]}" == 0 )); then
        if [[ -z "${default_values_str}" ]]; then
            # The argument is not given, but must have been since it
            # doesn't have a default value.  Hence, output an error
            # message.
            error_message="Error: The argument \"\$1\" is mandatory, but not "
            error_message+="given."

            argparser_translate "Error mandatory arg" "${error_message}" \
                "${option_names}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif [[ "${ARGPARSER_COUNT_FLAGS}" == true ]] \
            && argparser_in_array "${arg_number}" "*" "?" 0
        then
            # The argument is not given, but is a flag (or may be used
            # as such) with a default value of "true" or "false".  Since
            # the flags shall be counted, set the value to 1 for "true"
            # and to -1 for "false", which are the same values as would
            # be when the flags would be given with a hyphen ("-",
            # "true") or plus sign ("+", "false").  Output the values.
            # Since the default values are used, further checking isn't
            # necessary.
            if [[ "${default_values_str}" == true ]]; then
                messages+=("Value: 1")
            else
                messages+=("Value: -1")
            fi
            return
        else
            # The argument is not given, but it has default values.
            # Hence, read and output them.  This is required for
            # optional arguments, which don't need to be set.  Since the
            # default values are used, further checking isn't necessary.
            messages+=("Value: ${default_values_str}")
            return
        fi
    elif [[ "${arg_number}" == "+" && "${#values_arr[@]}" == 0 ]]; then
        # The number of values doesn't equal the number of required
        # values, so check if some default values are given.
        if [[ -z "${default_values_str}" ]]; then
            # No default value is given, so output an error message
            # indicating the number of required and given arguments.
            error_message="Error: The argument \"\$1\" requires at least 1 "
            error_message+="value, but has \$2 given."

            argparser_translate "Error wrong arg number 1" "${error_message}" \
                "${option_names}" "${#values_arr[@]}"
            error_message="${translation}"
            messages+=("${error_message}")
        else
            # As some default values are given, print a similar warning
            # message as for the absence case, but set the values to the
            # default values and output them.  Since the default values
            # are used, further checking isn't necessary.
            warning_message="Warning: The argument \"\$1\" requires at least "
            warning_message+="1 value, but has \$2 given.  For convenience, "
            warning_message+="the default (\$3) is used."

            argparser_translate "Warning wrong arg number 1" \
                "${warning_message}" "${option_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            messages+=("${warning_message}")

            messages+=("Value: ${default_values_str}")
            return
        fi
    elif [[ "${arg_number}" == "?" ]] && (( "${#values_arr[@]}" > 1 )); then
        # The number of values doesn't equal the number of required
        # values, so check if some default values are given.
        if [[ -z "${default_values_str}" ]]; then
            # No default value is given, so output an error message
            # indicating the number of required and given arguments.
            error_message="Error: The argument \"\$1\" requires 0 or 1 value, "
            error_message+="but has \$2 given."

            argparser_translate "Error wrong arg number 2" \
                "${error_message}" "${option_names}" "${#values_arr[@]}"
            error_message="${translation}"
            messages+=("${error_message}")
        else
            # As some default values are given, print a similar warning
            # message as for the absence case, but set the values to the
            # default values and output them.  Since the default values
            # are used, further checking isn't necessary.
            warning_message="Warning: The argument \"\$1\" requires 0 or 1 "
            warning_message+="value, but has \$2 given.  For convenience, the "
            warning_message+="default (\$3) is used."

            argparser_translate "Warning wrong arg number 2" \
                "${warning_message}" "${option_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            messages+=("${warning_message}")

            messages+=("Value: ${default_values_str}")
            return
        fi
    elif [[ "${arg_number}" == 1 && "${#values_arr[@]}" != 1 ]]; then
        # The number of values doesn't equal the number of required
        # values, so check if some default values are given.
        if [[ -z "${default_values_str}" ]]; then
            # No default value is given, so output an error message
            # indicating the number of required and given arguments.
            error_message="Error: The argument \"\$1\" requires 1 value, but "
            error_message+="has \$2 given."

            argparser_translate "Error wrong arg number 3" \
                "${error_message}" "${option_names}" "${#values_arr[@]}"
            error_message="${translation}"
            messages+=("${error_message}")
        else
            # As some default values are given, print a similar warning
            # message as for the absence case, but set the values to the
            # default values and output them.  Since the default values
            # are used, further checking isn't necessary.
            warning_message="Warning: The argument \"\$1\" requires 1 value, "
            warning_message+="but has \$2 given.  For convenience, the "
            warning_message+="default (\$3) is used."

            argparser_translate "Warning wrong arg number 3" \
                "${warning_message}" "${option_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            messages+=("${warning_message}")

            messages+=("Value: ${default_values_str}")
            return
        fi
    elif argparser_in_array "${arg_number}" "*" "?" 0 \
        && [[ ! -v values_arr || -z "${values_arr[0]}" ]]
    then
        # No value is required nor given, so the argument is a flag.  As
        # it is set (present), set the value to "true" for a "-" prefix
        # and to "false" for a "+" prefix.  Thereby, the last given
        # prefix determines the value, implicitly overriding any prefix
        # given before.  Alternatively, count the number of "-" and "+"
        # prefixes, then take their difference as actual count.
        # Finally, output the values.  Since the default values are
        # used, further checking isn't necessary.
        if [[ "${ARGPARSER_COUNT_FLAGS}" == true ]]; then
            argparser_count "-" "${prefixes[@]}"
            count_hyphen="${count}"

            argparser_count "+" "${prefixes[@]}"
            count_plus="${count}"

            (( count = count_hyphen - count_plus ))
            messages+=("Value: ${count}")
        else
            if [[ "${prefixes[-1]}" == "-" ]]; then
                messages+=("Value: true")
            else
                messages+=("Value: false")
            fi
        fi
        return
    elif argparser_is_int "${arg_number}" \
        && [[ "${#values_arr[@]}" != "${arg_number}" ]]
    then
        # The number of values doesn't equal the number of required
        # values, so check if some default values are given.
        if [[ -z "${default_values_str}" ]]; then
            # No default value is given, so output an error message
            # indicating the number of required and given arguments.
            error_message="Error: The argument \"\$1\" requires \$2 values, "
            error_message+="but has \$3 given."

            argparser_translate "Error wrong arg number 4" "${error_message}" \
                "${option_names}" "${arg_number}" "${#values_arr[@]}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        else
            # As some default values are given, print a similar warning
            # message as for the absence case, but set the values to the
            # default values and output them.  Since the default values
            # are used, further checking isn't necessary.
            warning_message="Warning: The argument \"\$1\" requires \$2 "
            warning_message+="values, but has \$3 given.  For convenience, "
            warning_message+="the default (\$4) is used."

            argparser_translate "Warning wrong arg number 4" \
                "${warning_message}" "${option_names}" "${arg_number}" \
                "${#values_arr[@]}" "${default_values_str}"
            warning_message="${translation}"
            messages+=("${warning_message}")

            messages+=("Value: ${default_values_str}")
            return
        fi
    fi

    # Check if the given values accord to the choice values, i.e., if
    # each given value lies within the array of choice values.  Else,
    # output an error message.
    if [[ -n "${resolved_choice_values_str}" ]]; then
        for value in "${values_arr[@]}"; do
            if ! argparser_in_array "${value}" \
                "${resolved_choice_values_arr[@]}"
            then
                error_message="Error: The argument \"\$1\" must be in {\$2}, "
                error_message+="but is {\$3}."

                argparser_translate "Error arg choice" "${error_message}" \
                    "${option_names}" "${choice_values_str}" "${values_str}"
                error_message="${translation}"
                messages+=("${error_message}")
                return
            fi
        done
    fi

    # Check if the given values accord to the type.
    for value in "${values_arr[@]}"; do
        if [[ "${type}" == "bool" ]] && ! argparser_is_bool "${value}"; then
            # Check if the value is a Boolean.
            error_message="Error: The argument \"\$1\" is set to \"\$2\", but "
            error_message+="must be a Boolean, i.e., \"true\" or \"false\"."

            argparser_translate "Error arg bool" "${error_message}" \
                "${option_names}" "${value}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif [[ "${type}" == "char" ]] && ! argparser_is_char "${value}"; then
            # Check if the value is a character.
            error_message="Error: The argument \"\$1\" is set to \"\$2\", but "
            error_message+="must be a character, i.e., a string comprising "
            error_message+="one printable ASCII character."

            argparser_translate "Error arg char" "${error_message}" \
                "${option_names}" "${value}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif [[ "${type}" == "float" ]] && ! argparser_is_float "${value}"
        then
            # Check if the value is a floating-point number.
            error_message="Error: The argument \"\$1\" is set to \"\$2\", but "
            error_message+="must be a floating-point number, i.e., comprise "
            error_message+="only digits, a dot, and possibly a leading sign."

            argparser_translate "Error arg float" "${error_message}" \
                "${option_names}" "${value}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif [[ "${type}" == "int" ]] && ! argparser_is_int "${value}"; then
            # Check if the value is an integer.
            error_message="Error: The argument \"\$1\" is set to \"\$2\", but "
            error_message+="must be an integer, i.e., comprise only digits "
            error_message+="and possibly a leading sign."

            argparser_translate "Error arg int" "${error_message}" \
                "${option_names}" "${value}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        elif [[ "${type}" == "uint" ]] && ! argparser_is_uint "${value}"; then
            # Check if the value is an unsigned integer.
            error_message="Error: The argument \"\$1\" is set to \"\$2\", but "
            error_message+="must be an unsigned integer, i.e., comprise only "
            error_message+="digits and no sign."

            argparser_translate "Error arg uint" "${error_message}" \
                "${option_names}" "${value}"
            error_message="${translation}"
            messages+=("${error_message}")
            return
        fi
    done

    # Output the checked values.
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${values_arr[@]}"
    messages+=("Value: ${joined_array}")
}

function argparser_parse_args() {
    # Parse the script's given arguments and check if they accord to
    # their definition.  Give proper error messages for wrongly set
    # arguments and assign the values to the respective variables.
    # Possibly, create and print a help message.
    #
    # Arguments:
    # - $@: the arguments to parse
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names
    # - all_short_options: the associative array holding the short
    #   option names
    # - is_self_parsing: whether the Argparser currently parses its own
    #   arguments (read-only)
    # - is_sourced: whether the Argparser has been sourced (read-only)
    #
    # Globals:
    # - ${ARGPARSER_ARG_ARRAY_NAME}: the parsed and checked arguments
    #   with key and value as associative array
    #
    # Environment:
    # - ARGPARSER_ALLOW_ARG_INTERMIXING (read-only)
    # - ARGPARSER_ARG_ARRAY_NAME
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_CHECK_ARG_DEF (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_SILENCE_ERRORS (read-only)

    # Define the local variables.  If the variable that
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to is undefined, all variables
    # prefixed with "arg" are searched, later.  In order to not shadow
    # them by local variables, all locals starting with "arg" are
    # defined later.
    local -a arg_prefixes
    local error_message
    local -a error_messages
    local given_arg
    local -a given_args
    local -a given_positional_args
    local is_help
    local is_logo
    local is_positional
    local is_positional_only
    local is_usage
    local is_version
    local message
    local -a messages
    local name
    local names
    local prefix
    local -A prefixes
    local translated_error
    local translated_warning
    local translation
    local value
    local values
    local -a warning_messages

    # Read the arguments.
    given_args=("$@")

    # If the Argparser is run as standalone script and not sourced, read
    # the arguments definition from STDIN into ${args} and remove
    # leading blank lines.  If STDIN is empty, output an error message.
    # If the Argparser is sourced, check if the variable that
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to is defined.  If not, guess
    # how it may be called by searching the set variables for a variable
    # name starting with "arg" to give a clearer error message.  If no
    # such variable name is found, skip that part of the message.
    if [[ "${is_sourced}" == false && "${is_self_parsing}" == false ]]; then
        ARGPARSER_ARG_ARRAY_NAME="args"
        local -a args
        if read -t 0 -u 0; then
            IFS=$'\n' read -r -d "" -t 0.1 -u 0 -a args

            # shellcheck disable=SC2190  # Indexed, not associative array.
            while (( "${#args[@]}" > 0 )) && [[ -z "${args[0]}" ]]; do
                args=("${args[@]:1}")
            done

            if (( "${#args[@]}" == 0 )); then
                error_message="Error: Calling (instead of sourcing) the "
                error_message+="Argparser requires the arguments definition "
                error_message+="to be provided through STDIN, separated by "
                error_message+="newlines.  Either pipe to the Argparser or "
                error_message+="use process substitution to give input.  "
                error_message+="Alternatively, try \"\$1 --help\" to get a "
                error_message+="help message with further information."

                argparser_translate "Error arg array 1" "${error_message}" \
                    "${ARGPARSER_SCRIPT_NAME}"
                error_message="${translation}"

                argparser_print_error_messages false true "${error_message}"
            fi
        else
            error_message="Error: Calling (instead of sourcing) the Argparser "
            error_message+="requires the arguments definition to be provided "
            error_message+="through STDIN, separated by newlines.  Either "
            error_message+="pipe to the Argparser or use process substitution "
            error_message+="to give input.  Alternatively, try \"\$1 --help\" "
            error_message+="to get a help message with further information."

            argparser_translate "Error arg array 1" "${error_message}" \
                "${ARGPARSER_SCRIPT_NAME}"
            error_message="${translation}"

            argparser_print_error_messages false true "${error_message}"
        fi
    elif [[ ! -v "${ARGPARSER_ARG_ARRAY_NAME}" ]]; then
        mapfile -t names < <(compgen -v)
        for name in "${names[@]}"; do
            if [[ "${name}" == "arg"* ]]; then
                name="${name%%=*}"
                break
            else
                name=""
            fi
        done

        if [[ -n "${name}" ]]; then
            error_message="Error: The variable ARGPARSER_ARG_ARRAY_NAME "
            error_message+="refers to \"\$1\", but this variable is not "
            error_message+="defined.  Either you have given your arguments "
            error_message+="array another name (maybe \"\$2\" -- then change "
            error_message+="ARGPARSER_ARG_ARRAY_NAME accordingly) or you "
            error_message+="forgot defining the array at all (then define it)."

            argparser_translate "Error arg array 2" "${error_message}" \
                "${ARGPARSER_ARG_ARRAY_NAME}"
            error_message="${translation}"
        else
            error_message="Error: The variable ARGPARSER_ARG_ARRAY_NAME "
            error_message+="refers to \"\$1\", but this variable is not "
            error_message+="defined.  Either you have given your arguments "
            error_message+="array another name (then change "
            error_message+="ARGPARSER_ARG_ARRAY_NAME accordingly) or you "
            error_message+="forgot defining the array at all (then define it)."

            argparser_translate "Error arg array 3" "${error_message}" \
                "${ARGPARSER_ARG_ARRAY_NAME}"
            error_message="${translation}"
        fi

        argparser_print_error_messages false true "${error_message}"
    fi

    # Define the remaining local variables that start with "arg".
    local arg_key
    local arg_number
    local -A arg_numbers
    local -a args_definition_file
    local -a args_definition_script

    # Read in the requested arguments.  ${ARGPARSER_ARG_ARRAY_NAME} is
    # set to the name of the indexed array holding the arguments in the
    # script.  If it is already "args" (the default name), nothing needs
    # to be done, but other variable names need to be mapped to "args"
    # to be able to refer to the variable by name.  Thus, declare prints
    # the array contents stored in the variable
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to, which then gets stripped
    # from the leading assignment (before the equals sign ("=")) and set
    # to the new indexed array ${args}.  Since later, the variable
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to is assigned an associative
    # array, while being an indexed array, unset it.
    if [[ "${ARGPARSER_ARG_ARRAY_NAME}" != "args" ]]; then
        local args
        args="$(declare -p "${ARGPARSER_ARG_ARRAY_NAME}")"
        local -a args="${args#*=}"

        unset "${ARGPARSER_ARG_ARRAY_NAME}"
    fi

    # Read the arguments definition.
    args_definition_file=( )
    args_definition_script=( )
    error_messages=( )

    argparser_translate "Error" "Error"
    translated_error="${translation}"

    argparser_translate "Warning" "Warning"
    translated_warning="${translation}"

    messages=( )
    argparser_read_args_definition "${args[@]}"
    for message in "${messages[@]}"; do
        # Append the arguments definition to those for the file or
        # script, respectively.
        case "${message}" in
            File*) args_definition_file+=("${message#File: }") ;;
            Script*) args_definition_script+=("${message#Script: }") ;;
            ${translated_error}*)
                error_messages+=("${message}")
            ;;
        esac
    done

    # If there are error messages, sort, colorize, and print them, then
    # exit, as parsing the arguments definition with missing parts is
    # useless.
    argparser_print_error_messages false true "${error_messages[@]}"

    # Parse the arguments definition.
    all_positional_args=( )
    if (( "${#args_definition_file[@]}" > 0 )); then
        argparser_parse_args_definition "file" "${args_definition_file[@]}"
    fi
    if (( "${#args_definition_script[@]}" > 0 )); then
        argparser_parse_args_definition "script" "${args_definition_script[@]}"
    fi

    # If ${ARGPARSER_CHECK_ARG_DEF} is set to "true", check the
    # consistency of the arguments definition.
    error_messages=( )
    if [[ "${ARGPARSER_CHECK_ARG_DEF}" == true ]]; then
        # Check the arguments definition, first the short and long
        # option names, then the default and choice values.
        argparser_check_args_definition_names
        argparser_check_args_definition_positional_values
        argparser_check_args_definition_option_values

        # If there are error messages, sort, filter, colorize, and print
        # them, then exit, as parsing the arguments with a faulty
        # definition is useless or even impossible.
        argparser_print_error_messages true true "${error_messages[@]}"
    fi

    # Possibly, add the help, usage, and version message options to the
    # arguments definition.
    argparser_add_args_definition_help_options

    # Parse the script's given arguments.
    is_logo=false
    is_positional=true
    is_positional_only=false
    error_messages=( )

    unset args
    local -A args

    for given_arg in "${given_args[@]}"; do
        # Parse the argument.
        messages=( )
        argparser_parse_arg "${given_arg}"

        # Read the output message and either set the help, usage, or
        # version message for printing and stop parsing, append the
        # message to the previous error messages or set the argument's
        # value or prefix. In case of arguments given multiple times,
        # i.e., when the key already exists in ${!args[@]}, add the new
        # value or prefix to the previously given ones.
        for message in "${messages[@]}"; do
            case "${message}" in
                ${translated_error}*) error_messages+=("${message}") ;;
                Positional_Start)
                    # Set the flag that the positional-only arguments
                    # delimiter "--" has been set, such that all
                    # following arguments are interpreted as positional.
                    is_positional=true
                    is_positional_only=true
                    ;;
                Positional_End)
                    # Set the flag that the positional-only arguments
                    # delimiter "++" has been set (and thus "--" has
                    # been unset), such that all following arguments are
                    # interpreted as usual.
                    is_positional=true
                    is_positional_only=false
                    ;;
                Argument*)
                    # Set the current argument name, and the first value
                    # to the empty string (by ending it with an
                    # ${ARGPARSER_ARG_DELIMITER_2} character).  This
                    # allows for discerning non-flag arguments given
                    # multiple times, but partly without value.
                    is_positional=false
                    arg_key="${message#Argument: }"
                    if [[ -z "${args[${arg_key}]+set}" ]]; then
                        args[${arg_key}]="${ARGPARSER_ARG_DELIMITER_2}"
                    else
                        args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                    fi
                    arg_numbers[${arg_key}]=0
                    ;;
                Prefix*)
                    # Set the current argument's prefix ("-" or "+").
                    prefix="${message#Prefix: }"
                    if [[ -z "${prefixes[${arg_key}]+set}" ]]; then
                        prefixes[${arg_key}]="${prefix}"
                    else
                        prefixes[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        prefixes[${arg_key}]+="${prefix}"
                    fi
                    ;;
                Value*)
                    # Set the current argument's value.  For values to
                    # keyword arguments, merge the value with the
                    # previous empty string value, iff the previous
                    # value is indeed empty.
                    value="${message#Value: }"
                    if [[ "${is_positional}" == true ]]; then
                        # The value is given in a positional-only
                        # location.
                        given_positional_args+=("${value}")
                    elif [[ "${ARGPARSER_ALLOW_ARG_INTERMIXING}" == true ]]
                    then
                        # The value may be either a value to the
                        # previous keyword argument or a positional
                        # argument.  Treat it as positional argument
                        # only if the previous keyword argument has
                        # already taken as many values as required.  For
                        # numerical argument counts, this is directly
                        # this count, for [0, 1] values, this is true
                        # when there is already 1 value, and for
                        # [1, inf) and [0, inf) values, this is never
                        # true since all values shall be taken.  Then,
                        # and in all other cases, treat the value as
                        # value for the previous keyword argument.
                        arg_number="${all_arg_numbers[${arg_key}]}"
                        if [[ "${arg_numbers[${arg_key}]}" == 1 \
                            && "${arg_number}" == "?" ]]
                        then
                            # The value is a positional argument.
                            given_positional_args+=("${value}")
                        elif [[ "${arg_numbers[${arg_key}]}" == "${arg_number}" \
                            && "${arg_number}" != "+" \
                            && "${arg_number}" != "*" ]]
                        then
                            # The value is a positional argument.
                            given_positional_args+=("${value}")
                        elif [[ "${args[${arg_key}]}" \
                            == "${ARGPARSER_ARG_DELIMITER_2}" ]]
                        then
                            # The value is the first value to the
                            # current keyword argument.
                            args[${arg_key}]="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                            (( arg_numbers[${arg_key}]++ ))
                        elif (( "${#args[${arg_key}]}" >= 2 )) \
                            && [[ "${args[${arg_key}]: -2}" \
                                == "${ARGPARSER_ARG_DELIMITER_2}${ARGPARSER_ARG_DELIMITER_2}" ]]
                        then
                            # The value is not the first one, but the
                            # previous argument was one of the current
                            # keyword argument's option names, which
                            # added an empty string needing to be
                            # merged.
                            args[${arg_key}]="${args[${arg_key}]::-1}"
                            args[${arg_key}]+="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                            (( arg_numbers[${arg_key}]++ ))
                        else
                            # The value is at least on the second place
                            # after one of the current keyword
                            # argument's option names.
                            args[${arg_key}]+="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                            (( arg_numbers[${arg_key}]++ ))
                        fi
                    else
                        if [[ "${args[${arg_key}]}" \
                            == "${ARGPARSER_ARG_DELIMITER_2}" ]]
                        then
                            # The value is the first value to the
                            # current keyword argument.
                            args[${arg_key}]="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        elif (( "${#args[${arg_key}]}" >= 2 )) \
                            && [[ "${args[${arg_key}]: -2}" \
                                == "${ARGPARSER_ARG_DELIMITER_2}${ARGPARSER_ARG_DELIMITER_2}" ]]
                        then
                            # The value is not the first one, but the
                            # previous argument was one of the current
                            # keyword argument's option names, which
                            # added an empty string needing to be
                            # merged.
                            args[${arg_key}]="${args[${arg_key}]::-1}"
                            args[${arg_key}]+="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        else
                            # The value is at least on the second place
                            # after one of the current keyword
                            # argument's option names.
                            args[${arg_key}]+="${value}"
                            args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        fi
                        (( arg_numbers[${arg_key}]++ ))
                    fi
                    ;;
                Logo) is_logo=true ;;
            esac
        done
    done

    # If the help, usage, or version message, or the logo was requested
    # (in this order of priority), print it.  To this end, check whether
    # the respective argument identifier (except for the logo, which was
    # parsed earlier) is given and has a prefix of "-", since "+" should
    # deactivate it.  To respect the priority of help > usage > version,
    # use intermediate variables as flags to be assigned to "true", and
    # check their values afterwards in the intended order (while the
    # associative array ${prefixes[@]} is unordered, just as the
    # command-line arguments may be).
    is_help=false
    is_usage=false
    is_version=false
    for arg_key in "${!prefixes[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a arg_prefixes \
            <<< "${prefixes[${arg_key}]}"

        for prefix in "${arg_prefixes[@]}"; do
            if [[ "${prefix}" != "-" ]]; then
                continue
            elif [[ "${arg_key}" == "help" ]]; then
                is_help=true
            elif [[ "${arg_key}" == "usage" ]]; then
                is_usage=true
            elif [[ "${arg_key}" == "version" ]]; then
                is_version=true
            fi
        done
    done

    if [[ "${is_help}" == true ]]; then
        argparser_print_help_message true
    elif [[ "${is_usage}" == true ]]; then
        argparser_print_usage_message true
    elif [[ "${is_version}" == true ]]; then
        argparser_print_version_message true
    elif [[ "${is_logo}" == true ]]; then
        argparser_print_logo
        exit 0
    fi

    # Parse the script's given positional arguments, that are yet only
    # assigned to a single indexed array.
    messages=( )
    argparser_parse_positional_args "${given_positional_args[@]}"

    # Read the output message and either append the message to the
    # previous error messages or set the argument's value.  Again, in
    # case of arguments given multiple times, i.e., when the key already
    # exists in ${!args[@]}, add the new value to the previously given
    # ones.
    for message in "${messages[@]}"; do
        case "${message}" in
            ${translated_error}*) error_messages+=("${message}") ;;
            Argument*) arg_key="${message#Argument: }" ;;
            Value*)
                # Set the current argument's value.
                value="${message#Value: }"
                if [[ -z "${args[${arg_key}]+set}" ]]; then
                    args[${arg_key}]="${value}"
                else
                    args[${arg_key}]+="${ARGPARSER_ARG_DELIMITER_2}"
                    args[${arg_key}]+="${value}"
                fi
                ;;
        esac
    done

    # Sort, filter, colorize, and print all error messages.
    argparser_print_error_messages true false "${error_messages[@]}"

    # If any argument was not or wrongly given (i.e., there were
    # errors), print a blank line and the usage message and abort the
    # script.
    if (( "${#error_messages[@]}" > 0 )); then
        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            {
                printf '\n'
                argparser_print_usage_message false
            } >&2
        fi
        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    fi

    # Check the arguments' values.
    error_messages=( )
    warning_messages=( )
    for arg_key in "${!all_short_options[@]}" "${all_positional_args[@]}"; do
        # Check which defined argument is given to the script.  Omitted
        # arguments or those without value are assigned the empty string
        # as prefix and/or value. This is then interpreted as hint for
        # the argument's or value's absence.
        if [[ -n "${prefixes[${arg_key}]+set}" ]]; then
            prefix="${prefixes[${arg_key}]}"
        else
            prefix=""
        fi

        if [[ -n "${args[${arg_key}]+set}" ]]; then
            values="${args[${arg_key}]}"
        else
            values=""
        fi

        # Check the argument's values.
        messages=( )
        argparser_check_arg_values "${arg_key}" "${prefix}" "${values}"

        # Read the output message and either append the message to the
        # previous error or warning messages or set the argument's
        # values.
        values=""
        for message in "${messages[@]}"; do
            case "${message}" in
                ${translated_error}*) error_messages+=("${message}") ;;
                ${translated_warning}*) warning_messages+=("${message}") ;;
                Value*) values="${message#Value: }" ;;
            esac
        done

        # Assign the checked values to the argument.
        args[${arg_key}]="${values}"
    done

    # Sort, filter, colorize, and print all error and warning messages.
    argparser_print_error_messages true false "${error_messages[@]}"
    argparser_print_warning_messages true "${warning_messages[@]}"

    # If any argument was not or wrongly given (i.e., there were errors
    # and not just warnings), print a blank line and the usage message
    # and abort the script.
    if (( "${#error_messages[@]}" > 0 )); then
        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            printf '\n'
            argparser_print_usage_message false
        fi >&2
        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    fi

    # Remove the help options from the associative array ${args}.
    for arg_key in "${!args[@]}"; do
        if [[
            "${all_arg_groups[${arg_key}]}" == "${ARGPARSER_HELP_ARG_GROUP}"
        ]]
        then
            unset 'args[${arg_key}]'
        fi
    done

    # Copy the values of the associative array ${args} to the variable
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to.  Thereby, declare prints
    # the array contents stored in ${args}, which then gets stripped
    # from the leading assignment (before the equals sign ("=")) and set
    # to the new associative array with the name of
    # ${ARGPARSER_ARG_ARRAY_NAME}.

    # shellcheck disable=SC2178  # Intentional string, not array.
    args="$(declare -p args)"
    declare -g -A "${ARGPARSER_ARG_ARRAY_NAME}"="${args#*=}"

    if [[ "${ARGPARSER_ARG_ARRAY_NAME}" != "args" ]]; then
        unset args
    fi
}

function argparser_set_args() {
    # Set the keyword and positional arguments to global variables.
    #
    # Globals:
    # - ${${ARGPARSER_ARG_ARRAY_NAME}[@]}: the parsed and checked
    #   arguments with key and value as associative array, which
    #   ${ARGPARSER_ARG_ARRAY_NAME} refers to (read-only)
    # - ${!${ARGPARSER_ARG_ARRAY_NAME}[@]}: all argument identifiers
    #   found in ${${ARGPARSER_ARG_ARRAY_NAME}[@]}
    #
    # Environment:
    # - ARGPARSER_ARG_ARRAY_NAME (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_SET_ARRAYS (read-only)

    # Define the local variable.
    local arg_key

    # Get the associative array ${ARGPARSER_ARG_ARRAY_NAME} refers to.
    # If it is already "args" (the default name), nothing needs to be
    # done, but other variable names need to be mapped to "args" to be
    # able to refer to the variable by name.  Thus, declare prints the
    # array contents stored in the variable ${ARGPARSER_ARG_ARRAY_NAME}
    # refers to, which then gets stripped from the leading assignment
    # (before the equals sign ("=")) and set to the new associative
    # array ${args}.
    if [[ "${ARGPARSER_ARG_ARRAY_NAME}" != "args" ]]; then
        local args
        args="$(declare -p "${ARGPARSER_ARG_ARRAY_NAME}")"
        local -A args="${args#*=}"
    fi

    # Set the arguments.
    for arg_key in "${!args[@]}"; do
        if [[ "${args[${arg_key}]}" == *"${ARGPARSER_ARG_DELIMITER_2}"*
            && "${ARGPARSER_SET_ARRAYS}" == true ]]
        then
            # Set the argument, which includes the
            # ${ARGPARSER_ARG_DELIMITER_2} and hence is a sequence of
            # elements, as indexed array variable, while keeping it in
            # ${args} for usage by the calling script.
            declare -g -a "${arg_key}"

            # shellcheck disable=SC2229  # Indirect variable reference.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a "${arg_key}" \
                <<< "${args[${arg_key}]}"
        else
            # Set the argument as variable, while keeping it in ${args}
            # for potential usage by the calling script.
            declare -g "${arg_key}"="${args[${arg_key}]}"
        fi
    done
}

function argparser_write_args() {
    # Write the keyword and positional arguments to STDOUT.
    #
    # Globals:
    # - ${${ARGPARSER_ARG_ARRAY_NAME}[@]}: the parsed and checked
    #   arguments with key and value as associative array, which
    #   ${ARGPARSER_ARG_ARRAY_NAME} refers to (read-only)
    # - ${!${ARGPARSER_ARG_ARRAY_NAME}[@]}: all argument identifiers
    #   found in ${${ARGPARSER_ARG_ARRAY_NAME}[@]}
    #
    # Environment:
    # - ARGPARSER_ARG_ARRAY_NAME (read-only)

    # Define the local variables.
    local arg_key
    local -a args_repr
    local -a sorted_array

    # Get the associative array ${ARGPARSER_ARG_ARRAY_NAME} refers to.
    # If it is already "args" (the default name), nothing needs to be
    # done, but other variable names need to be mapped to "args" to be
    # able to refer to the variable by name.  Thus, declare prints the
    # array contents stored in the variable ${ARGPARSER_ARG_ARRAY_NAME}
    # refers to, which then gets stripped from the leading assignment
    # (before the equals sign ("=")) and set to the new associative
    # array ${args}.
    if [[ "${ARGPARSER_ARG_ARRAY_NAME}" != "args" ]]; then
        local args
        args="$(declare -p "${ARGPARSER_ARG_ARRAY_NAME}")"
        local -A args="${args#*=}"
    fi

    # Sort and print the arguments.
    args_repr=( )
    for arg_key in "${!args[@]}"; do
        args_repr+=("${arg_key}=${args[${arg_key}]}")
    done
    argparser_sort false "${args_repr[@]}"
    printf '%s\n' "${sorted_array[@]}"
}

# Define the Argparser functions for creating and printing the help,
# usage, and version messages, as well as for printing error and warning
# messages, and the Argparser logo.
function argparser_create_help_message() {
    # Create a help message for the script's arguments.
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups (read-only)
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_choice_values: the associative array holding the choice
    #   values (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_help_texts: the associative array holding the help texts
    #   (read-only)
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - all_notes: the associative array holding the notes (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - all_value_names: the associative array holding the value names
    #   (read-only)
    # - help_message_blocks: the associative array holding the help
    #   message's groups usable as include directive
    # - styles: the associative array containing the styles (read-only)
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_HELP_DESCRIPTION (read-only)
    # - ARGPARSER_HELP_OPTIONS (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_1 (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_2 (read-only)
    # - ARGPARSER_MAX_COL_WIDTH_3 (read-only)
    # - ARGPARSER_MAX_WIDTH (read-only)
    # - ARGPARSER_POSITIONAL_ARG_GROUP (read-only)
    # - ARGPARSER_SCRIPT_NAME (read-only)
    # - ARGPARSER_USAGE_OPTIONS (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_VERSION_OPTIONS (read-only)

    # Define the local variables.
    local -a all_option_names
    local arg_group
    local -a arg_groups
    local arg_key
    local arg_number
    local caption
    local choice_values_str
    local -a choice_values_arr
    local -a col_1
    local -a col_2
    local -a col_3
    local col_width_1
    local col_width_2
    local col_width_3
    local -a colorized_array
    local default_text_end
    local default_text_start
    local -a default_values_arr
    local default_values_str
    local description
    local -a folded_array
    local -a framed_array
    local has_default_args
    local has_required_args
    local -a help_message
    local help_text
    local i
    local is_deprecated
    local -a joined_array
    local line
    local long_option
    local -a long_options_arr
    local long_options_str
    local mandatory_arguments_hint
    local max_col_width
    local max_col_width_3
    local max_value
    local max_width
    local -a new_col_1
    local new_col_1_value
    local -a new_col_2
    local new_col_2_value
    local -a new_col_3
    local new_col_3_value
    local note
    local -a notes
    local -a option_names
    local optional_arguments_hint
    local pad_width
    local -a padded_array
    local remark
    local script_name
    local short_option
    local -a short_options_arr
    local short_options_str
    local -a sorted_array
    local -A sorted_col_1
    local -A sorted_col_2
    local -A sorted_col_3
    local translation
    local type
    local -a uncolorized_array
    local usage
    local value_name
    local -a value_names_arr
    local value_names_str

    # Read the arguments' groups to sort the keyword arguments by group
    # in the help message.  To this end, compare each argument's group
    # later upon iterating over them.
    arg_groups=( )
    for arg_group in "${all_arg_groups[@]}"; do
        if [[ "${arg_group}" != "${ARGPARSER_POSITIONAL_ARG_GROUP}" \
            && "${arg_group}" != "${ARGPARSER_HELP_ARG_GROUP}" ]] \
            && ! argparser_in_array "${arg_group}" "${arg_groups[@]}"
        then
            arg_groups+=("${arg_group}")
        fi
    done

    # The help message is structured in three columns: short options,
    # long options and the help text.  Populate these columns with the
    # entries for each argument.
    col_1=( )
    col_2=( )
    col_3=( )

    has_default_args=false
    has_required_args=false

    # Compute the columns for the positional arguments.
    for arg_key in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        default_values_str="${all_default_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
            <<< "${default_values_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        type="${all_types[${arg_key}]}"
        arg_number="${all_arg_numbers[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_key}]}"
        help_text="${all_help_texts[${arg_key}]}"

        # For character, file, and string arguments, wrap the default
        # values in quotes.
        if argparser_in_array "${type}" "char" "file" "str"; then
            default_values_arr=("${default_values_arr[@]/#/\"}")
            default_values_arr=("${default_values_arr[@]/%/\"}")
        fi

        # Concatenate and colorize the value names, default values, and
        # choice values.  Then, colorize the help text.
        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        value_names_arr=("${colorized_array[@]}")
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${value_names_arr[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["default_values"]}" 1 "array" \
            "${default_values_arr[@]}"
        default_values_arr=("${colorized_array[@]}")
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
            "${default_values_arr[@]}"
        default_values_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        choice_values_arr=("${colorized_array[@]}")
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${choice_values_arr[@]}"
        choice_values_str="${joined_array}"

        argparser_colorize "${styles["help_text"]}" 1 help_text "${help_text}"

        # Set a flag whether the argument is deprecated.
        is_deprecated=false
        for note in "${notes[@]}"; do
            if [[ "${note}" == "deprecated" ]]; then
                is_deprecated=true
            fi
        done

        # Define the columns' next line, for the current argument.  The
        # argument may have some default and some choice values or an
        # arbitrary argument number, with the existence of each changing
        # the look of the first or second column (depending on whether
        # there are short options, so the first column may or may not be
        # used).
        if [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]; then
            # Set the first column's value.
            if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
                # [1, inf) or [0, inf) values.
                if [[ -n "${choice_values_str}" \
                    && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_1_value="[${value_names_str}"
                    new_col_1_value+="={${choice_values_str}}...]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_1_value="${value_names_str}"
                    new_col_1_value+="={${choice_values_str}}..."
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_1_value="[${value_names_str}...]"
                else
                    # No choice nor default.
                    new_col_1_value="${value_names_str}..."
                fi
            else
                # Integer-count or [0, 1] values.
                if [[ -n "${choice_values_str}" \
                    && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_1_value="[${value_names_str}"
                    new_col_1_value+="={${choice_values_str}}]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_1_value="${value_names_str}"
                    new_col_1_value+="={${choice_values_str}}"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_1_value="[${value_names_str}]"
                else
                    # No choice nor default.
                    new_col_1_value="${value_names_str}"
                fi
            fi
            col_1+=("${new_col_1_value}")

            # Set the second column's value.
            col_2+=("")
        else
            # Set the first column's value.
            col_1+=("")

            # Set the second column's value.
            if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
                # [1, inf) or [0, inf) values.
                if [[ -n "${choice_values_str}" \
                    && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value="[${value_names_str}"
                    new_col_2_value+="={${choice_values_str}}...]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value="${value_names_str}"
                    new_col_2_value+="={${choice_values_str}}..."
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value="[${value_names_str}...]"
                else
                    # No choice nor default.
                    new_col_2_value="${value_names_str}..."
                fi
            else
                # Integer-count or [0, 1] values.
                if [[ -n "${choice_values_str}" \
                    && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value="[${value_names_str}"
                    new_col_2_value+="={${choice_values_str}}]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value="${value_names_str}"
                    new_col_2_value+="={${choice_values_str}}"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value="[${value_names_str}]"
                else
                    # No choice nor default.
                    new_col_2_value="${value_names_str}"
                fi
            fi
            col_2+=("${new_col_2_value}")
        fi

        # Set the third column's value.
        if [[ -n "${default_values_str}" && "${is_deprecated}" == true ]]; then
            # Default and deprecated.
            argparser_translate "Deprecated" "DEPRECATED"
            argparser_colorize "${styles["deprecation_note"]}" 1 note \
                "${translation}"
            argparser_translate "Default" "default"
            argparser_colorize "${styles["default_text"]}" 1 \
                default_text_start "(${translation}:"
            argparser_colorize "${styles["default_text"]}" 1 default_text_end \
                ")"
            new_col_3_value="(${note}) ${help_text} ${default_text_start} "
            new_col_3_value+="${default_values_str}${default_text_end}"
        elif [[ -n "${default_values_str}" ]]; then
            # Default only.
            argparser_translate "Default" "default"
            argparser_colorize "${styles["default_text"]}" 1 \
                default_text_start "(${translation}:"
            argparser_colorize "${styles["default_text"]}" 1 default_text_end \
                ")"
            new_col_3_value="${help_text} ${default_text_start} "
            new_col_3_value+="${default_values_str}${default_text_end}"
        elif [[ "${is_deprecated}" == true ]]; then
            # Deprecated only.
            argparser_translate "Deprecated" "DEPRECATED"
            argparser_colorize "${styles["deprecation_note"]}" 1 note \
                "${translation}"
            new_col_3_value="(${note}) ${help_text}"
        else
            # No default nor deprecated.
            new_col_3_value="${help_text}"
        fi
        col_3+=("${new_col_3_value}")
    done

    # To mark the end of an argument group later upon printing, add an
    # empty line in all three columns.  This cannot appear by chance,
    # whereas empty lines for single columns emerge from the line break
    # insertion when they are differently long.  Thus, a completely
    # empty line can be used as safe argument group delimiter.
    if (( "${#all_positional_args[@]}" > 0 )); then
        col_1+=("")
        col_2+=("")
        col_3+=("")
    fi

    # Compute the columns for the keyword arguments, with the help
    # options last.
    for arg_group in "${arg_groups[@]}" "${ARGPARSER_HELP_ARG_GROUP}"; do
        new_col_1=( )
        new_col_2=( )
        new_col_3=( )
        all_option_names=( )

        for arg_key in "${!all_short_options[@]}"; do
            # Read the argument's group to check whether it belongs to
            # the current group.
            if [[ "${all_arg_groups[${arg_key}]}" != "${arg_group}" ]]; then
                continue
            fi

            # Read the argument's remaining definition.
            short_options_str="${all_short_options[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options_arr \
                <<< "${short_options_str}"
            long_options_str="${all_long_options[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options_arr \
                <<< "${long_options_str}"
            value_names_str="${all_value_names[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
                <<< "${value_names_str}"
            default_values_str="${all_default_values[${arg_key}]}"
            if [[ "${arg_key}" == "ARGPARSER_ARG_DELIMITER_2" ]]; then
                default_values_arr=("${default_values_str}")
            else
                IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
                    default_values_arr \
                        <<< "${default_values_str}"
            fi
            choice_values_str="${all_choice_values[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
                <<< "${choice_values_str}"
            type="${all_types[${arg_key}]}"
            arg_number="${all_arg_numbers[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
                <<< "${all_notes[${arg_key}]}"
            help_text="${all_help_texts[${arg_key}]}"

            # Concatenate the name of all short and long options for the
            # sorting of all arguments, later.
            argparser_get_option_names "${arg_key}" "long-short" false
            all_option_names+=("${option_names}")

            # If there are less value names than short or long option
            # names, create the remaining value names by capitalizing
            # the respective option names.  If the argument has long
            # option names, use them, and only else the short option
            # names, as the value names are preferentially appended to
            # the long option names.
            if [[ -n "${long_options_str}" ]]; then
                # Long option.
                if (( "${#value_names_arr[@]}" < "${#long_options_arr[@]}" ))
                then
                    for long_option in "${long_options_arr[@]:${#value_names_arr[@]}}"
                    do
                        value_name="${long_option//-/_}"
                        value_names_arr+=("${value_name^^}")
                    done
                fi
            else
                # No long option.
                if (( "${#value_names_arr[@]}" < "${#short_options_arr[@]}" ))
                then
                    for short_option in "${short_options_arr[@]:${#value_names_arr[@]}}"
                    do
                        value_name="${short_option//-/_}"
                        value_names_arr+=("${value_name^^}")
                    done
                fi
            fi

            # For character, file, and string arguments, wrap the
            # default values in quotes.
            if argparser_in_array "${type}" "char" "file" "str"; then
                default_values_arr=("${default_values_arr[@]/#/\"}")
                default_values_arr=("${default_values_arr[@]/%/\"}")
            fi

            # Translate the default value of "true" or "false" for
            # flags.
            if [[ "${arg_number}" == 0 ]]; then
                argparser_translate "${default_values_str}" \
                    "${default_values_str}"
                default_values_arr=("${translation}")
                default_values_str="${translation}"
            fi

            # Concatenate and colorize the short and long option names,
            # the value names, default values, and choice values.  Then,
            # colorize the help text.
            argparser_colorize "${styles["short_options"]}" 1 "array" \
                "${short_options_arr[@]/#/-}"
            short_options_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${short_options_arr[@]}"
            short_options_str="${joined_array}"

            argparser_colorize "${styles["long_options"]}" 1 "array" \
                "${long_options_arr[@]/#/--}"
            long_options_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${long_options_arr[@]}"
            long_options_str="${joined_array}"

            argparser_colorize "${styles["value_names"]}" 1 "array" \
                "${value_names_arr[@]}"
            value_names_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${value_names_arr[@]}"
            value_names_str="${joined_array}"

            argparser_colorize "${styles["default_values"]}" 1 "array" \
                "${default_values_arr[@]}"
            default_values_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${default_values_arr[@]}"
            default_values_str="${joined_array}"

            argparser_colorize "${styles["choice_values"]}" 1 "array" \
                "${choice_values_arr[@]}"
            choice_values_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${choice_values_arr[@]}"
            choice_values_str="${joined_array}"

            argparser_colorize "${styles["help_text"]}" 1 help_text \
                "${help_text}"

            # Set a flag whether the option has default values for
            # adjustment of the help message header, later.
            if [[ "${arg_group}" != "${ARGPARSER_HELP_ARG_GROUP}" ]]; then
                if [[ -n "${default_values_str}" ]]; then
                    has_default_args=true
                else
                    has_required_args=true
                fi
            fi

            # Set a flag whether the option is deprecated.
            is_deprecated=false
            for note in "${notes[@]}"; do
                if [[ "${note}" == "deprecated" ]]; then
                    is_deprecated=true
                fi
            done

            # Define the columns' next line, for the current argument.
            # The argument may have some short and long options, along
            # with value names, some default and some choice values or
            # an arbitrary argument number, with the existence of each
            # changing the look of the respective column.  If either no
            # short or no long option is given, use the empty string
            # instead.
            # Set the first column's value.
            if [[ -z "${short_options_str}" ]]; then
                # No short option.
                new_col_1_value=""
            elif [[ -z "${long_options_str}" ]]; then
                # No long option.
                if [[ "${arg_number}" == 0 ]]; then
                    # Flag.
                    if [[ -n "${default_values_str}" ]]; then
                        # Default.
                        new_col_1_value="["
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}, "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                        new_col_1_value+="]"
                    else
                        # No default.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}, "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    fi
                elif [[ "${arg_number}" == "+" ]]; then
                    # [1, inf) values.
                    if [[ -n "${choice_values_str}" \
                        && -n "${default_values_str}" ]]
                    then
                        # Choice and default.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="[${short_option}"
                            new_col_1_value+="={${choice_values_str}}...], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${choice_values_str}" ]]; then
                        # Choice only.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}"
                            new_col_1_value+="={${choice_values_str}}..., "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${default_values_str}" ]]; then
                        # Default only.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="[${short_options_arr[i]}"
                            new_col_1_value+="=${value_names_arr[i]}...], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="${short_options_arr[i]}"
                            new_col_1_value+="=${value_names_arr[i]}..., "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    fi
                elif [[ "${arg_number}" == "*" ]]; then
                    # [0, inf) values.
                    if [[ -n "${choice_values_str}" \
                        && -n "${default_values_str}" ]]
                    then
                        # Choice and default.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="[${short_option}"
                            new_col_1_value+="[={${choice_values_str}}...]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${choice_values_str}" ]]; then
                        # Choice only.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}"
                            new_col_1_value+="[={${choice_values_str}}...], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${default_values_str}" ]]; then
                        # Default only.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="[${short_options_arr[i]}"
                            new_col_1_value+="[=${value_names_arr[i]}...]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="${short_options_arr[i]}"
                            new_col_1_value+="[=${value_names_arr[i]}...], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    fi
                elif [[ "${arg_number}" == "?" ]]; then
                    # [0, 1] values.
                    if [[ -n "${choice_values_str}" \
                        && -n "${default_values_str}" ]]
                    then
                        # Choice and default.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="[${short_option}"
                            new_col_1_value+="[={${choice_values_str}}]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${choice_values_str}" ]]; then
                        # Choice only.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}"
                            new_col_1_value+="[={${choice_values_str}}], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${default_values_str}" ]]; then
                        # Default only.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="[${short_options_arr[i]}"
                            new_col_1_value+="[=${value_names_arr[i]}]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="${short_options_arr[i]}"
                            new_col_1_value+="[=${value_names_arr[i]}], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    fi
                else
                    # Integer-count values.
                    if [[ -n "${choice_values_str}" \
                        && -n "${default_values_str}" ]]
                    then
                        # Choice and default.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="[${short_option}"
                            new_col_1_value+="={${choice_values_str}}], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${choice_values_str}" ]]; then
                        # Choice only.
                        new_col_1_value=""
                        for short_option in "${short_options_arr[@]}"; do
                            new_col_1_value+="${short_option}"
                            new_col_1_value+="={${choice_values_str}}, "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    elif [[ -n "${default_values_str}" ]]; then
                        # Default only.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="[${short_options_arr[i]}"
                            new_col_1_value+="=${value_names_arr[i]}], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options_arr[@]}"; do
                            new_col_1_value+="${short_options_arr[i]}"
                            new_col_1_value+="=${value_names_arr[i]}, "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    fi
                fi
            elif [[ -n "${default_values_str}" ]]; then
                # Long option, default.
                new_col_1_value="["
                for short_option in "${short_options_arr[@]}"; do
                    new_col_1_value+="${short_option}, "
                done
                new_col_1_value="${new_col_1_value%, }"
                new_col_1_value+="],"
            else
                # Long option, no default.
                new_col_1_value=""
                for short_option in "${short_options_arr[@]}"; do
                    new_col_1_value+="${short_option}, "
                done
                new_col_1_value="${new_col_1_value% }"
            fi
            new_col_1+=("${new_col_1_value}")

            # Set the second column's value.
            if [[ -z "${long_options_str}" ]]; then
                # No long option.
                new_col_2_value=""
            elif [[ "${arg_number}" == 0 ]]; then
                # Flag.
                if [[ -n "${default_values_str}" ]]; then
                    # Default.
                    new_col_2_value="["
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}, "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                    new_col_2_value+="]"
                else
                    # No default.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}, "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                fi
            elif [[ "${arg_number}" == "+" ]]; then
                # [1, inf) values.
                if [[ -n "${choice_values_str}" && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="[${long_option}"
                        new_col_2_value+="={${choice_values_str}}...], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}"
                        new_col_2_value+="={${choice_values_str}}..., "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="[${long_options_arr[i]}"
                        new_col_2_value+="=${value_names_arr[i]}...], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="${long_options_arr[i]}"
                        new_col_2_value+="=${value_names_arr[i]}..., "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                fi
            elif [[ "${arg_number}" == "*" ]]; then
                # [0, inf) values.
                if [[ -n "${choice_values_str}" && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="[${long_option}"
                        new_col_2_value+="[={${choice_values_str}}...]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}"
                        new_col_2_value+="={${choice_values_str}}...], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="[${long_options_arr[i]}"
                        new_col_2_value+="[=${value_names_arr[i]}...]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="${long_options_arr[i]}"
                        new_col_2_value+="[=${value_names_arr[i]}...], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                fi
            elif [[ "${arg_number}" == "?" ]]; then
                # [0, 1] values.
                if [[ -n "${choice_values_str}" && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="[${long_option}"
                        new_col_2_value+="[={${choice_values_str}}]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}"
                        new_col_2_value+="[={${choice_values_str}}], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="[${long_options_arr[i]}"
                        new_col_2_value+="[=${value_names_arr[i]}]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="${long_options_arr[i]}"
                        new_col_2_value+="[=${value_names_arr[i]}], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                fi
            else
                # Integer-count values.
                if [[ -n "${choice_values_str}" && -n "${default_values_str}" ]]
                then
                    # Choice and default.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="[${long_option}={${choice_values_str}}], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value=""
                    for long_option in "${long_options_arr[@]}"; do
                        new_col_2_value+="${long_option}={${choice_values_str}}, "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="[${long_options_arr[i]}"
                        new_col_2_value+="=${value_names_arr[i]}], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options_arr[@]}"; do
                        new_col_2_value+="${long_options_arr[i]}"
                        new_col_2_value+="=${value_names_arr[i]}, "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                fi
            fi
            new_col_2+=("${new_col_2_value}")

            # Set the third column's value.
            if [[ -n "${default_values_str}" && "${is_deprecated}" == true ]]
            then
                # Default and deprecated.
                argparser_translate "Deprecated" "DEPRECATED"
                argparser_colorize "${styles["deprecation_note"]}" 1 note \
                    "${translation}"
                argparser_translate "Default" "default"
                argparser_colorize "${styles["default_text"]}" 1 \
                    default_text_start "(${translation}:"
                argparser_colorize "${styles["default_text"]}" 1 \
                    default_text_end ")"
                new_col_3_value="(${note}) ${help_text} ${default_text_start} "
                new_col_3_value+="${default_values_str}${default_text_end}"
            elif [[ -n "${default_values_str}" ]]; then
                # Default only.
                argparser_translate "Default" "default"
                argparser_colorize "${styles["default_text"]}" 1 \
                    default_text_start "(${translation}:"
                argparser_colorize "${styles["default_text"]}" 1 \
                    default_text_end ")"
                new_col_3_value="${help_text} ${default_text_start} "
                new_col_3_value+="${default_values_str}${default_text_end}"
            elif [[ "${is_deprecated}" == true ]]; then
                # Deprecated only.
                argparser_translate "Deprecated" "DEPRECATED"
                argparser_colorize "${styles["deprecation_note"]}" 1 note \
                    "${translation}"
                new_col_3_value="(${note}) ${help_text}"
            else
                # No default nor deprecated.
                new_col_3_value="${help_text}"
            fi
            new_col_3+=("${new_col_3_value}")
        done

        # Sort the arguments by the option names.  To this end, three
        # associative arrays are defined that use the option names as
        # keys and the first, second, or third column's values as
        # values.  Then, the option names' indexed array gets sorted and
        # the indexed arrays for the first, second, and third columns
        # are re-populated using the values from the associative array,
        # such that the sorted option names define the order of the yet
        # unsorted columns.  As a consequence, all columns are sorted as
        # if they would have been sorted together (which appears not be
        # feasible).
        for i in "${!all_option_names[@]}"; do
            sorted_col_1[${all_option_names[i]}]="${new_col_1[i]}"
            sorted_col_2[${all_option_names[i]}]="${new_col_2[i]}"
            sorted_col_3[${all_option_names[i]}]="${new_col_3[i]}"
        done

        argparser_sort false "${all_option_names[@]}"
        all_option_names=("${sorted_array[@]}")

        for i in "${!all_option_names[@]}"; do
            col_1+=("${sorted_col_1[${all_option_names[i]}]}")
            col_2+=("${sorted_col_2[${all_option_names[i]}]}")
            col_3+=("${sorted_col_3[${all_option_names[i]}]}")
        done

        # To mark the end of an argument group later upon printing, add
        # an empty line in all three columns.  This cannot appear by
        # chance, whereas empty lines for single columns emerge from the
        # line break insertion when they are differently long.  Thus, a
        # completely empty line can be used as safe argument group
        # delimiter.
        col_1+=("")
        col_2+=("")
        col_3+=("")
    done

    # If there are positional arguments, include the positional argument
    # group as first one.  If there are keyword arguments, add them
    # afterwards.  Finally, add the help options' group, if existing.
    if (( "${#all_positional_args[@]}" > 0 )); then
        arg_groups=(
            "${ARGPARSER_POSITIONAL_ARG_GROUP}"
            "${arg_groups[@]}"
        )
    fi

    if [[ "${ARGPARSER_ADD_HELP}" == true \
        || "${ARGPARSER_ADD_USAGE}" == true \
        || "${ARGPARSER_ADD_VERSION}" == true ]]
    then
        arg_groups+=("${ARGPARSER_HELP_ARG_GROUP}")
    fi

    # Get the maximum width the first and second column will actually
    # occupy, once line-wrapped (folded), to be able to compute the
    # width for the third column.  To this end, fold the first two
    # (uncolorized) columns and compute their maximum width, then throw
    # them away.
    argparser_uncolorize "array" "${col_1[@]}"
    argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
        "${ARGPARSER_MAX_COL_WIDTH_1}" 0 "${uncolorized_array[@]}"
    argparser_get_max_width "${folded_array[@]}"
    col_width_1="${max_width}"

    argparser_uncolorize "array" "${col_2[@]}"
    argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
        "${ARGPARSER_MAX_COL_WIDTH_2}" 0 "${uncolorized_array[@]}"
    argparser_get_max_width "${folded_array[@]}"
    col_width_2="${max_width}"

    if (( ARGPARSER_MAX_COL_WIDTH_3 == 0 )); then
        if (( col_width_1 > 0 && col_width_2 > 0 )); then
            (( max_col_width_3 = ARGPARSER_MAX_WIDTH - col_width_1 \
                - col_width_2 - 2 ))
        elif (( col_width_1 > 0 )); then
            (( max_col_width_3 = ARGPARSER_MAX_WIDTH - col_width_1 - 1 ))
        elif (( col_width_2 > 0 )); then
            (( max_col_width_3 = ARGPARSER_MAX_WIDTH - col_width_2 - 1 ))
        else
            max_col_width_3="${ARGPARSER_MAX_WIDTH}"
        fi
    else
        max_col_width_3="${ARGPARSER_MAX_COL_WIDTH_3}"
    fi

    # Fold each line per column separately and immediately set each
    # folded line to the same number of line breaks, to keep the lines
    # synchronized with each other, despite likely needing a different
    # number of rows in the final help message.
    new_col_1=( )
    new_col_2=( )
    new_col_3=( )
    for i in "${!col_1[@]}"; do
        # Limit the width of the first two columns of the help message
        # to ${ARGPARSER_MAX_COL_WIDTH_*}, and of the third column to
        # ${ARGPARSER_MAX_WIDTH} minus the first two columns' actual
        # widths, or ${ARGPARSER_MAX_COL_WIDTH_3} (if given), by
        # inserting line breaks (as separate array elements).
        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_COL_WIDTH_1}" 0 "${col_1[i]}"
        new_col_1+=("${folded_array[@]}")

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_COL_WIDTH_2}" 0 "${col_2[i]}"
        new_col_2+=("${folded_array[@]}")

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${max_col_width_3}" 0 "${col_3[i]}"
        new_col_3+=("${folded_array[@]}")

        # Adjust the number of line breaks between each column's rows,
        # such that each column shares the same number of rows, thus
        # re-synchronizing the columns.  Thereby, get the largest line
        # count and add as many empty lines as needed to set each column
        # to the same line count.
        argparser_get_max "${#new_col_1[@]}" "${#new_col_2[@]}" \
            "${#new_col_3[@]}"

        while (( "${#new_col_1[@]}" < max_value )); do
            new_col_1+=("")
        done

        while (( "${#new_col_2[@]}" < max_value )); do
            new_col_2+=("")
        done

        while (( "${#new_col_3[@]}" < max_value )); do
            new_col_3+=("")
        done
    done

    # Right-pad the first and second column to properly align all three
    # columns.
    argparser_pad "right" "${col_width_1}" "${new_col_1[@]}"
    new_col_1=("${padded_array[@]}")
    argparser_pad "right" "${col_width_2}" "${new_col_2[@]}"
    new_col_2=("${padded_array[@]}")

    # Store the lines back in the original columns' variables.
    col_1=("${new_col_1[@]}")
    col_2=("${new_col_2[@]}")
    col_3=("${new_col_3[@]}")

    # Compute the padding width for the frame around argument group
    # blocks.  This equals the greater value of the maximum width of all
    # three columns, i.e., the actual column widths plus the mandatory
    # separation between the used columns, and the largest argument
    # group name, including the two spaces used as separation around the
    # name in the frame.
    argparser_get_max_width "${col_3[@]}"
    col_width_3="${max_width}"

    (( max_col_width = col_width_1 + col_width_2 + col_width_3 ))
    if [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]; then
        (( max_col_width++ ))
    fi
    if [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true ]]; then
        (( max_col_width++ ))
    fi

    argparser_get_max_width "${arg_groups[@]}"
    argparser_get_max "${max_col_width}" "$(( max_width + 2 ))"
    pad_width="${max_value}"

    # Set the help message's usage line with the caption and the script
    # name.
    argparser_translate "Usage" "Usage"
    argparser_colorize "${styles["help_caption"]}" 1 caption "${translation}:"
    argparser_colorize "${styles["script_name"]}" 1 script_name \
        "${ARGPARSER_SCRIPT_NAME}"
    usage="${caption} ${script_name}"

    # Add a hint for the optional keyword arguments (as summary), if
    # existing.
    if [[ "${has_default_args}" == true ]]; then
        argparser_translate "Options" "OPTIONS"
        argparser_colorize "${styles["value_names"]}" 1 \
            optional_arguments_hint "${translation}"
        usage+=" [${optional_arguments_hint}]"
    fi

    # Add a hint for the mandatory keyword arguments (as summary), if
    # existing.
    if [[ "${has_required_args}" == true ]]; then
        argparser_translate "Arguments" "ARGUMENTS"
        argparser_colorize "${styles["value_names"]}" 1 \
            mandatory_arguments_hint "${translation}"
        usage+=" ${mandatory_arguments_hint}"
    fi

    # Add the names of the positional arguments, if existing.
    if (( "${#all_positional_args[@]}" > 0 )); then
        if [[ "${has_required_args}" == true ]]; then
            usage+=" --"
        elif [[ "${has_default_args}" == true ]]; then
            usage+=" [--]"
        fi

        for arg_key in "${all_positional_args[@]}"; do
            value_names_str="${all_value_names[${arg_key}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
                <<< "${value_names_str}"
            default_values_str="${all_default_values[${arg_key}]}"

            argparser_colorize "${styles["value_names"]}" 1 "array" \
                "${value_names_arr[@]}"
            value_names_arr=("${colorized_array[@]}")
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${value_names_arr[@]}"
            value_names_str="${joined_array}"

            if [[ -n "${default_values_str}" ]]; then
                usage+=" [${value_names_str}]"
            else
                usage+=" ${value_names_str}"
            fi
        done
    fi

    usage+=$'\n'
    help_message_blocks["Usage"]="${usage}"

    # Set the description.
    if [[ -n "${ARGPARSER_HELP_DESCRIPTION}" ]]; then
        argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 \
            "${ARGPARSER_HELP_DESCRIPTION}"
        argparser_colorize "${styles["description_text"]}" 1 description \
            "${folded_array[@]}"
        description+=$'\n'
    else
        description=""
    fi
    help_message_blocks["Description"]="${description}"

    # Set the remark.
    remark="Mandatory arguments to long options are mandatory for short "
    remark+="options too."

    argparser_translate "Mandatory arguments" "${remark}"
    argparser_fold " " "${ARGPARSER_MAX_WIDTH}" 0 "${translation}"
    argparser_colorize "${styles["remark_text"]}" 1 remark "${folded_array[@]}"
    remark+=$'\n'
    help_message_blocks["Remark"]="${remark}"

    # For each argument group, print its arguments.
    i=0
    for arg_group in "${arg_groups[@]}"; do
        # For any argument line, output the three columns and their
        # delimiting whitespace.  If all three columns are empty, the
        # end of the current argument group has been reached.
        help_message=( )
        while [[ "${col_1[i]} ${col_2[i]} ${col_3[i]}" != +( ) ]]; do
            if [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true ]]
            then
                line="${col_1[i]} ${col_2[i]} ${col_3[i]}"
            elif [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]; then
                line="${col_1[i]} ${col_3[i]}"
            elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true ]]; then
                line="${col_2[i]} ${col_3[i]}"
            fi
            help_message+=("${line}")
            (( i++ ))
        done

        # Increment the start index for the next argument group by the
        # empty line used as argument group delimiter.
        (( i++ ))

        # If a help frame style is given, right-pad the lines of the
        # argument group's block, such that all blocks have the same
        # width.  Then, draw a frame around the block, containing the
        # colorized argument group name as heading.  Otherwise, use the
        # heading as separate line, and strip the whitespace from lines
        # where the third column is empty and the separating whitespace
        # thus trailing instead of in-between.  Finally, join the lines
        # into a single string.
        if [[ -n "${styles["help_frame"]}" ]]; then
            argparser_colorize "${styles["argument_group"]}" 1 caption \
                " ${arg_group} "
            argparser_pad "right" "${pad_width}" "${help_message[@]}"
            argparser_draw_frame "${styles["help_frame"]}" 1 "array" \
                "${caption}" "${padded_array[@]}"
            help_message=("${framed_array[@]}")
        else
            argparser_colorize "${styles["argument_group"]}" 1 caption \
                "${arg_group}:"
            help_message=(
                "${caption}"
                "${help_message[@]%%+( )}"
            )
        fi

        argparser_join $'\n' "${help_message[@]}"
        help_message_blocks[${arg_group}]="${joined_array}"$'\n'
    done
}

function argparser_create_usage_message() {
    # Create a usage message for the script's arguments.
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups (read-only)
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - all_choice_values: the associative array holding the choice
    #   values (read-only)
    # - all_default_values: the associative array holding the default
    #   values (read-only)
    # - all_long_options: the associative array holding the long option
    #   names (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - all_value_names: the associative array holding the value names
    #   (read-only)
    # - styles: the associative array containing the styles (read-only)
    # - usage_message_blocks: the associative array holding the usage
    #   message's groups usable as include directive
    #
    # Environment:
    # - ARGPARSER_ADD_HELP (read-only)
    # - ARGPARSER_ADD_USAGE (read-only)
    # - ARGPARSER_ADD_VERSION (read-only)
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_HELP_OPTIONS (read-only)
    # - ARGPARSER_MAX_WIDTH (read-only)
    # - ARGPARSER_SCRIPT_NAME (read-only)
    # - ARGPARSER_USAGE_MESSAGE_OPTION_TYPE(read-only)
    # - ARGPARSER_USAGE_MESSAGE_ORIENTATION (read-only)
    # - ARGPARSER_USAGE_OPTIONS (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_VERSION_OPTIONS (read-only)

    # Define the local variables.
    local arg_key
    local arg_number
    local caption
    local -a choice_values_arr
    local choice_values_str
    local -a colorized_array
    local default_values
    local -a framed_array
    local header
    local -a help_option_args
    local help_options
    local joined_array
    local -a lines
    local long_option
    local -a long_option_default_args
    local -a long_option_required_args
    local -a long_options_arr
    local long_options_str
    local -a positional_default_args
    local -a positional_required_args
    local option_names
    local -a padded_array
    local script_name
    local short_option
    local -a short_option_default_args
    local -a short_option_required_args
    local -a short_options_arr
    local short_options_str
    local -a sorted_array
    local translation
    local -a usage_message
    local uncolorized_message
    local value_name
    local -a value_names_arr
    local value_names_str
    local whitespace

    # Get the help options and sort them by the argument identifier,
    # such that the order is always "help", "usage", "version".
    help_option_args=( )
    for arg_key in "${!all_short_options[@]}"; do
        if [[
            "${all_arg_groups[${arg_key}]}" == "${ARGPARSER_HELP_ARG_GROUP}"
        ]]
        then
            help_option_args+=("${arg_key}")
        fi
    done

    if (( "${#help_option_args[@]}" > 0 )); then
        argparser_sort false "${help_option_args[@]}"
        help_option_args=("${sorted_array[@]}")
    fi

    # Concatenate the short or long option names of each help option.
    help_options=""
    for arg_key in "${help_option_args[@]}"; do
        # Separate the help options' names by pipes.
        if [[ -n "${help_options}" ]]; then
            help_options+=" | "
        fi

        # Set the help options' names.
        if [[ ("${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "short" \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true) \
            || "${ARGPARSER_USE_LONG_OPTIONS}" == false ]]
        then
            argparser_get_option_names "${arg_key}" "short" true
            help_options+="${option_names}"
        elif [[ ("${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "long" \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true) \
            || "${ARGPARSER_USE_SHORT_OPTIONS}" == false ]]
        then
            argparser_get_option_names "${arg_key}" "long" true
            help_options+="${option_names}"
        fi
    done

    # Add the help options to the usage message.
    usage_message=( )
    if [[ -n "${help_options}" ]]; then
        usage_message+=("[${help_options}]")
    fi

    # If ${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE} is set to "short",
    # separate keyword arguments with default values from those without
    # to output first the arguments with default values and afterwards
    # those without.  Within either block, separate arguments with short
    # options from those without to output first the arguments with
    # short option names and then those with only long option names.  If
    # ${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE} is set to "long", do the
    # same for the long options and short option-only arguments.  In
    # both cases, having both short and long option names does not
    # matter as only one sort gets printed.
    short_option_default_args=( )
    short_option_required_args=( )
    long_option_default_args=( )
    long_option_required_args=( )
    if [[ "${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "short" ]]; then
        for arg_key in "${!all_short_options[@]}"; do
            # Skip the help options.
            if [[ "${all_arg_groups[${arg_key}]}" \
                == "${ARGPARSER_HELP_ARG_GROUP}" ]]
            then
                continue
            fi

            # Read the argument's definition.
            short_options_str="${all_short_options[${arg_key}]}"
            default_values="${all_default_values[${arg_key}]}"

            # Add the argument to the respective array.
            if [[ -z "${default_values}" ]]; then
                if [[ -z "${short_options_str}" ]]; then
                    long_option_required_args+=("${arg_key}")
                else
                    short_option_required_args+=("${arg_key}")
                fi
            else
                if [[ -z "${short_options_str}" ]]; then
                    long_option_default_args+=("${arg_key}")
                else
                    short_option_default_args+=("${arg_key}")
                fi
            fi
        done
    else
        for arg_key in "${!all_short_options[@]}"; do
            # Skip the help options.
            if [[ "${all_arg_groups[${arg_key}]}" \
                == "${ARGPARSER_HELP_ARG_GROUP}" ]]
            then
                continue
            fi

            # Read the argument's definition.
            long_options_str="${all_long_options[${arg_key}]}"
            default_values="${all_default_values[${arg_key}]}"

            # Add the argument to the respective array.
            if [[ -z "${default_values}" ]]; then
                if [[ -z "${long_options_str}" ]]; then
                    short_option_required_args+=("${arg_key}")
                else
                    long_option_required_args+=("${arg_key}")
                fi
            else
                if [[ -z "${long_options_str}" ]]; then
                    short_option_default_args+=("${arg_key}")
                else
                    long_option_default_args+=("${arg_key}")
                fi
            fi
        done
    fi

    # Likewise, separate positional arguments with default values from
    # those without.
    positional_default_args=( )
    positional_required_args=( )
    for arg_key in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        default_values="${all_default_values[${arg_key}]}"

        # Add the argument to the respective array.
        if [[ -z "${default_values}" ]]; then
            positional_required_args+=("${arg_key}")
        else
            positional_default_args+=("${arg_key}")
        fi
    done

    # Output each keyword argument with short options and default values
    # and sort them alphabetically.
    lines=( )
    for arg_key in "${short_option_default_args[@]}"; do
        # Read the argument's definition.
        short_options_str="${all_short_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options_arr \
            <<< "${short_options_str}"
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # If there are less value names than short option names, create
        # the remaining value names by capitalizing the short option
        # names.
        if (( "${#value_names_arr[@]}" < "${#short_options_arr[@]}" ))
        then
            for short_option in "${short_options_arr[@]:${#value_names_arr[@]}}"
            do
                value_name="${short_option//-/_}"
                value_names_arr+=("${value_name^^}")
            done
        fi

        # Concatenate and colorize the short option names, value names,
        # and choice values.
        argparser_get_option_names "${arg_key}" "short" true
        short_options_str="${option_names}"

        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has
        # some short options, default values, and possibly choice
        # values, and a variable argument number, with each property
        # changing the look of the line.
        if [[ "${arg_number}" == 0 ]]; then
            # Flag.
            lines+=("[${short_options_str}]")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options_str}={${choice_values_str}}...]")
            else
                # Default only.
                lines+=("[${short_options_str}=${value_names_str}...]")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options_str}[={${choice_values_str}}...]]")
            else
                # Default only.
                lines+=("[${short_options_str}[=${value_names_str}...]]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options_str}[={${choice_values_str}}]]")
            else
                # Default only.
                lines+=("[${short_options_str}[=${value_names_str}]]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options_str}={${choice_values_str}}]")
            else
                # Default only.
                lines+=("[${short_options_str}=${value_names_str}]")
            fi
        fi
    done

    if (( "${#lines[@]}" > 0 )); then
        argparser_sort false "${lines[@]}"
        usage_message+=("${sorted_array[@]}")
    fi

    # Output each keyword argument with long options and default values
    # and sort them alphabetically.
    lines=( )
    for arg_key in "${long_option_default_args[@]}"; do
        # Read the argument's definition.
        long_options_str="${all_long_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options_arr \
            <<< "${long_options_str}"
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # If there are less value names than long option names, create
        # the remaining value names by capitalizing the long option
        # names.
        if (( "${#value_names_arr[@]}" < "${#long_options_arr[@]}" ))
        then
            for long_option in "${long_options_arr[@]:${#value_names_arr[@]}}"
            do
                value_name="${long_option//-/_}"
                value_names_arr+=("${value_name^^}")
            done
        fi

        # Concatenate and colorize the long option names, value names,
        # and choice values.
        argparser_get_option_names "${arg_key}" "long" true
        long_options_str="${option_names}"

        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has
        # some long options, default values, and possibly choice
        # values, and a variable argument number, with each property
        # changing the look of the line.
        if [[ "${arg_number}" == 0 ]]; then
            # Flag.
            lines+=("[${long_options_str}]")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options_str}={${choice_values_str}}...]")
            else
                # Default only.
                lines+=("[${long_options_str}=${value_names_str}...]")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options_str}[={${choice_values_str}}...]]")
            else
                # Default only.
                lines+=("[${long_options_str}[=${value_names_str}...]]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options_str}[={${choice_values_str}}]]")
            else
                # Default only.
                lines+=("[${long_options_str}[=${value_names_str}]]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options_str}={${choice_values_str}}]")
            else
                # Default only.
                lines+=("[${long_options_str}=${value_names_str}]")
            fi
        fi
    done

    if (( "${#lines[@]}" > 0 )); then
        argparser_sort false "${lines[@]}"
        usage_message+=("${sorted_array[@]}")
    fi

    # Output each keyword argument with short options and without
    # default values and sort them alphabetically.
    lines=( )
    for arg_key in "${short_option_required_args[@]}"; do
        # Read the argument's definition.
        short_options_str="${all_short_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options_arr \
            <<< "${short_options_str}"
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # If there are less value names than short option names, create
        # the remaining value names by capitalizing the short option
        # names.
        if (( "${#value_names_arr[@]}" < "${#short_options_arr[@]}" ))
        then
            for short_option in "${short_options_arr[@]:${#value_names_arr[@]}}"
            do
                value_name="${short_option//-/_}"
                value_names_arr+=("${value_name^^}")
            done
        fi

        # Concatenate and colorize the short option names, value names,
        # and choice values.
        argparser_get_option_names "${arg_key}" "short" true
        short_options_str="${option_names}"

        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has
        # some short options, no default values, and possibly some
        # choice values, and a variable argument number, with each
        # property changing the look of the line.
        if [[ "${arg_number}" == 0 ]]; then
            # Flag.
            lines+=("${short_options_str}")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options_str}={${choice_values_str}}...")
            else
                # No choice nor default.
                lines+=("${short_options_str}=${value_names_str}...")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options_str}[={${choice_values_str}}...]")
            else
                # No choice nor default.
                lines+=("${short_options_str}[=${value_names_str}...]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options_str}[={${choice_values_str}}]")
            else
                # No choice nor default.
                lines+=("${short_options_str}[=${value_names_str}]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options_str}={${choice_values_str}}")
            else
                # No choice nor default.
                lines+=("${short_options_str}=${value_names_str}")
            fi
        fi
    done

    if (( "${#lines[@]}" > 0 )); then
        argparser_sort false "${lines[@]}"
        usage_message+=("${sorted_array[@]}")
    fi

    # Output each keyword argument with long options and without default
    # values and sort them alphabetically.
    lines=( )
    for arg_key in "${long_option_required_args[@]}"; do
        # Read the argument's definition.
        long_options_str="${all_long_options[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options_arr \
            <<< "${long_options_str}"
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # If there are less value names than long option names, create
        # the remaining value names by capitalizing the long option
        # names.
        if (( "${#value_names_arr[@]}" < "${#long_options_arr[@]}" ))
        then
            for long_option in "${long_options_arr[@]:${#value_names_arr[@]}}"
            do
                value_name="${long_option//-/_}"
                value_names_arr+=("${value_name^^}")
            done
        fi

        # Concatenate and colorize the long option names, value names,
        # and choice values.
        argparser_get_option_names "${arg_key}" "long" true
        long_options_str="${option_names}"

        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has
        # some long options, no default values, and possibly some choice
        # values, and a variable argument number, with each property
        # changing the look of the line.
        if [[ "${arg_number}" == 0 ]]; then
            # Flag.
            lines+=("${long_options_str}")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options_str}={${choice_values_str}}...")
            else
                # No choice nor default.
                lines+=("${long_options_str}=${value_names_str}...")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options_str}[={${choice_values_str}}...]")
            else
                # No choice nor default.
                lines+=("${long_options_str}[=${value_names_str}...]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options_str}[={${choice_values_str}}]")
            else
                # No choice nor default.
                lines+=("${long_options_str}[=${value_names_str}]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options_str}={${choice_values_str}}")
            else
                # No choice nor default.
                lines+=("${long_options_str}=${value_names_str}")
            fi
        fi
    done

    if (( "${#lines[@]}" > 0 )); then
        argparser_sort false "${lines[@]}"
        usage_message+=("${sorted_array[@]}")
    fi

    # Output each positional argument with default values.
    lines=( )
    for arg_key in "${positional_default_args[@]}"; do
        # Read the argument's definition.
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # Concatenate and colorize the value names and choice values.
        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has
        # some default values and may have some choice values, with the
        # existence of each changing the look of the line.
        if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
            # [1, inf) or [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[{${choice_values_str}}...]")
            else
                # Default only.
                lines+=("[${value_names_str}...]")
            fi
        else
            # Integer-count or [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[{${choice_values_str}}]")
            else
                # Default only.
                lines+=("[${value_names_str}]")
            fi
        fi
    done

    usage_message+=("${lines[@]}")

    # Output each positional argument without default values.
    lines=( )
    for arg_key in "${positional_required_args[@]}"; do
        # Read the argument's definition.
        value_names_str="${all_value_names[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names_arr \
            <<< "${value_names_str}"
        choice_values_str="${all_choice_values[${arg_key}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_key}]}"

        # Concatenate and colorize the value names and choice values.
        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        value_names_str="${joined_array}"

        argparser_colorize "${styles["choice_values"]}" 1 "array" \
            "${choice_values_arr[@]}"
        argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${colorized_array[@]}"
        choice_values_str="${joined_array}"

        # Define the line for the current argument.  The argument has no
        # default values and may have some choice values, with the
        # existence of each changing the look of the line.
        if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
            # [1, inf) or [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("{${choice_values_str}}...")
            else
                # No choice nor default.
                lines+=("${value_names_str}...")
            fi
        else
            # Integer-count or [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("{${choice_values_str}}")
            else
                # No choice nor default.
                lines+=("${value_names_str}")
            fi
        fi
    done

    usage_message+=("${lines[@]}")

    # To keep all arguments aligned in columnar orientation, prepend
    # whitespace to the usage message's lines.  Its length equals the
    # length of the header with the script name, and, if no usage frame
    # is given, the (translated) caption.  For the first line, where the
    # header will be added, below, remove the whitespace afterwards.
    # For a row-like orientation, join the lines using one space,
    # instead.  Even if a row-like orientation is preferred, use a
    # columnar orientation if the (uncolorized) usage message's length,
    # when joined to a row, exceeds ${ARGPARSER_MAX_WIDTH}.
    argparser_translate "Usage" "Usage"
    caption="${translation}"

    if [[ -n "${styles["usage_frame"]}" ]]; then
        header="${ARGPARSER_SCRIPT_NAME} "
    else
        header="${caption}: ${ARGPARSER_SCRIPT_NAME} "
    fi

    argparser_join " " "${usage_message[@]}"
    argparser_uncolorize uncolorized_message 1 "${joined_array}"
    if (( "${#uncolorized_message}" + "${#header}" > ARGPARSER_MAX_WIDTH )) \
        || [[ "${ARGPARSER_USAGE_MESSAGE_ORIENTATION}" == "column" ]]
    then
        printf -v whitespace '%*s' "${#header}" ""
        usage_message=("${usage_message[@]/#/"${whitespace}"}")
        usage_message[0]="${usage_message[0]#"${whitespace}"}"
    else
        usage_message=("${joined_array}")
    fi

    # Colorize the caption and script name.  If a usage frame style is
    # given, prepend the script name to the first option line, right-pad
    # the messages and draw a frame around the block, containing the
    # colorized usage caption as heading.  Otherwise, print the usage
    # message with script name, heading, and the first option line in
    # one line.  Finally, join the lines into a single string.
    argparser_colorize "${styles["script_name"]}" 2 script_name \
        "${ARGPARSER_SCRIPT_NAME}"

    if [[ -n "${styles["usage_frame"]}" ]]; then
        argparser_colorize "${styles["usage_caption"]}" 1 caption \
            " ${caption} "
        usage_message[0]="${script_name} ${usage_message[0]}"
        argparser_pad "right" "auto" "${usage_message[@]}"
        argparser_draw_frame "${styles["usage_frame"]}" 1 "array" \
            "${caption}" "${padded_array[@]}"
        usage_message=("${framed_array[@]}")
    else
        argparser_colorize "${styles["usage_caption"]}" 1 caption "${caption}:"
        usage_message[0]="${caption} ${script_name} ${usage_message[0]}"
    fi

    argparser_join $'\n' "${usage_message[@]}"
    usage_message_blocks["Usage"]="${joined_array}"$'\n'
}

function argparser_print_help_message() {
    # Print a help message.  If a file with such is given, print the
    # file, else, create a message for the script's arguments.  For
    # files, possibly skip commented lines (i.e., lines starting with
    # "#") and their trailing blank lines.  Replace lines starting with
    # ${ARGPARSER_HELP_FILE_INCLUDE_CHAR} by the auto-generated help
    # message.
    #
    # Arguments:
    # - $1: whether to exit after printing
    #
    # Nonlocals:
    # - all_arg_groups: the associative array holding the argument
    #   groups (read-only)
    # - all_positional_args: the indexed array holding the positional
    #   argument names (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - styles: the associative array containing the styles
    #
    # Environment:
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_HELP_EXIT_CODE (read-only)
    # - ARGPARSER_HELP_FILE (read-only)
    # - ARGPARSER_HELP_FILE_INCLUDE_CHAR (read-only)
    # - ARGPARSER_HELP_FILE_KEEP_COMMENTS (read-only)
    # - ARGPARSER_POSITIONAL_ARG_GROUP (read-only)

    # Define the local variables.
    local add_caption
    local arg_group
    local -a arg_groups
    local block
    local caption
    local count
    local error_message
    local -a error_messages
    local exit
    local frame
    local frame_char
    local help_message
    local -A help_message_blocks
    local include_char
    local include_directive
    local line
    local -a lines
    local line_type
    local -a resolved_lines
    local skip_blank_line
    local -a sorted_array
    local translation
    local uncolorized_caption

    # Read the argument.
    exit="$1"

    # Read the keyword arguments' groups to sort them for the help
    # message.
    arg_groups=( )
    for arg_group in "${all_arg_groups[@]}"; do
        if [[ "${arg_group}" != "${ARGPARSER_POSITIONAL_ARG_GROUP}" \
            && "${arg_group}" != "${ARGPARSER_HELP_ARG_GROUP}" ]] \
            && ! argparser_in_array "${arg_group}" "${arg_groups[@]}"
        then
            arg_groups+=("${arg_group}")
        fi
    done

    # Sort the argument groups, prepend the positional argument group
    # and append the help options' group.
    argparser_sort false "${arg_groups[@]}"
    arg_groups=("${sorted_array[@]}")
    if (( "${#all_positional_args[@]}" > 0 )); then
        arg_groups=("${ARGPARSER_POSITIONAL_ARG_GROUP}" "${arg_groups[@]}")
    fi

    if [[ "${ARGPARSER_ADD_HELP}" == true \
        || "${ARGPARSER_ADD_USAGE}" == true \
        || "${ARGPARSER_ADD_VERSION}" == true ]]
    then
        arg_groups+=("${ARGPARSER_HELP_ARG_GROUP}")
    fi

    # Count the keyword arguments that aren't used for the help, usage,
    # or version message.  This count is used to conditionally add the
    # remark to the help message, below.  By counting the number of
    # "true" values in ${ARGPARSER_ADD_HELP}, ${ARGPARSER_ADD_USAGE},
    # and ${ARGPARSER_ADD_VERSION}, it is possible to check which help
    # options are defined.  All other arguments that have an entry in
    # ${!all_short_options[@]} are actual keyword arguments needed for
    # the remark.
    argparser_count "true" "${ARGPARSER_ADD_HELP}" "${ARGPARSER_ADD_USAGE}" \
        "${ARGPARSER_ADD_VERSION}"
    (( keyword_args_count = "${#all_short_options[@]}" - count ))

    # Create the help message groups, which are saved in an associative
    # array using the include directives as keys.
    argparser_create_help_message

    # Read the help file, if given, or set the lines to just the include
    # directive "All", meaning to create the entire help message.
    include_char="${ARGPARSER_HELP_FILE_INCLUDE_CHAR}"
    if [[ -n "${ARGPARSER_HELP_FILE}" ]]; then
        mapfile -t lines < "${ARGPARSER_HELP_FILE}"
    else
        lines=("${include_char}All")
    fi

    # Resolve the summarizing include directives by replacing them with
    # the individual include directives and separating blank lines.
    resolved_lines=( )
    for line in "${lines[@]}"; do
        if [[ "${line::1}" != "${include_char}" ]]; then
            resolved_lines+=("${line}")
            continue
        fi

        # Extract the include directive, where the include character may
        # be doubled.
        if [[ "${line:1:1}" == "${include_char}" ]]; then
            add_caption=false
            include_directive="${line:2}"
        else
            add_caption=true
            include_directive="${line:1}"
        fi

        if [[ "${include_directive}" == "All" ]]; then
            # Add the usage, description, and remark include directives,
            # terminated by blank lines.
            resolved_lines+=(
                "${include_char}Usage"
                ""
                "${include_char}Description"
                ""
                "${include_char}Remark"
                ""
            )

            # Add the include directives for each argument group.
            # Terminate all but the last by a blank line.  If the last
            # group is the help options group, double the include
            # character to indicate that the caption shall be
            # suppressed.
            for i in "${!arg_groups[@]}"; do
                if (( i < "${#arg_groups[@]}" - 1 )); then
                    resolved_lines+=(
                        "${include_char}${arg_groups[i]}"
                        ""
                    )
                elif [[ "${ARGPARSER_ADD_HELP}" == true \
                    || "${ARGPARSER_ADD_USAGE}" == true \
                    || "${ARGPARSER_ADD_VERSION}" == true ]]
                then
                    resolved_lines+=(
                        "${include_char}${include_char}${arg_groups[i]}"
                    )
                else
                    resolved_lines+=("${include_char}${arg_groups[i]}")
                fi
            done
        elif [[ "${include_directive}" == "Header" ]]; then
            # Add the usage, description, and remark include directives,
            # separated by blank lines.
            resolved_lines+=(
                "${include_char}Usage"
                ""
                "${include_char}Description"
                ""
                "${include_char}Remark"
            )
        elif [[ "${include_directive}" == "Help" ]]; then
            # Replace the include directive with the actual name of the
            # help option group.
            if [[ "${add_caption}" == true ]]; then
                resolved_lines+=(
                    "${include_char}${ARGPARSER_HELP_ARG_GROUP}"
                )
            else
                resolved_lines+=(
                    "${include_char}${include_char}${ARGPARSER_HELP_ARG_GROUP}"
                )
            fi
        else
            # Add the unmodified line.
            resolved_lines+=("${line}")
        fi
    done

    # For each resolved line, print the text and replace the include
    # directives by the respective part from the help message.
    # Possibly, skip comments.
    line_type="text"
    skip_blank_line=false
    help_message=""
    for line in "${resolved_lines[@]}"; do
        # Set ${line_type} to "include directive" if the line contains
        # an include directive, to "comment" if the line is commented
        # and ${ARGPARSER_HELP_FILE_KEEP_COMMENTS} is "false", and to
        # "text" if it is not empty (but not commented).  Thus, empty
        # lines following comments still have ${line_type} set to
        # "comment".  For include directives, add the requested groups
        # from the help message.  Only add the remark if keyword
        # arguments are given.
        if [[ "${line::1}" == "${include_char}" ]]; then
            line_type="include directive"

            # Set the caption to be suppressed when the include
            # character is doubled.
            if [[ "${line:1:1}" == "${include_char}" ]]; then
                add_caption=false
                include_directive="${line:2}"
            else
                add_caption=true
                include_directive="${line:1}"
            fi

            if [[ "${include_directive}" == "Description" ]]; then
                # Add the description.
                if [[ -n "${help_message_blocks["Description"]}" ]]; then
                    help_message+="${help_message_blocks["Description"]}"
                else
                    skip_blank_line=true
                fi
            elif [[ "${include_directive}" == "Remark" ]]; then
                # Add the remark.
                if (( keyword_args_count > 0 )); then
                    help_message+="${help_message_blocks["Remark"]}"
                else
                    skip_blank_line=true
                fi
            elif [[ "${include_directive}" == "Usage" ]]; then
                # Add the usage.
                help_message+="${help_message_blocks["Usage"]}"
            elif argparser_in_array "${include_directive}" "${arg_groups[@]}"
            then
                # Add the argument group, possibly removing the caption.
                block="${help_message_blocks["${include_directive}"]}"
                if [[ "${add_caption}" == false ]]; then
                    if [[ -n "${styles["help_frame"]}" ]]; then
                        # A frame is used, where the first line contains
                        # the caption on the frame.  Replace all
                        # characters (which are the frame's horizontal
                        # line and the caption) between the first and
                        # last character in the uncolorized copy of the
                        # line (which are the frame corners) by the
                        # second uncolorized character (which is part of
                        # the horizontal line, just before the caption
                        # starts).  The number of characters to replace
                        # equals the length of the uncolorized line
                        # minus the two corner characters.
                        caption="${block%%$'\n'*}"
                        block="${block#"${caption}"$'\n'}"
                        argparser_uncolorize uncolorized_caption "${caption}"
                        frame_char="${uncolorized_caption:1:1}"
                        printf -v frame '%*s' \
                            "$(( "${#uncolorized_caption}" - 2 ))" ""
                        frame="${frame// /"${frame_char}"}"
                        frame="${caption//"${frame_char}"*"${frame_char}"/"${frame}"}"
                        block="${frame}"$'\n'"${block}"
                    else
                        # No frame is used, so simply remove the first
                        # line, which contains the caption.
                        block="${block#+([^$'\n'])$'\n'}"
                    fi
                fi
                help_message+="${block}"
            else
                # Output an error message for the unrecognized and
                # likely incorrect include directive.
                error_message="Error: The include directive \"\$1\" could not "
                error_message+="be recognized."

                argparser_translate "Error include directive" \
                    "${error_message}" "${include_directive}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        elif [[ "${line::1}" == \# \
            && "${ARGPARSER_HELP_FILE_KEEP_COMMENTS}" == false ]]
        then
            line_type="comment"
        elif [[ -n "${line}" \
            || "${ARGPARSER_HELP_FILE_KEEP_COMMENTS}" == true ]]
        then
            line_type="text"
        fi

        # If ${skip_blank_line} is set to "true", skip the current line,
        # which is empty by definition (it follows an include directive
        # for an empty group).  Else, if ${line_type} has been set to
        # "text", print the current line.  If it is set to
        # "include_directive", reset it to "text" to (possibly) print
        # the next line, and only not the current include directive
        # line.
        if [[ "${skip_blank_line}" == true ]]; then
            skip_blank_line=false
        elif [[ "${line_type}" == "text" ]]; then
            help_message+="${line}"$'\n'
        elif [[ "${line_type}" == "include directive" ]]; then
            line_type="text"
        fi
    done

    # Sort, filter, colorize, and print all error messages.
    argparser_print_error_messages true false "${error_messages[@]}"

    # Print the help message, then exit, if requested.
    printf '%s' "${help_message}"

    if [[ "${exit}" == true ]]; then
        exit "${ARGPARSER_HELP_EXIT_CODE}"
    fi
}

function argparser_print_usage_message() {
    # Print a usage message.  If a file with such is given, print the
    # file, else, create a message for the script's arguments.  For
    # files, possibly skip commented lines (i.e., lines starting with
    # "#") and their trailing blank lines.  Replace lines starting with
    # ${ARGPARSER_USAGE_FILE_INCLUDE_CHAR} by the auto-generated usage
    # message.
    #
    # Arguments:
    # - $1: whether to exit after printing
    #
    # Environment:
    # - ARGPARSER_USAGE_EXIT_CODE (read-only)
    # - ARGPARSER_USAGE_FILE (read-only)
    # - ARGPARSER_USAGE_FILE_INCLUDE_CHAR (read-only)
    # - ARGPARSER_USAGE_FILE_KEEP_COMMENTS (read-only)

    # Define the local variables.
    local error_message
    local -a error_messages
    local exit
    local include_directive
    local line
    local -a lines
    local line_type
    local -a resolved_lines
    local skip_blank_line
    local translation
    local usage_message
    local -A usage_message_blocks

    # Read the argument.
    exit="$1"

    # Create the usage message groups, which are saved in an associative
    # array using the include directives as keys.
    argparser_create_usage_message

    # Read the usage file, if given, or set the lines to just the
    # include directive "All", meaning to create the entire usage
    # message.
    if [[ -n "${ARGPARSER_USAGE_FILE}" ]]; then
        mapfile -t lines < "${ARGPARSER_USAGE_FILE}"
    else
        lines=("${ARGPARSER_USAGE_FILE_INCLUDE_CHAR}All")
    fi

    # Resolve the summarizing include directives by replacing them with
    # the individual include directives and separating blank lines.
    resolved_lines=( )
    for line in "${lines[@]}"; do
        if [[ "${line::1}" != "${ARGPARSER_USAGE_FILE_INCLUDE_CHAR}" ]]; then
            resolved_lines+=("${line}")
            continue
        fi

        include_directive="${line:1}"
        if [[ "${include_directive}" == "All" ]]; then
            # Add the usage include directive.
            resolved_lines+=("${ARGPARSER_USAGE_FILE_INCLUDE_CHAR}Usage")
        else
            # Add the unmodified line.
            resolved_lines+=("${line}")
        fi
    done

    # For each resolved line, print the text and replace the include
    # directives by the respective part from the usage message.
    # Possibly, skip comments.
    line_type="text"
    skip_blank_line=false
    usage_message=""
    for line in "${resolved_lines[@]}"; do
        # Set ${line_type} to "include directive" if the line contains
        # an include directive, to "comment" if the line is commented
        # and ${ARGPARSER_USAGE_FILE_KEEP_COMMENTS} is "false", and to
        # "text" if it is not empty (but not commented).  Thus, empty
        # lines following comments still have ${line_type} set to
        # "comment".  For include directives, add the requested groups
        # from the usage message.
        if [[ "${line::1}" == "${ARGPARSER_USAGE_FILE_INCLUDE_CHAR}" ]]; then
            line_type="include directive"
            include_directive="${line:1}"

            if [[ "${include_directive}" == "Usage" ]]; then
                # Add the usage.
                usage_message+="${usage_message_blocks["Usage"]}"
            else
                # Output an error message for the unrecognized and
                # likely incorrect include directive.
                error_message="Error: The include directive \"\$1\" could not "
                error_message+="be recognized."

                argparser_translate "Error include directive" \
                    "${error_message}" "${include_directive}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        elif [[ "${line::1}" == \# \
            && "${ARGPARSER_USAGE_FILE_KEEP_COMMENTS}" == false ]]
        then
            line_type="comment"
        elif [[ -n "${line}" \
            || "${ARGPARSER_USAGE_FILE_KEEP_COMMENTS}" == true ]]
        then
            line_type="text"
        fi

        # If ${skip_blank_line} is set to "true", skip the current line,
        # which is empty by definition (it follows an include directive
        # for an empty group).  Else, if ${line_type} has been set to
        # "text", print the current line.  If it is set to
        # "include_directive", reset it to "text" to (possibly) print
        # the next line, and only not the current include directive
        # line.
        if [[ "${skip_blank_line}" == true ]]; then
            skip_blank_line=false
        elif [[ "${line_type}" == "text" ]]; then
            usage_message+="${line}"$'\n'
        elif [[ "${line_type}" == "include directive" ]]; then
            line_type="text"
        fi
    done

    # Sort, filter, colorize, and print all error messages.
    argparser_print_error_messages true false "${error_messages[@]}"

    # Print the usage message, then exit, if requested.
    printf '%s' "${usage_message}"

    if [[ "${exit}" == true ]]; then
        exit "${ARGPARSER_USAGE_EXIT_CODE}"
    fi
}

function argparser_print_version_message() {
    # Create and print a version message.
    #
    # Arguments:
    # - $1: whether to exit after printing
    #
    # Nonlocals:
    # - styles: the associative array containing the styles (read-only)
    #
    # Environment:
    # - ARGPARSER_SCRIPT_NAME (read-only)
    # - ARGPARSER_VERSION_EXIT_CODE (read-only)
    # - ARGPARSER_VERSION_NUMBER (read-only)

    # Define the local variables.
    local caption
    local exit
    local -a framed_array
    local script_name
    local translation
    local version_message

    # Read the argument.
    exit="$1"

    # Colorize the caption, the script name, and the version message.
    # If a version frame style is given, draw a frame around the
    # message, containing the colorized version caption as heading.
    # Otherwise, print the version message with script name and heading
    # in one line.
    argparser_translate "Version" "Version"
    caption="${translation}"

    argparser_colorize "${styles["script_name"]}" 1 script_name \
        "${ARGPARSER_SCRIPT_NAME}"
    argparser_colorize "${styles["version_text"]}" 1 version_message \
        "v${ARGPARSER_VERSION_NUMBER}"
    version_message="${script_name} ${version_message}"

    if [[ -n "${styles["version_frame"]}" ]]; then
        argparser_colorize "${styles["version_caption"]}" 1 caption \
            " ${caption} "
        argparser_draw_frame "${styles["version_frame"]}" 1 "array" \
            "${caption}" "${version_message}"
        printf '%s\n' "${framed_array[@]}"
    else
        argparser_colorize "${styles["version_caption"]}" 1 caption \
            "${caption}:"
        printf '%s %s\n' "${caption}" "${version_message}"
    fi

    # Exit, if requested.
    if [[ "${exit}" == true ]]; then
        exit "${ARGPARSER_VERSION_EXIT_CODE}"
    fi
}

function argparser_print_error_messages() {
    # Sort, filter, colorize, and print all error messages.
    #
    # Arguments:
    # - $1: whether to filter the messages
    # - $2: whether to exit after printing
    # - $@: the error messages
    #
    # Nonlocals:
    # - styles: the associative array containing the styles (read-only)
    #
    # Environment:
    # - ARGPARSER_MAX_WIDTH (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_SCRIPT_NAME (read-only)
    # - ARGPARSER_SILENCE_ERRORS (read-only)

    # Define the local variables.
    local caption
    local -a colorized_array
    local exit
    local -a error_messages
    local filter
    local -a filtered_array
    local -a folded_array
    local -a framed_array
    local indentation
    local -a padded_array
    local script_name
    local -a sorted_array
    local translation

    # Read the arguments.
    filter="$1"
    exit="$2"
    shift 2
    error_messages=("$@")

    # If there are no error messages or they shall not be emitted
    # (output), return or exit, which also effectively silences the
    # message.
    if (( "${#error_messages[@]}" == 0 )); then
        return
    elif [[ "${ARGPARSER_SILENCE_ERRORS}" == true ]]; then
        if [[ "${exit}" == true ]]; then
            exit "${ARGPARSER_ERROR_EXIT_CODE}"
        else
            return
        fi
    fi

    # Sort and filter the error messages.
    argparser_sort false "${error_messages[@]}"
    error_messages=("${sorted_array[@]}")

    if [[ "${filter}" == true ]]; then
        argparser_uniq "${error_messages[@]}"
        error_messages=("${filtered_array[@]}")
    fi

    # Colorize the caption, the script name, and the error messages.  If
    # an error frame style is given, fold and right-pad the messages,
    # then draw a frame around the block, containing the colorized error
    # caption as heading, and join the lines into a single string.
    # Otherwise, print each folded error message with script name and
    # heading as separate lines.
    argparser_translate "Error" "Error"
    caption="${translation}"

    argparser_colorize "${styles["script_name"]}" 2 script_name \
        "${ARGPARSER_SCRIPT_NAME}:"
    argparser_colorize "${styles["error_text"]}" 2 "array" \
        "${error_messages[@]#"${caption}: "}"
    error_messages=("${colorized_array[@]}")

    if [[ -n "${styles["error_frame"]}" ]]; then
        (( indentation = "${#ARGPARSER_SCRIPT_NAME}" + 2 ))

        if (( "${#error_messages[@]}" > 1 )); then
            argparser_translate "Errors" "Errors"
            caption="${translation}"
        fi

        argparser_colorize "${styles["error_caption"]}" 2 caption \
            " ${caption} "

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_WIDTH}" "${indentation}" \
            "${error_messages[@]/#/"${script_name} "}"
        argparser_pad "right" "auto" "${folded_array[@]}"
        argparser_draw_frame "${styles["error_frame"]}" 2 "array" \
            "${caption}" "${padded_array[@]}"
        printf '%s\n' "${framed_array[@]}"
    else
        (( indentation = "${#ARGPARSER_SCRIPT_NAME}" + "${#caption}" + 4 ))

        argparser_colorize "${styles["error_caption"]}" 2 caption "${caption}:"

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_WIDTH}" "${indentation}" \
            "${error_messages[@]/#/"${script_name} ${caption}" }"
        printf '%s\n' "${folded_array[@]}"
    fi >&2

    # Exit, if requested.
    if [[ "${exit}" == true ]]; then
        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    fi
}

function argparser_print_warning_messages() {
    # Sort, filter, colorize, and print all warning messages.
    #
    # Arguments:
    # - $1: whether to filter the messages
    # - $@: the warning messages
    #
    # Nonlocals:
    # - styles: the associative array containing the styles (read-only)
    #
    # Environment:
    # - ARGPARSER_MAX_WIDTH (read-only)
    # - ARGPARSER_SCRIPT_NAME (read-only)
    # - ARGPARSER_SILENCE_WARNINGS (read-only)

    # Define the local variables.
    local caption
    local -a colorized_array
    local filter
    local -a filtered_array
    local -a folded_array
    local -a framed_array
    local indentation
    local -a padded_array
    local script_name
    local -a sorted_array
    local translation
    local -a warning_messages

    # Read the arguments.
    filter="$1"
    shift
    warning_messages=("$@")

    # If there are no warning messages or they shall not be emitted
    # (output), return, which also effectively silences the message.
    if (( "${#warning_messages[@]}" == 0 )) \
        || [[ "${ARGPARSER_SILENCE_WARNINGS}" == true ]]
    then
        return
    fi

    # Sort and filter the warning messages.
    argparser_sort false "${warning_messages[@]}"
    warning_messages=("${sorted_array[@]}")

    if [[ "${filter}" == true ]]; then
        argparser_uniq "${warning_messages[@]}"
        warning_messages=("${filtered_array[@]}")
    fi

    # Colorize the caption, the script name, and the warning messages.
    # If a warning frame style is given, fold and right-pad the
    # messages, then draw a frame around the block, containing the
    # colorized warning caption as heading, and join the lines into a
    # single string.  Otherwise, print each folded warning message with
    # script name and heading as separate lines.
    argparser_translate "Warning" "Warning"
    caption="${translation}"

    argparser_colorize "${styles["script_name"]}" 2 script_name \
        "${ARGPARSER_SCRIPT_NAME}:"
    argparser_colorize "${styles["warning_text"]}" 2 "array" \
        "${warning_messages[@]#"${caption}: "}"
    warning_messages=("${colorized_array[@]}")

    if [[ -n "${styles["warning_frame"]}" ]]; then
        (( indentation = "${#ARGPARSER_SCRIPT_NAME}" + 2 ))

        if (( "${#warning_messages[@]}" > 1 )); then
            argparser_translate "Warnings" "Warnings"
            caption="${translation}"
        fi

        argparser_colorize "${styles["warning_caption"]}" 2 caption \
            " ${caption} "

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_WIDTH}" "${indentation}" \
            "${warning_messages[@]/#/"${script_name} "}"
        argparser_pad "right" "auto" "${folded_array[@]}"
        argparser_draw_frame "${styles["warning_frame"]}" 2 "array" \
            "${caption}" "${padded_array[@]}"
        printf '%s\n' "${framed_array[@]}"
    else
        (( indentation = "${#ARGPARSER_SCRIPT_NAME}" + "${#caption}" + 4 ))

        argparser_colorize "${styles["warning_caption"]}" 2 caption \
            "${caption}:"

        argparser_fold " =${ARGPARSER_ARG_DELIMITER_2}" \
            "${ARGPARSER_MAX_WIDTH}" "${indentation}" \
            "${warning_messages[@]/#/"${script_name} ${caption} "}"
        printf '%s\n' "${folded_array[@]}"
    fi >&2
}

function argparser_print_logo() {
    # Print the Argparser logo in ANSI art.

    # Define the local variables.
    local font_1
    local font_2
    local font_3
    local font_4
    local font_5
    local font_6
    local font_7
    local font_8
    local font_9
    local space

    # Set each letter's color as all primary and secondary colors,
    # traversing the color wheel for one and a half rounds.
    space="black,reverse"     # _ (whitespace)
    font_1="green,reverse"    # A
    font_2="cyan,reverse"     # R
    font_3="blue,reverse"     # G
    font_4="magenta,reverse"  # P
    font_5="red,reverse"      # A
    font_6="yellow,reverse"   # R
    font_7="green,reverse"    # S
    font_8="cyan,reverse"     # E
    font_9="blue,reverse"     # R

    # Output the first line, which is empty.
    argparser_colorize "${space}" 1 "print" "0000000000000000000000000"  # _
    argparser_colorize "${space}" 1 "print" "0000000000000000000000000"  # _
    argparser_colorize "${space}" 1 "print" "000000000000000000000000"   # _
    printf '\n'

    # Output the second line, containing the first of five lines of the
    # letters.
    argparser_colorize "${space}"  1 "print" "001"      # _, A
    argparser_colorize "${font_1}" 1 "print" "0000"     # A
    argparser_colorize "${space}"  1 "print" "0101"     # A, _, R
    argparser_colorize "${font_2}" 1 "print" "0100"     # R
    argparser_colorize "${space}"  1 "print" "1001"     # R, _, G
    argparser_colorize "${font_3}" 1 "print" "00011"    # G
    argparser_colorize "${space}"  1 "print" "101"      # _, P
    argparser_colorize "${font_4}" 1 "print" "0100"     # P
    argparser_colorize "${space}"  1 "print" "0001"     # P, _, A
    argparser_colorize "${font_5}" 1 "print" "0000"     # A
    argparser_colorize "${space}"  1 "print" "0101"     # A, _, R
    argparser_colorize "${font_6}" 1 "print" "0100"     # R
    argparser_colorize "${space}"  1 "print" "1001"     # R, _, S
    argparser_colorize "${font_7}" 1 "print" "01001"    # S
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_8}" 1 "print" "100010"   # E
    argparser_colorize "${space}"  1 "print" "101"      # _, R
    argparser_colorize "${font_9}" 1 "print" "0100"     # R
    argparser_colorize "${space}"  1 "print" "100"      # R, _
    printf '\n'

    # Output the third line, containing the second of five lines of the
    # letters.
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_1}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_1}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_2}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_2}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_3}" 1 "print" "10"       # G
    argparser_colorize "${space}"  1 "print" "001110"   # G, _
    argparser_colorize "${font_4}" 1 "print" "10"       # P
    argparser_colorize "${space}"  1 "print" "10"       # P
    argparser_colorize "${font_4}" 1 "print" "00"       # P
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_5}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_5}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_6}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_6}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_7}" 1 "print" "10"       # S
    argparser_colorize "${space}"  1 "print" "100110"   # S, _
    argparser_colorize "${font_8}" 1 "print" "10"       # E
    argparser_colorize "${space}"  1 "print" "001010"   # E, _
    argparser_colorize "${font_9}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_9}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    printf '\n'

    # Output the fourth line, containing the third of five lines of the
    # letters.
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_1}" 1 "print" "100000"   # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_2}" 1 "print" "101001"   # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_3}" 1 "print" "10001"    # G
    argparser_colorize "${space}"  1 "print" "110"      # G, _
    argparser_colorize "${font_4}" 1 "print" "10100"    # P
    argparser_colorize "${space}"  1 "print" "000"      # P, _
    argparser_colorize "${font_5}" 1 "print" "100000"   # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_6}" 1 "print" "101001"   # R
    argparser_colorize "${space}"  1 "print" "001"      # _, S
    argparser_colorize "${font_7}" 1 "print" "0100"     # S
    argparser_colorize "${space}"  1 "print" "110"      # S, _
    argparser_colorize "${font_8}" 1 "print" "100010"   # E
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_9}" 1 "print" "101001"   # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    printf '\n'

    # Output the fifth line, containing the fourth of five lines of the
    # letters.
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_1}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_1}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_2}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "1"        # R
    argparser_colorize "${font_2}" 1 "print" "00"       # R
    argparser_colorize "${space}"  1 "print" "100"      # R, _
    argparser_colorize "${font_3}" 1 "print" "10"       # G
    argparser_colorize "${space}"  1 "print" "00"       # G
    argparser_colorize "${font_3}" 1 "print" "11"       # G
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_4}" 1 "print" "10"       # P
    argparser_colorize "${space}"  1 "print" "100000"   # P, _
    argparser_colorize "${font_5}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_5}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_6}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "1"        # R
    argparser_colorize "${font_6}" 1 "print" "00"       # R
    argparser_colorize "${space}"  1 "print" "1001010"  # R, _, S
    argparser_colorize "${font_7}" 1 "print" "01"       # S
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_8}" 1 "print" "10"       # E
    argparser_colorize "${space}"  1 "print" "001010"   # E, _
    argparser_colorize "${font_9}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "1"        # R
    argparser_colorize "${font_9}" 1 "print" "00"       # R
    argparser_colorize "${space}"  1 "print" "100"      # R, _
    printf '\n'

    # Output the sixth line, containing the fifth of five lines of the
    # letters.
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_1}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_1}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_2}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_2}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "001"      # _, G
    argparser_colorize "${font_3}" 1 "print" "0001"     # G
    argparser_colorize "${space}"  1 "print" "110"      # G, _
    argparser_colorize "${font_4}" 1 "print" "10"       # P
    argparser_colorize "${space}"  1 "print" "100000"   # P, _
    argparser_colorize "${font_5}" 1 "print" "10"       # A
    argparser_colorize "${space}"  1 "print" "00"       # A
    argparser_colorize "${font_5}" 1 "print" "00"       # A
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_6}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_6}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    argparser_colorize "${font_7}" 1 "print" "10100"    # S
    argparser_colorize "${space}"  1 "print" "110"      # S, _
    argparser_colorize "${font_8}" 1 "print" "100010"   # E
    argparser_colorize "${space}"  1 "print" "10"       # _
    argparser_colorize "${font_9}" 1 "print" "10"       # R
    argparser_colorize "${space}"  1 "print" "10"       # R
    argparser_colorize "${font_9}" 1 "print" "01"       # R
    argparser_colorize "${space}"  1 "print" "00"       # _
    printf '\n'

    # Output the seventh line, which is empty again.
    argparser_colorize "${space}" 1 "print" "0000000000000000000000000"  # _
    argparser_colorize "${space}" 1 "print" "0000000000000000000000000"  # _
    argparser_colorize "${space}" 1 "print" "000000000000000000000000"   # _
    printf '\n'
}

# Define the main Argparser function.
function argparser_main() {
    # Run the Argparser, depending on the values of its environment
    # variables, to read, parse, and set the script's arguments.
    #
    # Environment:
    # - ARGPARSER_ARGS
    # - ARGPARSER_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_CONFIG_FILE (read-only)
    # - ARGPARSER_CREATE_ARG_DEF (read-only)
    # - ARGPARSER_DEBUG (read-only)
    # - ARGPARSER_ERROR_STYLE (read-only)
    # - ARGPARSER_HELP_ARG_GROUP
    # - ARGPARSER_HELP_DESCRIPTION
    # - ARGPARSER_HELP_STYLE (read-only)
    # - ARGPARSER_POSITIONAL_ARG_GROUP
    # - ARGPARSER_READ_ARGS (read-only)
    # - ARGPARSER_SET_ARGS (read-only)
    # - ARGPARSER_STYLE_FILE (read-only)
    # - ARGPARSER_TRANSLATION_FILE (read-only)
    # - ARGPARSER_UNSET_ARGS (read-only)
    # - ARGPARSER_UNSET_ENV_VARS (read-only)
    # - ARGPARSER_UNSET_FUNCTIONS (read-only)
    # - ARGPARSER_USAGE_STYLE (read-only)
    # - ARGPARSER_USE_STYLES
    # - ARGPARSER_USE_STYLES_IN_FILES (read-only)
    # - ARGPARSER_VERSION_STYLE (read-only)
    # - ARGPARSER_WARNING_STYLE (read-only)
    # - ARGPARSER_WRITE_ARGS (read-only)

    # Possibly, enable the debug mode.  Since at this point, the shell
    # option "nounset" may still be activated (from the parent script),
    # the test for the variable's existence is necessary.
    if [[ "$1" == "--debug" \
        || (-v ARGPARSER_DEBUG && "${ARGPARSER_DEBUG}" == true) ]]
    then
        argparser_toggle_debugger start
    fi

    # Define the local variables.
    local -A all_arg_groups
    local -A all_arg_numbers
    local -A all_choice_values
    local -A all_default_values
    local -A all_help_texts
    local -A all_long_options
    local -A all_notes
    local -a all_positional_args
    local -A all_resolved_choice_values
    local -A all_short_options
    local -A all_types
    local -A all_value_names
    local -A dictionary
    local is_extglob_set
    local is_self_parsing
    local is_sourced
    local -a script_args
    local -A styles
    local translation

    # Declare the remaining internal variables.  Since ${ARGPARSER_ARGS}
    # must be set in global scope within argparser_set_args, later, it's
    # useless declaring it as local, here.
    declare -a ARGPARSER_ARGS
    local argparser_version="1.3.2 \"Dasyprocta fuliginosa\""

    # Detect whether the Argparser is sourced or run as standalone
    # script.  In the former case, the second element of ${FUNCNAME[@]}
    # is "source".
    if (( "${#FUNCNAME[@]}" >= 2 )) && [[ "${FUNCNAME[1]}" == "source" ]]; then
        is_sourced=true
    else
        is_sourced=false
    fi

    # Locally disable errexit, nounset, and pipefail, and enable
    # extglob.  Since all functions are called from argparser_main, they
    # inherit the options.
    local -
    set +o errexit +o nounset +o pipefail
    shopt -q extglob
    is_extglob_set="$?"
    shopt -s extglob

    # Define the default styles, and set them to be disabled if the
    # non-empty environment variable ${NO_COLOR} is given, but neither
    # ${ARGPARSER_USE_STYLES} nor ${ARGPARSER_USE_STYLES_IN_FILES}.
    styles=(
        ["argument_group"]="cyan,bold"
        ["choice_values"]="yellow"
        ["default_text"]="italic"
        ["default_values"]="cyan,italic"
        ["deprecation_note"]="red,bold"
        ["description_text"]="italic"
        ["error_caption"]="red,bold,reverse"
        ["error_frame"]=""
        ["error_text"]="red"
        ["help_caption"]="green,bold"
        ["help_frame"]=""
        ["help_text"]="normal"
        ["long_options"]="magenta,bold"
        ["remark_text"]="italic"
        ["script_name"]="bold"
        ["short_options"]="green,bold"
        ["usage_caption"]="green,bold"
        ["usage_frame"]=""
        ["value_names"]="blue"
        ["version_caption"]="magenta,bold"
        ["version_frame"]=""
        ["version_text"]="normal"
        ["warning_caption"]="red,bold"
        ["warning_frame"]=""
        ["warning_text"]="red"
    )

    if [[ -v NO_COLOR \
        && -n "${NO_COLOR}" \
        && ! -v ARGPARSER_USE_STYLES \
        && ! -v ARGPARSER_USE_STYLES_IN_FILES ]]
    then
        ARGPARSER_USE_STYLES="never"
    fi

    # If ${ARGPARSER_CONFIG_FILE} isn't set to the empty string, read
    # the configuration file.
    if [[ -n "${ARGPARSER_CONFIG_FILE}" ]]; then
        argparser_read_configuration
    fi

    # Set the environment variables that aren't already set by the
    # calling script or environment or read from the configuration file
    # to prevent overriding them.  Modify the values for all variables
    # with special values.  Then, set the script's command-line
    # arguments (with the Argparser arguments being removed) as the
    # current command line.  Finally, reset the arrays holding the
    # arguments definition data.
    is_self_parsing=true
    argparser_set_env_vars "$@"
    argparser_modify_env_vars "$@"
    set -- "${script_args[@]}"
    is_self_parsing=false

    unset all_arg_groups
    unset all_arg_numbers
    unset all_choice_values
    unset all_default_values
    unset all_help_texts
    unset all_long_options
    unset all_notes
    unset all_positional_args
    unset all_resolved_choice_values
    unset all_short_options
    unset all_types
    unset all_value_names

    local -A all_arg_groups
    local -A all_arg_numbers
    local -A all_choice_values
    local -A all_default_values
    local -A all_help_texts
    local -A all_long_options
    local -A all_notes
    local -a all_positional_args
    local -A all_resolved_choice_values
    local -A all_short_options
    local -A all_types
    local -A all_value_names

    # If ${ARGPARSER_TRANSLATION_FILE} isn't set to the empty string,
    # read the translation file.  To be able to use the localized names
    # of ${ARGPARSER_HELP_DESCRIPTION}, ${ARGPARSER_HELP_ARG_GROUP}, and
    # ${ARGPARSER_POSITIONAL_ARG_GROUP} in the arguments definition and
    # help message, translate them.
    if [[ -n "${ARGPARSER_TRANSLATION_FILE}" ]]; then
        argparser_read_translation

        argparser_translate "Positional arguments" \
            "${ARGPARSER_POSITIONAL_ARG_GROUP}"
        ARGPARSER_POSITIONAL_ARG_GROUP="${translation}"

        argparser_translate "Help options" "${ARGPARSER_HELP_ARG_GROUP}"
        ARGPARSER_HELP_ARG_GROUP="${translation}"

        argparser_translate "Help description" "${ARGPARSER_HELP_DESCRIPTION}"
        ARGPARSER_HELP_DESCRIPTION="${translation}"
    fi

    # If ${ARGPARSER_STYLE_FILE} isn't set to the empty string, read the
    # style file.
    if [[ -n "${ARGPARSER_STYLE_FILE}" ]]; then
        argparser_read_styles
    fi

    # If ${ARGPARSER_CHECK_ENV_VARS} isn't set to "false", check if the
    # environment variables accord to their definition.  Since
    # ${ARGPARSER_CHECK_ENV_VARS} is, as any other environment variable,
    # yet unchecked, its value may be different from the expected "true"
    # or "false".  Hence, testing for "not false" is not the exact
    # opposite of testing for "true".  Even more, if
    # ${ARGPARSER_CHECK_ENV_VARS} is different from "true" and "false",
    # the test would be mandatory as it shows the environment variables
    # have been wrongly set.
    if [[ "${ARGPARSER_CHECK_ENV_VARS}" != false ]]; then
        argparser_check_env_vars
    fi

    # If the (deprecated) style environment variables are set, overwrite
    # the default styles and those from the style file.  Since the help
    # and usage message need the same message keys for their styles,
    # ${ARGPARSER_HELP_STYLE} overrides ${ARGPARSER_USAGE_STYLE}, if
    # both are given.  The script name style is needed for all message
    # types, where the value is overridden in the following order of
    # priority: warning < error < version < usage < help.
    if [[ -v ARGPARSER_WARNING_STYLE ]]; then
        styles["script_name"]="${ARGPARSER_WARNING_STYLE}"
        styles["warning_caption"]="${ARGPARSER_WARNING_STYLE}"
        styles["warning_text"]="${ARGPARSER_WARNING_STYLE}"
    fi

    if [[ -v ARGPARSER_ERROR_STYLE ]]; then
        styles["error_caption"]="${ARGPARSER_ERROR_STYLE}"
        styles["error_text"]="${ARGPARSER_ERROR_STYLE}"
        styles["script_name"]="${ARGPARSER_ERROR_STYLE}"
    fi

    if [[ -v ARGPARSER_VERSION_STYLE ]]; then
        styles["script_name"]="${ARGPARSER_VERSION_STYLE}"
        styles["version_caption"]="${ARGPARSER_VERSION_STYLE}"
        styles["version_text"]="${ARGPARSER_VERSION_STYLE}"
    fi

    if [[ -v ARGPARSER_USAGE_STYLE ]]; then
        styles["choice_values"]="${ARGPARSER_USAGE_STYLE}"
        styles["long_options"]="${ARGPARSER_USAGE_STYLE}"
        styles["script_name"]="${ARGPARSER_USAGE_STYLE}"
        styles["short_options"]="${ARGPARSER_USAGE_STYLE}"
        styles["usage_caption"]="${ARGPARSER_USAGE_STYLE}"
        styles["value_names"]="${ARGPARSER_USAGE_STYLE}"
    fi

    if [[ -v ARGPARSER_HELP_STYLE ]]; then
        styles["argument_group"]="${ARGPARSER_HELP_STYLE}"
        styles["choice_values"]="${ARGPARSER_HELP_STYLE}"
        styles["default_text"]="${ARGPARSER_HELP_STYLE}"
        styles["default_values"]="${ARGPARSER_HELP_STYLE}"
        styles["deprecation_note"]="${ARGPARSER_HELP_STYLE}"
        styles["description_text"]="${ARGPARSER_HELP_STYLE}"
        styles["help_caption"]="${ARGPARSER_HELP_STYLE}"
        styles["help_text"]="${ARGPARSER_HELP_STYLE}"
        styles["long_options"]="${ARGPARSER_HELP_STYLE}"
        styles["remark_text"]="${ARGPARSER_HELP_STYLE}"
        styles["script_name"]="${ARGPARSER_HELP_STYLE}"
        styles["short_options"]="${ARGPARSER_HELP_STYLE}"
        styles["value_names"]="${ARGPARSER_HELP_STYLE}"
    fi

    # If ${ARGPARSER_CREATE_ARG_DEF} is set to "true", create the
    # arguments definition, then exit, since the creation should not
    # happen alongside the argument parsing.
    if [[ "${ARGPARSER_CREATE_ARG_DEF}" == true ]]; then
        argparser_create_args_definition
        exit
    fi

    # If ${ARGPARSER_READ_ARGS} is set to "true", read and parse the
    # arguments.
    if [[ "${ARGPARSER_READ_ARGS}" == true ]]; then
        argparser_parse_args "$@"
    fi

    # If ${ARGPARSER_UNSET_ARGS} is set to "true", disable all arguments
    # given to the calling script, effectively unsetting the command
    # line.
    if [[ "${ARGPARSER_UNSET_ARGS}" == true ]]; then
        set --
    fi

    # If ${ARGPARSER_SET_ARGS} is set to "true", set the arguments as
    # variables to the current environment.
    if [[ "${ARGPARSER_SET_ARGS}" == true ]]; then
        argparser_set_args
    fi

    # If ${ARGPARSER_WRITE_ARGS} is set to "true", write the arguments
    # to STDOUT.
    if [[ "${ARGPARSER_WRITE_ARGS}" == true ]]; then
        argparser_write_args
    fi

    # Possibly, disable the debug mode.
    if [[ "$1" == "--debug" || "${ARGPARSER_DEBUG}" == true ]]; then
        argparser_toggle_debugger stop
    fi

    # If ${ARGPARSER_UNSET_FUNCTIONS} is set to "true", unset all
    # Argparser functions.  The names are used instead of a glob to
    # limit side effects with potentially same-named functions (i.e.,
    # those starting with "argparser_") from the calling script that
    # stand in no relation to the Argparser.
    if [[ "${ARGPARSER_UNSET_FUNCTIONS}" == true ]]; then
        unset -f argparser_add_args_definition_help_options
        unset -f argparser_check_arg_values
        unset -f argparser_check_args_definition_names
        unset -f argparser_check_args_definition_option_values
        unset -f argparser_check_args_definition_positional_values
        unset -f argparser_check_bash_version
        unset -f argparser_check_env_vars
        unset -f argparser_check_file
        unset -f argparser_check_shell
        unset -f argparser_check_styles
        unset -f argparser_colorize
        unset -f argparser_count
        unset -f argparser_create_args_definition
        unset -f argparser_create_help_message
        unset -f argparser_create_usage_message
        unset -f argparser_draw_frame
        unset -f argparser_fold
        unset -f argparser_get_arg_key
        unset -f argparser_get_max
        unset -f argparser_get_max_width
        unset -f argparser_get_option_names
        unset -f argparser_in_array
        unset -f argparser_is_alpha
        unset -f argparser_is_bool
        unset -f argparser_is_char
        unset -f argparser_is_float
        unset -f argparser_is_identifier
        unset -f argparser_is_int
        unset -f argparser_is_uint
        unset -f argparser_join
        unset -f argparser_main
        unset -f argparser_modify_env_vars
        unset -f argparser_pad
        unset -f argparser_parse_arg
        unset -f argparser_parse_args
        unset -f argparser_parse_args_definition
        unset -f argparser_parse_long_option
        unset -f argparser_parse_positional_args
        unset -f argparser_parse_short_option
        unset -f argparser_print_error_messages
        unset -f argparser_print_help_message
        unset -f argparser_print_logo
        unset -f argparser_print_usage_message
        unset -f argparser_print_version_message
        unset -f argparser_print_warning_messages
        unset -f argparser_quicksort
        unset -f argparser_read_args_definition
        unset -f argparser_read_configuration
        unset -f argparser_read_styles
        unset -f argparser_read_translation
        unset -f argparser_seq
        unset -f argparser_set_args
        unset -f argparser_set_env_var_defaults
        unset -f argparser_set_env_vars
        unset -f argparser_sort
        unset -f argparser_toggle_debugger
        unset -f argparser_translate
        unset -f argparser_trim
        unset -f argparser_uncolorize
        unset -f argparser_uniq
        unset -f argparser_write_args
    fi

    # If ${ARGPARSER_UNSET_ENV_VARS} is set to "true", unset all
    # Argparser environment variables.  Again, the names are used
    # instead of a glob to limit side effects with potentially
    # same-named variables (i.e., those starting with "ARGPARSER_") from
    # the calling script that stand in no relation to the Argparser.
    if [[ "${ARGPARSER_UNSET_ENV_VARS}" == true ]]; then
        unset ARGPARSER_ADD_HELP
        unset ARGPARSER_ADD_USAGE
        unset ARGPARSER_ADD_VERSION
        unset ARGPARSER_ALLOW_ARG_INTERMIXING
        unset ARGPARSER_ALLOW_FLAG_INVERSION
        unset ARGPARSER_ALLOW_FLAG_NEGATION
        unset ARGPARSER_ALLOW_OPTION_ABBREVIATION
        unset ARGPARSER_ALLOW_OPTION_MERGING
        unset ARGPARSER_ARG_ARRAY_NAME
        unset ARGPARSER_ARG_DEF_FILE
        unset ARGPARSER_ARG_DELIMITER_1
        unset ARGPARSER_ARG_DELIMITER_2
        unset ARGPARSER_ARGS
        unset ARGPARSER_CHECK_ARG_DEF
        unset ARGPARSER_CHECK_ENV_VARS
        unset ARGPARSER_CONFIG_FILE
        unset ARGPARSER_COUNT_FLAGS
        unset ARGPARSER_CREATE_ARG_DEF
        unset ARGPARSER_DEBUG
        unset ARGPARSER_ERROR_EXIT_CODE
        unset ARGPARSER_ERROR_STYLE
        unset ARGPARSER_HELP_ARG_GROUP
        unset ARGPARSER_HELP_DESCRIPTION
        unset ARGPARSER_HELP_EXIT_CODE
        unset ARGPARSER_HELP_FILE
        unset ARGPARSER_HELP_FILE_INCLUDE_CHAR
        unset ARGPARSER_HELP_FILE_KEEP_COMMENTS
        unset ARGPARSER_HELP_OPTIONS
        unset ARGPARSER_HELP_STYLE
        unset ARGPARSER_LANGUAGE
        unset ARGPARSER_MAX_COL_WIDTH_1
        unset ARGPARSER_MAX_COL_WIDTH_2
        unset ARGPARSER_MAX_COL_WIDTH_3
        unset ARGPARSER_MAX_WIDTH
        unset ARGPARSER_POSITIONAL_ARG_GROUP
        unset ARGPARSER_READ_ARGS
        unset ARGPARSER_SCRIPT_NAME
        unset ARGPARSER_SET_ARGS
        unset ARGPARSER_SET_ARRAYS
        unset ARGPARSER_SILENCE_ERRORS
        unset ARGPARSER_SILENCE_WARNINGS
        unset ARGPARSER_STYLE_FILE
        unset ARGPARSER_TRANSLATION_FILE
        unset ARGPARSER_UNSET_ARGS
        unset ARGPARSER_UNSET_ENV_VARS
        unset ARGPARSER_UNSET_FUNCTIONS
        unset ARGPARSER_USAGE_EXIT_CODE
        unset ARGPARSER_USAGE_FILE
        unset ARGPARSER_USAGE_FILE_INCLUDE_CHAR
        unset ARGPARSER_USAGE_FILE_KEEP_COMMENTS
        unset ARGPARSER_USAGE_MESSAGE_OPTION_TYPE
        unset ARGPARSER_USAGE_MESSAGE_ORIENTATION
        unset ARGPARSER_USAGE_OPTIONS
        unset ARGPARSER_USAGE_STYLE
        unset ARGPARSER_USE_LONG_OPTIONS
        unset ARGPARSER_USE_SHORT_OPTIONS
        unset ARGPARSER_USE_STYLES
        unset ARGPARSER_USE_STYLES_IN_FILES
        unset ARGPARSER_VERSION_EXIT_CODE
        unset ARGPARSER_VERSION_NUMBER
        unset ARGPARSER_VERSION_OPTIONS
        unset ARGPARSER_VERSION_STYLE
        unset ARGPARSER_WARNING_STYLE
        unset ARGPARSER_WRITE_ARGS
    fi

    # Possibly disable extglob, if it was previously unset.
    if (( is_extglob_set == 1 )); then
        shopt -u extglob
    fi
}

# Run the Argparser.
argparser_main "$@"