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-11-12

# TODO: Output a warning message when options in the configuration file
#       are set that don't correspond to Argparser environment
#       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 5-digit line number, the currently executing
        # function's name (padded to the width of the largest name,
        # currently 49 characters), and the command to be executed, for
        # any command.  Replace newlines in the commands by their ANSI-C
        # quoting form ("$'\n'").
        # Note that Bash single-quotes newlines when they are separate
        # arguments to a command (to recognize them as semantic, and not
        # as bare whitespace), but not when they are, e.g., part of a
        # parameter expansion.  Thus, the printed command in the debug
        # output may not be exactly identical to the actually executed
        # one, or not runnable at all.
        trap_action='printf "Line %5d in %-49s %s\n" "${LINENO}" '
        trap_action+='"${FUNCNAME[0]:-main}" '
        trap_action+='"${BASH_COMMAND//"'$'\n''"/"'"\\$'\\n'"'"}" >&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_ # ShellCheck scope issue with associative array "colors".
    local -a corner_styles
    local -a line_styles
    local -a line_widths
    local style_request
    local -a style_requests
    local -a text_styles

    # Read the arguments.
    check_type="$1"
    style_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=(
        "ASCII"
        "angular"
        "rounded"
        "double"
    )

    line_styles=(
        "ASCII"
        "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 style_requests \
        <<< "${style_requests}"

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

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

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

        for style_request in "${style_requests[@]}"; do
            if ! argparser_in_array "${style_request}" "${colors_[@]}" \
                "${text_styles[@]}"
            then
                style_request="${style_request#bright_}"
                style_request="${style_request%@(_bg|_fg)}"
                if ! argparser_in_array "${style_request}" "${colors_[@]}"
                then
                    return 1
                fi
            fi
        done
    elif [[ "${check_type}" == "colors, frame styles" ]]; then
        for style_request in "${style_requests[@]}"; do
            if ! argparser_in_array "${style_request}" "${colors_[@]}" \
                "${corner_styles[@]}" "${line_styles[@]}" "${line_widths[@]}"
            then
                style_request="${style_request#bright_}"
                style_request="${style_request%@(_bg|_fg)}"
                if ! argparser_in_array "${style_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
    local width

    # 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" 1 "${padded_array[@]}"
    if [[ "${side}" == "left" ]]; then
        for i in "${!padded_array[@]}"; do
            (( width = max_width - "${#uncolorized_array[i]}" ))
            if (( width > 0 )); then
                printf -v whitespace '%*s' "${width}" ""
                padded_array[i]="${whitespace}${padded_array[i]}"
            fi
        done
    else
        for i in "${!padded_array[@]}"; do
            (( width = max_width - "${#uncolorized_array[i]}" ))
            if (( width > 0 )); then
                printf -v whitespace '%*s' "${width}" ""
                padded_array[i]="${padded_array[i]}${whitespace}"
            fi
        done
    fi
}

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" 1 "${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_id
    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_id="$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_id}" "${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" 1 "${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_COLORS (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
    local file_descriptor
    local i
    local joined_array
    local -A styles
    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 arrays with colors and styles, and their
    # corresponding Select Graphic Rendition (SGR) ANSI escape sequence
    # codes.
    colors=(
        [black]=30
        [red]=31
        [green]=32
        [yellow]=33
        [blue]=34
        [magenta]=35
        [cyan]=36
        [white]=37
    )

    styles=(
        [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 styles (and possibly colors) are enabled.  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
                # Bright background color.
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    style_request="${style_request#bright_}"
                    style_request="${style_request%_bg}"
                    (( ansi_code = "${colors[${style_request}]}" + 70 ))
                    style+=";${ansi_code}"
                fi
            elif [[ "${style_request}" == "bright_"*"_fg" ]]; then
                # Bright foreground color.
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    style_request="${style_request#bright_}"
                    style_request="${style_request%_fg}"
                    (( ansi_code = "${colors[${style_request}]}" + 60 ))
                    style+=";${ansi_code}"
                fi
            elif [[ "${style_request}" == "bright_"* ]]; then
                # Bright foreground color without "fg" qualifier.
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    style_request="${style_request#bright_}"
                    (( ansi_code = "${colors[${style_request}]}" + 60 ))
                    style+=";${ansi_code}"
                fi
            elif [[ "${style_request}" == *"_bg" ]]; then
                # Background color.
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    style_request="${style_request%_bg}"
                    (( ansi_code = "${colors[${style_request}]}" + 10 ))
                    style+=";${ansi_code}"
                fi
            elif [[ "${style_request}" == *"_fg" ]]; then
                # Foreground color.
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    style_request="${style_request%_fg}"
                    ansi_code="${colors[${style_request}]}"
                    style+=";${ansi_code}"
                fi
            elif [[ -n "${colors[${style_request}]+set}" ]]; then
                # Foreground color without "fg" qualifier..
                if [[ "${ARGPARSER_USE_COLORS}" == true ]]; then
                    ansi_code="${colors[${style_request}]}"
                    style+=";${ansi_code}"
                fi
            else
                # Style.
                ansi_code="${styles[${style_request}]}"
                style+=";${ansi_code}"
            fi

        done
        style+="m"

        if [[ "${style}" != $'\e[0m' ]]; then
            for i in "${!colorized_array[@]}"; do
                if [[ -n "${colorized_array[i]}" ]]; then
                    colorized_array[i]="${style}${colorized_array[i]}"$'\e[0m'
                fi
            done
        fi
    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 2
    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=(
        "ASCII"
        "angular"
        "rounded"
        "double"
    )

    line_style="solid"
    line_styles=(
        "ASCII"
        "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}" == "ASCII" ]]; then
        frame_chars["top-left"]="+"
        frame_chars["top-right"]="+"
        frame_chars["bottom-left"]="+"
        frame_chars["bottom-right"]="+"
    elif [[ "${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}" == "ASCII" ]]; then
        frame_chars["horizontal"]="-"
        frame_chars["vertical"]="|"
    elif [[ "${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" "${file_descriptor}" "${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 "${file_descriptor}" \
                "${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
}

function argparser_cleanup() {
    # Unset (clean up) the Argparser functions and environment variables.
    #
    # Environment:
    # - ARGPARSER_UNSET_ENV_VARS (read-only)
    # - ARGPARSER_UNSET_FUNCTIONS (read-only)

    # Possibly, unset all Argparser functions (by name to limit side
    # effects with potentially same-named functions starting with
    # "argparser_" from the calling script/environment that stand in no
    # relation to the Argparser).
    if [[ "${ARGPARSER_UNSET_FUNCTIONS}" == true ]]; then
        unset -f \
            argparser_add_args_definition_help_options \
            argparser_check_arg_values \
            argparser_check_args_definition_names \
            argparser_check_args_definition_option_values \
            argparser_check_args_definition_positional_values \
            argparser_check_bash_version \
            argparser_check_env_vars \
            argparser_check_file \
            argparser_check_shell \
            argparser_check_styles \
            argparser_cleanup \
            argparser_colorize \
            argparser_count \
            argparser_create_args_definition \
            argparser_create_help_message \
            argparser_create_usage_message \
            argparser_define_env_vars \
            argparser_draw_frame \
            argparser_fold \
            argparser_get_arg_id \
            argparser_get_args_definition \
            argparser_get_display_names \
            argparser_get_max \
            argparser_get_max_width \
            argparser_in_array \
            argparser_is_alpha \
            argparser_is_bool \
            argparser_is_char \
            argparser_is_float \
            argparser_is_identifier \
            argparser_is_int \
            argparser_is_uint \
            argparser_join \
            argparser_main \
            argparser_modify_env_vars \
            argparser_pad \
            argparser_parse_arg \
            argparser_parse_args \
            argparser_parse_args_definition \
            argparser_parse_long_option \
            argparser_parse_positional_args \
            argparser_parse_short_option \
            argparser_print_error_messages \
            argparser_print_help_message \
            argparser_print_logo \
            argparser_print_usage_message \
            argparser_print_version_message \
            argparser_print_warning_messages \
            argparser_quicksort \
            argparser_read_args_definition \
            argparser_read_configuration \
            argparser_read_styles \
            argparser_read_translation \
            argparser_seq \
            argparser_set_args \
            argparser_set_env_var_defaults \
            argparser_set_env_vars \
            argparser_sort \
            argparser_toggle_debugger \
            argparser_translate \
            argparser_uncolorize \
            argparser_uniq \
            argparser_write_args
    fi

    # Likewise, possibly unset all Argparser environment variables.
    if [[ "${ARGPARSER_UNSET_ENV_VARS}" == true ]]; then
        unset -v \
            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_ALLOW_POSITIONAL_DELIMITER_END \
            ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START \
            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_FLAG_NEGATION_PREFIXES \
            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_SUBCOMMAND_GROUP \
            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_COLORS \
            ARGPARSER_USE_LONG_OPTIONS \
            ARGPARSER_USE_SHORT_OPTIONS \
            ARGPARSER_USE_STYLES \
            ARGPARSER_USE_STYLES_IN_FILES \
            ARGPARSER_USE_UNICODE \
            ARGPARSER_VERSION_EXIT_CODE \
            ARGPARSER_VERSION_NUMBER \
            ARGPARSER_VERSION_OPTIONS \
            ARGPARSER_VERSION_STYLE \
            ARGPARSER_WARNING_STYLE \
            ARGPARSER_WRITE_ARGS \
            argparser_logo
    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_ALLOW_POSITIONAL_DELIMITER_END
    # - ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START
    # - 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_FLAG_NEGATION_PREFIXES
    # - 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_SUBCOMMAND_GROUP
    # - 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_COLORS
    # - ARGPARSER_USE_LONG_OPTIONS
    # - ARGPARSER_USE_SHORT_OPTIONS
    # - ARGPARSER_USE_STYLES
    # - ARGPARSER_USE_STYLES_IN_FILES
    # - ARGPARSER_USE_UNICODE
    # - 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 value
    local var

    # Check if the configuration file exists and is readable.  Else,
    # output an error message and exit.  Since at this point of
    # invocation, 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%%=*}"
            var="${var##+( )}"
            var="${var%%+( )}"
            var="${var//-/_}"
            var="${var// /_}"
            var="ARGPARSER_${var^^}"

            value="${line#*=}"
            value="${value##+( )}"
            value="${value%%+( )}"
            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_define_env_vars() {
    # Define the Argparser environment variables.
    #
    # 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

    # Define ${ARGPARSER_ADD_HELP}.
             all_short_options["ARGPARSER_ADD_HELP"]=""
              all_long_options["ARGPARSER_ADD_HELP"]="add-help"
               all_value_names["ARGPARSER_ADD_HELP"]=""
            all_default_values["ARGPARSER_ADD_HELP"]="true"
             all_choice_values["ARGPARSER_ADD_HELP"]=""
    all_resolved_choice_values["ARGPARSER_ADD_HELP"]=""
                     all_types["ARGPARSER_ADD_HELP"]="bool"
               all_arg_numbers["ARGPARSER_ADD_HELP"]="0"
                all_arg_groups["ARGPARSER_ADD_HELP"]="General options"
                     all_notes["ARGPARSER_ADD_HELP"]=""
                all_help_texts["ARGPARSER_ADD_HELP"]="add ARGPARSER_HELP_OPTIONS as flags to call the help message"

    # Define ${ARGPARSER_ADD_USAGE}.
             all_short_options["ARGPARSER_ADD_USAGE"]=""
              all_long_options["ARGPARSER_ADD_USAGE"]="add-usage"
               all_value_names["ARGPARSER_ADD_USAGE"]=""
            all_default_values["ARGPARSER_ADD_USAGE"]="true"
             all_choice_values["ARGPARSER_ADD_USAGE"]=""
    all_resolved_choice_values["ARGPARSER_ADD_USAGE"]=""
                     all_types["ARGPARSER_ADD_USAGE"]="bool"
               all_arg_numbers["ARGPARSER_ADD_USAGE"]="0"
                all_arg_groups["ARGPARSER_ADD_USAGE"]="General options"
                     all_notes["ARGPARSER_ADD_USAGE"]=""
                all_help_texts["ARGPARSER_ADD_USAGE"]="add ARGPARSER_USAGE_OPTIONS as flags to call the usage message"

    # Define ${ARGPARSER_ADD_VERSION}.
             all_short_options["ARGPARSER_ADD_VERSION"]=""
              all_long_options["ARGPARSER_ADD_VERSION"]="add-version"
               all_value_names["ARGPARSER_ADD_VERSION"]=""
            all_default_values["ARGPARSER_ADD_VERSION"]="true"
             all_choice_values["ARGPARSER_ADD_VERSION"]=""
    all_resolved_choice_values["ARGPARSER_ADD_VERSION"]=""
                     all_types["ARGPARSER_ADD_VERSION"]="bool"
               all_arg_numbers["ARGPARSER_ADD_VERSION"]="0"
                all_arg_groups["ARGPARSER_ADD_VERSION"]="General options"
                     all_notes["ARGPARSER_ADD_VERSION"]=""
                all_help_texts["ARGPARSER_ADD_VERSION"]="add ARGPARSER_VERSION_OPTIONS as flags to call the version message"

    # Define ${ARGPARSER_ALLOW_ARG_INTERMIXING}.
             all_short_options["ARGPARSER_ALLOW_ARG_INTERMIXING"]=""
              all_long_options["ARGPARSER_ALLOW_ARG_INTERMIXING"]="allow-arg-intermixing"
               all_value_names["ARGPARSER_ALLOW_ARG_INTERMIXING"]=""
            all_default_values["ARGPARSER_ALLOW_ARG_INTERMIXING"]="true"
             all_choice_values["ARGPARSER_ALLOW_ARG_INTERMIXING"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_ARG_INTERMIXING"]=""
                     all_types["ARGPARSER_ALLOW_ARG_INTERMIXING"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_ARG_INTERMIXING"]="0"
                all_arg_groups["ARGPARSER_ALLOW_ARG_INTERMIXING"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_ARG_INTERMIXING"]=""
                all_help_texts["ARGPARSER_ALLOW_ARG_INTERMIXING"]="allow the user to intermix positional and keyword arguments"

    # Define ${ARGPARSER_ALLOW_FLAG_INVERSION}.
             all_short_options["ARGPARSER_ALLOW_FLAG_INVERSION"]=""
              all_long_options["ARGPARSER_ALLOW_FLAG_INVERSION"]="allow-flag-inversion"
               all_value_names["ARGPARSER_ALLOW_FLAG_INVERSION"]=""
            all_default_values["ARGPARSER_ALLOW_FLAG_INVERSION"]="true"
             all_choice_values["ARGPARSER_ALLOW_FLAG_INVERSION"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_FLAG_INVERSION"]=""
                     all_types["ARGPARSER_ALLOW_FLAG_INVERSION"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_FLAG_INVERSION"]="0"
                all_arg_groups["ARGPARSER_ALLOW_FLAG_INVERSION"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_FLAG_INVERSION"]=""
                all_help_texts["ARGPARSER_ALLOW_FLAG_INVERSION"]="allow the user to invert flags by prefixing them with \"+\" (short options) or \"++\" (long options)"

    # Define ${ARGPARSER_ALLOW_FLAG_NEGATION}.
             all_short_options["ARGPARSER_ALLOW_FLAG_NEGATION"]=""
              all_long_options["ARGPARSER_ALLOW_FLAG_NEGATION"]="allow-flag-negation"
               all_value_names["ARGPARSER_ALLOW_FLAG_NEGATION"]=""
            all_default_values["ARGPARSER_ALLOW_FLAG_NEGATION"]="true"
             all_choice_values["ARGPARSER_ALLOW_FLAG_NEGATION"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_FLAG_NEGATION"]=""
                     all_types["ARGPARSER_ALLOW_FLAG_NEGATION"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_FLAG_NEGATION"]="0"
                all_arg_groups["ARGPARSER_ALLOW_FLAG_NEGATION"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_FLAG_NEGATION"]=""
                all_help_texts["ARGPARSER_ALLOW_FLAG_NEGATION"]="allow the user to negate long-option flags by prefixing them with one of the \"ARGPARSER_FLAG_NEGATION_PREFIXES\""

    # Define ${ARGPARSER_ALLOW_OPTION_ABBREVIATION}.
             all_short_options["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]=""
              all_long_options["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="allow-option-abbreviation"
               all_value_names["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]=""
            all_default_values["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="false"
             all_choice_values["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]=""
                     all_types["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="0"
                all_arg_groups["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]=""
                all_help_texts["ARGPARSER_ALLOW_OPTION_ABBREVIATION"]="allow the user to give long option names in abbreviated form"

    # Define ${ARGPARSER_ALLOW_OPTION_MERGING}.
             all_short_options["ARGPARSER_ALLOW_OPTION_MERGING"]=""
              all_long_options["ARGPARSER_ALLOW_OPTION_MERGING"]="allow-option-merging"
               all_value_names["ARGPARSER_ALLOW_OPTION_MERGING"]=""
            all_default_values["ARGPARSER_ALLOW_OPTION_MERGING"]="false"
             all_choice_values["ARGPARSER_ALLOW_OPTION_MERGING"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_OPTION_MERGING"]=""
                     all_types["ARGPARSER_ALLOW_OPTION_MERGING"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_OPTION_MERGING"]="0"
                all_arg_groups["ARGPARSER_ALLOW_OPTION_MERGING"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_OPTION_MERGING"]=""
                all_help_texts["ARGPARSER_ALLOW_OPTION_MERGING"]="allow the user to give short option names in merged (concatenated) form"

    # Define ${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}.
             all_short_options["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]=""
              all_long_options["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="allow-positional-delimiter-end"
               all_value_names["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]=""
            all_default_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="true"
             all_choice_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]=""
                     all_types["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="0"
                all_arg_groups["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]=""
                all_help_texts["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END"]="allow the user to mark the end of the positional-arguments-only part by a doubled plus sign (\"++\")"

    # Define ${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START}.
             all_short_options["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]=""
              all_long_options["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="allow-positional-delimiter-start"
               all_value_names["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]=""
            all_default_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="true"
             all_choice_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]=""
    all_resolved_choice_values["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]=""
                     all_types["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="bool"
               all_arg_numbers["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="0"
                all_arg_groups["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="Parsing options"
                     all_notes["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]=""
                all_help_texts["ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START"]="allow the user to mark the start of the positional-arguments-only part by a doubled hyphen (\"--\")"

    # Define ${ARGPARSER_ARG_ARRAY_NAME}.
             all_short_options["ARGPARSER_ARG_ARRAY_NAME"]=""
              all_long_options["ARGPARSER_ARG_ARRAY_NAME"]="arg-array-name"
               all_value_names["ARGPARSER_ARG_ARRAY_NAME"]="NAME"
            all_default_values["ARGPARSER_ARG_ARRAY_NAME"]="args"
             all_choice_values["ARGPARSER_ARG_ARRAY_NAME"]=""
    all_resolved_choice_values["ARGPARSER_ARG_ARRAY_NAME"]=""
                     all_types["ARGPARSER_ARG_ARRAY_NAME"]="str"
               all_arg_numbers["ARGPARSER_ARG_ARRAY_NAME"]="1"
                all_arg_groups["ARGPARSER_ARG_ARRAY_NAME"]="Parsing options"
                     all_notes["ARGPARSER_ARG_ARRAY_NAME"]=""
                all_help_texts["ARGPARSER_ARG_ARRAY_NAME"]="the indexed array for the raw arguments and the associative array for the parsed arguments"

    # Define ${ARGPARSER_ARG_DEF_FILE}.
             all_short_options["ARGPARSER_ARG_DEF_FILE"]=""
              all_long_options["ARGPARSER_ARG_DEF_FILE"]="arg-def-file"
               all_value_names["ARGPARSER_ARG_DEF_FILE"]="FILE"
            all_default_values["ARGPARSER_ARG_DEF_FILE"]="''"
             all_choice_values["ARGPARSER_ARG_DEF_FILE"]=""
    all_resolved_choice_values["ARGPARSER_ARG_DEF_FILE"]=""
                     all_types["ARGPARSER_ARG_DEF_FILE"]="file"
               all_arg_numbers["ARGPARSER_ARG_DEF_FILE"]="1"
                all_arg_groups["ARGPARSER_ARG_DEF_FILE"]="General options"
                     all_notes["ARGPARSER_ARG_DEF_FILE"]=""
                all_help_texts["ARGPARSER_ARG_DEF_FILE"]="the path to a file holding the definition of the arguments"

    # Define ${ARGPARSER_ARG_DELIMITER_1}.
             all_short_options["ARGPARSER_ARG_DELIMITER_1"]=""
              all_long_options["ARGPARSER_ARG_DELIMITER_1"]="arg-delimiter-1"
               all_value_names["ARGPARSER_ARG_DELIMITER_1"]="CHAR"
            all_default_values["ARGPARSER_ARG_DELIMITER_1"]="|"
             all_choice_values["ARGPARSER_ARG_DELIMITER_1"]=""
    all_resolved_choice_values["ARGPARSER_ARG_DELIMITER_1"]=""
                     all_types["ARGPARSER_ARG_DELIMITER_1"]="char"
               all_arg_numbers["ARGPARSER_ARG_DELIMITER_1"]="1"
                all_arg_groups["ARGPARSER_ARG_DELIMITER_1"]="General options"
                     all_notes["ARGPARSER_ARG_DELIMITER_1"]=""
                all_help_texts["ARGPARSER_ARG_DELIMITER_1"]="the primary delimiter that separates the fields in the arguments definition"

    # Define ${ARGPARSER_ARG_DELIMITER_2}.
             all_short_options["ARGPARSER_ARG_DELIMITER_2"]=""
              all_long_options["ARGPARSER_ARG_DELIMITER_2"]="arg-delimiter-2"
               all_value_names["ARGPARSER_ARG_DELIMITER_2"]="CHAR"
            all_default_values["ARGPARSER_ARG_DELIMITER_2"]=","
             all_choice_values["ARGPARSER_ARG_DELIMITER_2"]=""
    all_resolved_choice_values["ARGPARSER_ARG_DELIMITER_2"]=""
                     all_types["ARGPARSER_ARG_DELIMITER_2"]="char"
               all_arg_numbers["ARGPARSER_ARG_DELIMITER_2"]="1"
                all_arg_groups["ARGPARSER_ARG_DELIMITER_2"]="General options"
                     all_notes["ARGPARSER_ARG_DELIMITER_2"]=""
                all_help_texts["ARGPARSER_ARG_DELIMITER_2"]="the secondary delimiter that separates the elements of sequences in the arguments definition"

    # Define ${ARGPARSER_CHECK_ARG_DEF}.
             all_short_options["ARGPARSER_CHECK_ARG_DEF"]=""
              all_long_options["ARGPARSER_CHECK_ARG_DEF"]="check-arg-def"
               all_value_names["ARGPARSER_CHECK_ARG_DEF"]=""
            all_default_values["ARGPARSER_CHECK_ARG_DEF"]="false"
             all_choice_values["ARGPARSER_CHECK_ARG_DEF"]=""
    all_resolved_choice_values["ARGPARSER_CHECK_ARG_DEF"]=""
                     all_types["ARGPARSER_CHECK_ARG_DEF"]="bool"
               all_arg_numbers["ARGPARSER_CHECK_ARG_DEF"]="0"
                all_arg_groups["ARGPARSER_CHECK_ARG_DEF"]="General options"
                     all_notes["ARGPARSER_CHECK_ARG_DEF"]=""
                all_help_texts["ARGPARSER_CHECK_ARG_DEF"]="check if the arguments definition is consistent"

    # Define ${ARGPARSER_CHECK_ENV_VARS}.
             all_short_options["ARGPARSER_CHECK_ENV_VARS"]=""
              all_long_options["ARGPARSER_CHECK_ENV_VARS"]="check-env-vars"
               all_value_names["ARGPARSER_CHECK_ENV_VARS"]=""
            all_default_values["ARGPARSER_CHECK_ENV_VARS"]="false"
             all_choice_values["ARGPARSER_CHECK_ENV_VARS"]=""
    all_resolved_choice_values["ARGPARSER_CHECK_ENV_VARS"]=""
                     all_types["ARGPARSER_CHECK_ENV_VARS"]="bool"
               all_arg_numbers["ARGPARSER_CHECK_ENV_VARS"]="0"
                all_arg_groups["ARGPARSER_CHECK_ENV_VARS"]="General options"
                     all_notes["ARGPARSER_CHECK_ENV_VARS"]=""
                all_help_texts["ARGPARSER_CHECK_ENV_VARS"]="check if the Argparser environment variables accord to their definition"

    # Define ${ARGPARSER_CONFIG_FILE}.
             all_short_options["ARGPARSER_CONFIG_FILE"]=""
              all_long_options["ARGPARSER_CONFIG_FILE"]="config-file"
               all_value_names["ARGPARSER_CONFIG_FILE"]="FILE"
            all_default_values["ARGPARSER_CONFIG_FILE"]="''"
             all_choice_values["ARGPARSER_CONFIG_FILE"]=""
    all_resolved_choice_values["ARGPARSER_CONFIG_FILE"]=""
                     all_types["ARGPARSER_CONFIG_FILE"]="file"
               all_arg_numbers["ARGPARSER_CONFIG_FILE"]="1"
                all_arg_groups["ARGPARSER_CONFIG_FILE"]="General options"
                     all_notes["ARGPARSER_CONFIG_FILE"]=""
                all_help_texts["ARGPARSER_CONFIG_FILE"]="the path to a file holding the Argparser configuration"

    # Define ${ARGPARSER_COUNT_FLAGS}.
             all_short_options["ARGPARSER_COUNT_FLAGS"]=""
              all_long_options["ARGPARSER_COUNT_FLAGS"]="count-flags"
               all_value_names["ARGPARSER_COUNT_FLAGS"]=""
            all_default_values["ARGPARSER_COUNT_FLAGS"]="false"
             all_choice_values["ARGPARSER_COUNT_FLAGS"]=""
    all_resolved_choice_values["ARGPARSER_COUNT_FLAGS"]=""
                     all_types["ARGPARSER_COUNT_FLAGS"]="bool"
               all_arg_numbers["ARGPARSER_COUNT_FLAGS"]="0"
                all_arg_groups["ARGPARSER_COUNT_FLAGS"]="Parsing options"
                     all_notes["ARGPARSER_COUNT_FLAGS"]=""
                all_help_texts["ARGPARSER_COUNT_FLAGS"]="count flags instead of setting them to \"true\" or \"false\" based on the last prefix used on the command line"

    # Define ${ARGPARSER_CREATE_ARG_DEF}.
             all_short_options["ARGPARSER_CREATE_ARG_DEF"]=""
              all_long_options["ARGPARSER_CREATE_ARG_DEF"]="create-arg-def"
               all_value_names["ARGPARSER_CREATE_ARG_DEF"]=""
            all_default_values["ARGPARSER_CREATE_ARG_DEF"]="false"
             all_choice_values["ARGPARSER_CREATE_ARG_DEF"]=""
    all_resolved_choice_values["ARGPARSER_CREATE_ARG_DEF"]=""
                     all_types["ARGPARSER_CREATE_ARG_DEF"]="bool"
               all_arg_numbers["ARGPARSER_CREATE_ARG_DEF"]="0"
                all_arg_groups["ARGPARSER_CREATE_ARG_DEF"]="General options"
                     all_notes["ARGPARSER_CREATE_ARG_DEF"]=""
                all_help_texts["ARGPARSER_CREATE_ARG_DEF"]="create the arguments definition for a script"

    # Define ${ARGPARSER_DEBUG}.
             all_short_options["ARGPARSER_DEBUG"]=""
              all_long_options["ARGPARSER_DEBUG"]="debug"
               all_value_names["ARGPARSER_DEBUG"]=""
            all_default_values["ARGPARSER_DEBUG"]="false"
             all_choice_values["ARGPARSER_DEBUG"]=""
    all_resolved_choice_values["ARGPARSER_DEBUG"]=""
                     all_types["ARGPARSER_DEBUG"]="bool"
               all_arg_numbers["ARGPARSER_DEBUG"]="0"
                all_arg_groups["ARGPARSER_DEBUG"]="Miscellaneous options"
                     all_notes["ARGPARSER_DEBUG"]=""
                all_help_texts["ARGPARSER_DEBUG"]="(EXPERT OPTION) run the Argparser in debug mode, writing the stack trace for each command to STDERR"

    # Define ${ARGPARSER_ERROR_EXIT_CODE}.
             all_short_options["ARGPARSER_ERROR_EXIT_CODE"]=""
              all_long_options["ARGPARSER_ERROR_EXIT_CODE"]="error-exit-code"
               all_value_names["ARGPARSER_ERROR_EXIT_CODE"]="INT"
            all_default_values["ARGPARSER_ERROR_EXIT_CODE"]="1"
             all_choice_values["ARGPARSER_ERROR_EXIT_CODE"]=""
    all_resolved_choice_values["ARGPARSER_ERROR_EXIT_CODE"]=""
                     all_types["ARGPARSER_ERROR_EXIT_CODE"]="int"
               all_arg_numbers["ARGPARSER_ERROR_EXIT_CODE"]="1"
                all_arg_groups["ARGPARSER_ERROR_EXIT_CODE"]="Error/warning message options"
                     all_notes["ARGPARSER_ERROR_EXIT_CODE"]=""
                all_help_texts["ARGPARSER_ERROR_EXIT_CODE"]="the exit code when errors occurred upon parsing"

    # Define ${ARGPARSER_ERROR_STYLE}.
             all_short_options["ARGPARSER_ERROR_STYLE"]=""
              all_long_options["ARGPARSER_ERROR_STYLE"]="error-style"
               all_value_names["ARGPARSER_ERROR_STYLE"]="STYLE"
            all_default_values["ARGPARSER_ERROR_STYLE"]="red,bold,reverse"
             all_choice_values["ARGPARSER_ERROR_STYLE"]=""
    all_resolved_choice_values["ARGPARSER_ERROR_STYLE"]=""
                     all_types["ARGPARSER_ERROR_STYLE"]="str"
               all_arg_numbers["ARGPARSER_ERROR_STYLE"]="+"
                all_arg_groups["ARGPARSER_ERROR_STYLE"]="Stylization options"
                     all_notes["ARGPARSER_ERROR_STYLE"]="deprecated"
                all_help_texts["ARGPARSER_ERROR_STYLE"]="the color and style specification for error messages, deprecated in favor of \"--style-file=FILE\""

    # Define ${ARGPARSER_FLAG_NEGATION_PREFIXES}.
             all_short_options["ARGPARSER_FLAG_NEGATION_PREFIXES"]=""
              all_long_options["ARGPARSER_FLAG_NEGATION_PREFIXES"]="flag-negation-prefixes"
               all_value_names["ARGPARSER_FLAG_NEGATION_PREFIXES"]="PREFIX"
            all_default_values["ARGPARSER_FLAG_NEGATION_PREFIXES"]="no"
             all_choice_values["ARGPARSER_FLAG_NEGATION_PREFIXES"]=""
    all_resolved_choice_values["ARGPARSER_FLAG_NEGATION_PREFIXES"]=""
                     all_types["ARGPARSER_FLAG_NEGATION_PREFIXES"]="str"
               all_arg_numbers["ARGPARSER_FLAG_NEGATION_PREFIXES"]="+"
                all_arg_groups["ARGPARSER_FLAG_NEGATION_PREFIXES"]="Parsing options"
                     all_notes["ARGPARSER_FLAG_NEGATION_PREFIXES"]=""
                all_help_texts["ARGPARSER_FLAG_NEGATION_PREFIXES"]="the prefixes to consider as negating long-option flags"

    # Define ${ARGPARSER_HELP_ARG_GROUP}.
             all_short_options["ARGPARSER_HELP_ARG_GROUP"]=""
              all_long_options["ARGPARSER_HELP_ARG_GROUP"]="help-arg-group"
               all_value_names["ARGPARSER_HELP_ARG_GROUP"]="NAME"
            all_default_values["ARGPARSER_HELP_ARG_GROUP"]="Help options"
             all_choice_values["ARGPARSER_HELP_ARG_GROUP"]=""
    all_resolved_choice_values["ARGPARSER_HELP_ARG_GROUP"]=""
                     all_types["ARGPARSER_HELP_ARG_GROUP"]="str"
               all_arg_numbers["ARGPARSER_HELP_ARG_GROUP"]="1"
                all_arg_groups["ARGPARSER_HELP_ARG_GROUP"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_ARG_GROUP"]=""
                all_help_texts["ARGPARSER_HELP_ARG_GROUP"]="the name of the argument group holding all help options, i.e., --help, --usage, and --version"

    # Define ${ARGPARSER_HELP_DESCRIPTION}.
             all_short_options["ARGPARSER_HELP_DESCRIPTION"]=""
              all_long_options["ARGPARSER_HELP_DESCRIPTION"]="help-description"
               all_value_names["ARGPARSER_HELP_DESCRIPTION"]="TEXT"
            all_default_values["ARGPARSER_HELP_DESCRIPTION"]="''"
             all_choice_values["ARGPARSER_HELP_DESCRIPTION"]=""
    all_resolved_choice_values["ARGPARSER_HELP_DESCRIPTION"]=""
                     all_types["ARGPARSER_HELP_DESCRIPTION"]="str"
               all_arg_numbers["ARGPARSER_HELP_DESCRIPTION"]="1"
                all_arg_groups["ARGPARSER_HELP_DESCRIPTION"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_DESCRIPTION"]=""
                all_help_texts["ARGPARSER_HELP_DESCRIPTION"]="the script's description (purpose) to show in help message"

    # Define ${ARGPARSER_HELP_EXIT_CODE}.
             all_short_options["ARGPARSER_HELP_EXIT_CODE"]=""
              all_long_options["ARGPARSER_HELP_EXIT_CODE"]="help-exit-code"
               all_value_names["ARGPARSER_HELP_EXIT_CODE"]="INT"
            all_default_values["ARGPARSER_HELP_EXIT_CODE"]="0"
             all_choice_values["ARGPARSER_HELP_EXIT_CODE"]=""
    all_resolved_choice_values["ARGPARSER_HELP_EXIT_CODE"]=""
                     all_types["ARGPARSER_HELP_EXIT_CODE"]="int"
               all_arg_numbers["ARGPARSER_HELP_EXIT_CODE"]="1"
                all_arg_groups["ARGPARSER_HELP_EXIT_CODE"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_EXIT_CODE"]=""
                all_help_texts["ARGPARSER_HELP_EXIT_CODE"]="the exit code for help messages"

    # Define ${ARGPARSER_HELP_FILE}.
             all_short_options["ARGPARSER_HELP_FILE"]=""
              all_long_options["ARGPARSER_HELP_FILE"]="help-file"
               all_value_names["ARGPARSER_HELP_FILE"]="FILE"
            all_default_values["ARGPARSER_HELP_FILE"]="''"
             all_choice_values["ARGPARSER_HELP_FILE"]=""
    all_resolved_choice_values["ARGPARSER_HELP_FILE"]=""
                     all_types["ARGPARSER_HELP_FILE"]="file"
               all_arg_numbers["ARGPARSER_HELP_FILE"]="1"
                all_arg_groups["ARGPARSER_HELP_FILE"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_FILE"]=""
                all_help_texts["ARGPARSER_HELP_FILE"]="the path to a file holding the extended help message"

    # Define ${ARGPARSER_HELP_FILE_INCLUDE_CHAR}.
             all_short_options["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]=""
              all_long_options["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="help-file-include-char"
               all_value_names["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="CHAR"
            all_default_values["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="@"
             all_choice_values["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]=""
    all_resolved_choice_values["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]=""
                     all_types["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="char"
               all_arg_numbers["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="1"
                all_arg_groups["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]=""
                all_help_texts["ARGPARSER_HELP_FILE_INCLUDE_CHAR"]="the character that introduces an include directive in an ARGPARSER_HELP_FILE"

    # Define ${ARGPARSER_HELP_FILE_KEEP_COMMENTS}.
             all_short_options["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]=""
              all_long_options["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="help-file-keep-comments"
               all_value_names["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]=""
            all_default_values["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="false"
             all_choice_values["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]=""
    all_resolved_choice_values["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]=""
                     all_types["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="bool"
               all_arg_numbers["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="0"
                all_arg_groups["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]=""
                all_help_texts["ARGPARSER_HELP_FILE_KEEP_COMMENTS"]="keep commented lines in the help file"

    # Define ${ARGPARSER_HELP_OPTIONS}.
             all_short_options["ARGPARSER_HELP_OPTIONS"]=""
              all_long_options["ARGPARSER_HELP_OPTIONS"]="help-options"
               all_value_names["ARGPARSER_HELP_OPTIONS"]="OPTION"
            all_default_values["ARGPARSER_HELP_OPTIONS"]="h,?,help"
             all_choice_values["ARGPARSER_HELP_OPTIONS"]=""
    all_resolved_choice_values["ARGPARSER_HELP_OPTIONS"]=""
                     all_types["ARGPARSER_HELP_OPTIONS"]="str"
               all_arg_numbers["ARGPARSER_HELP_OPTIONS"]="+"
                all_arg_groups["ARGPARSER_HELP_OPTIONS"]="Help/usage message options"
                     all_notes["ARGPARSER_HELP_OPTIONS"]=""
                all_help_texts["ARGPARSER_HELP_OPTIONS"]="the short and long option names to invoke the help message"

    # Define ${ARGPARSER_HELP_STYLE}.
             all_short_options["ARGPARSER_HELP_STYLE"]=""
              all_long_options["ARGPARSER_HELP_STYLE"]="help-style"
               all_value_names["ARGPARSER_HELP_STYLE"]="STYLE"
            all_default_values["ARGPARSER_HELP_STYLE"]="italic"
             all_choice_values["ARGPARSER_HELP_STYLE"]=""
    all_resolved_choice_values["ARGPARSER_HELP_STYLE"]=""
                     all_types["ARGPARSER_HELP_STYLE"]="str"
               all_arg_numbers["ARGPARSER_HELP_STYLE"]="+"
                all_arg_groups["ARGPARSER_HELP_STYLE"]="Stylization options"
                     all_notes["ARGPARSER_HELP_STYLE"]="deprecated"
                all_help_texts["ARGPARSER_HELP_STYLE"]="the color and style specification for help messages, deprecated in favor of \"--style-file=FILE\""

    # Define ${ARGPARSER_LANGUAGE}.
             all_short_options["ARGPARSER_LANGUAGE"]=""
              all_long_options["ARGPARSER_LANGUAGE"]="language"
               all_value_names["ARGPARSER_LANGUAGE"]="LANG"
            all_default_values["ARGPARSER_LANGUAGE"]="en"
             all_choice_values["ARGPARSER_LANGUAGE"]=""
    all_resolved_choice_values["ARGPARSER_LANGUAGE"]=""
                     all_types["ARGPARSER_LANGUAGE"]="str"
               all_arg_numbers["ARGPARSER_LANGUAGE"]="1"
                all_arg_groups["ARGPARSER_LANGUAGE"]="Localization options"
                     all_notes["ARGPARSER_LANGUAGE"]=""
                all_help_texts["ARGPARSER_LANGUAGE"]="the language in which to localize the help and usage messages"

    # Define ${ARGPARSER_MAX_COL_WIDTH_1}.
             all_short_options["ARGPARSER_MAX_COL_WIDTH_1"]=""
              all_long_options["ARGPARSER_MAX_COL_WIDTH_1"]="max-col-width-1"
               all_value_names["ARGPARSER_MAX_COL_WIDTH_1"]="INT"
            all_default_values["ARGPARSER_MAX_COL_WIDTH_1"]="9"
             all_choice_values["ARGPARSER_MAX_COL_WIDTH_1"]=""
    all_resolved_choice_values["ARGPARSER_MAX_COL_WIDTH_1"]=""
                     all_types["ARGPARSER_MAX_COL_WIDTH_1"]="uint"
               all_arg_numbers["ARGPARSER_MAX_COL_WIDTH_1"]="1"
                all_arg_groups["ARGPARSER_MAX_COL_WIDTH_1"]="Stylization options"
                     all_notes["ARGPARSER_MAX_COL_WIDTH_1"]=""
                all_help_texts["ARGPARSER_MAX_COL_WIDTH_1"]="the maximum column width of the first column in the help message"

    # Define ${ARGPARSER_MAX_COL_WIDTH_2}.
             all_short_options["ARGPARSER_MAX_COL_WIDTH_2"]=""
              all_long_options["ARGPARSER_MAX_COL_WIDTH_2"]="max-col-width-2"
               all_value_names["ARGPARSER_MAX_COL_WIDTH_2"]="INT"
            all_default_values["ARGPARSER_MAX_COL_WIDTH_2"]="33"
             all_choice_values["ARGPARSER_MAX_COL_WIDTH_2"]=""
    all_resolved_choice_values["ARGPARSER_MAX_COL_WIDTH_2"]=""
                     all_types["ARGPARSER_MAX_COL_WIDTH_2"]="uint"
               all_arg_numbers["ARGPARSER_MAX_COL_WIDTH_2"]="1"
                all_arg_groups["ARGPARSER_MAX_COL_WIDTH_2"]="Stylization options"
                     all_notes["ARGPARSER_MAX_COL_WIDTH_2"]=""
                all_help_texts["ARGPARSER_MAX_COL_WIDTH_2"]="the maximum column width of the second column in the help message"

    # Define ${ARGPARSER_MAX_COL_WIDTH_3}.
             all_short_options["ARGPARSER_MAX_COL_WIDTH_3"]=""
              all_long_options["ARGPARSER_MAX_COL_WIDTH_3"]="max-col-width-3"
               all_value_names["ARGPARSER_MAX_COL_WIDTH_3"]="INT"
            all_default_values["ARGPARSER_MAX_COL_WIDTH_3"]="0"
             all_choice_values["ARGPARSER_MAX_COL_WIDTH_3"]=""
    all_resolved_choice_values["ARGPARSER_MAX_COL_WIDTH_3"]=""
                     all_types["ARGPARSER_MAX_COL_WIDTH_3"]="uint"
               all_arg_numbers["ARGPARSER_MAX_COL_WIDTH_3"]="1"
                all_arg_groups["ARGPARSER_MAX_COL_WIDTH_3"]="Stylization options"
                     all_notes["ARGPARSER_MAX_COL_WIDTH_3"]=""
                all_help_texts["ARGPARSER_MAX_COL_WIDTH_3"]="the maximum column width of the third column in the help message"

    # Define ${ARGPARSER_MAX_WIDTH}.
             all_short_options["ARGPARSER_MAX_WIDTH"]=""
              all_long_options["ARGPARSER_MAX_WIDTH"]="max-width"
               all_value_names["ARGPARSER_MAX_WIDTH"]="INT"
            all_default_values["ARGPARSER_MAX_WIDTH"]="79"
             all_choice_values["ARGPARSER_MAX_WIDTH"]=""
    all_resolved_choice_values["ARGPARSER_MAX_WIDTH"]=""
                     all_types["ARGPARSER_MAX_WIDTH"]="uint"
               all_arg_numbers["ARGPARSER_MAX_WIDTH"]="1"
                all_arg_groups["ARGPARSER_MAX_WIDTH"]="Stylization options"
                     all_notes["ARGPARSER_MAX_WIDTH"]=""
                all_help_texts["ARGPARSER_MAX_WIDTH"]="the maximum width of the help message"

    # Define ${ARGPARSER_POSITIONAL_ARG_GROUP}.
             all_short_options["ARGPARSER_POSITIONAL_ARG_GROUP"]=""
              all_long_options["ARGPARSER_POSITIONAL_ARG_GROUP"]="positional-arg-group"
               all_value_names["ARGPARSER_POSITIONAL_ARG_GROUP"]="NAME"
            all_default_values["ARGPARSER_POSITIONAL_ARG_GROUP"]="Positional arguments"
             all_choice_values["ARGPARSER_POSITIONAL_ARG_GROUP"]=""
    all_resolved_choice_values["ARGPARSER_POSITIONAL_ARG_GROUP"]=""
                     all_types["ARGPARSER_POSITIONAL_ARG_GROUP"]="str"
               all_arg_numbers["ARGPARSER_POSITIONAL_ARG_GROUP"]="1"
                all_arg_groups["ARGPARSER_POSITIONAL_ARG_GROUP"]="Help/usage message options"
                     all_notes["ARGPARSER_POSITIONAL_ARG_GROUP"]=""
                all_help_texts["ARGPARSER_POSITIONAL_ARG_GROUP"]="the name of the argument group holding all positional arguments"

    # Define ${ARGPARSER_READ_ARGS}.
             all_short_options["ARGPARSER_READ_ARGS"]=""
              all_long_options["ARGPARSER_READ_ARGS"]="read-args"
               all_value_names["ARGPARSER_READ_ARGS"]=""
            all_default_values["ARGPARSER_READ_ARGS"]="true"
             all_choice_values["ARGPARSER_READ_ARGS"]=""
    all_resolved_choice_values["ARGPARSER_READ_ARGS"]=""
                     all_types["ARGPARSER_READ_ARGS"]="bool"
               all_arg_numbers["ARGPARSER_READ_ARGS"]="0"
                all_arg_groups["ARGPARSER_READ_ARGS"]="General options"
                     all_notes["ARGPARSER_READ_ARGS"]=""
                all_help_texts["ARGPARSER_READ_ARGS"]="read the arguments and parse them to ARGPARSER_ARG_ARRAY_NAME"

    # Define ${ARGPARSER_SCRIPT_NAME}.
             all_short_options["ARGPARSER_SCRIPT_NAME"]=""
              all_long_options["ARGPARSER_SCRIPT_NAME"]="script-name"
               all_value_names["ARGPARSER_SCRIPT_NAME"]="NAME"
            all_default_values["ARGPARSER_SCRIPT_NAME"]="''"
             all_choice_values["ARGPARSER_SCRIPT_NAME"]=""
    all_resolved_choice_values["ARGPARSER_SCRIPT_NAME"]=""
                     all_types["ARGPARSER_SCRIPT_NAME"]="str"
               all_arg_numbers["ARGPARSER_SCRIPT_NAME"]="1"
                all_arg_groups["ARGPARSER_SCRIPT_NAME"]="General options"
                     all_notes["ARGPARSER_SCRIPT_NAME"]=""
                all_help_texts["ARGPARSER_SCRIPT_NAME"]="the script's name for the help, usage, version, error, and warning messages"

    # Define ${ARGPARSER_SET_ARGS}.
             all_short_options["ARGPARSER_SET_ARGS"]=""
              all_long_options["ARGPARSER_SET_ARGS"]="set-args"
               all_value_names["ARGPARSER_SET_ARGS"]=""
            all_default_values["ARGPARSER_SET_ARGS"]="true"
             all_choice_values["ARGPARSER_SET_ARGS"]=""
    all_resolved_choice_values["ARGPARSER_SET_ARGS"]=""
                     all_types["ARGPARSER_SET_ARGS"]="bool"
               all_arg_numbers["ARGPARSER_SET_ARGS"]="0"
                all_arg_groups["ARGPARSER_SET_ARGS"]="General options"
                     all_notes["ARGPARSER_SET_ARGS"]=""
                all_help_texts["ARGPARSER_SET_ARGS"]="set the arguments from ARGPARSER_ARG_ARRAY_NAME as variables in the script's scope"

    # Define ${ARGPARSER_SET_ARRAYS}.
             all_short_options["ARGPARSER_SET_ARRAYS"]=""
              all_long_options["ARGPARSER_SET_ARRAYS"]="set-arrays"
               all_value_names["ARGPARSER_SET_ARRAYS"]=""
            all_default_values["ARGPARSER_SET_ARRAYS"]="true"
             all_choice_values["ARGPARSER_SET_ARRAYS"]=""
    all_resolved_choice_values["ARGPARSER_SET_ARRAYS"]=""
                     all_types["ARGPARSER_SET_ARRAYS"]="bool"
               all_arg_numbers["ARGPARSER_SET_ARRAYS"]="0"
                all_arg_groups["ARGPARSER_SET_ARRAYS"]="General options"
                     all_notes["ARGPARSER_SET_ARRAYS"]=""
                all_help_texts["ARGPARSER_SET_ARRAYS"]="set arguments intended to have multiple values as indexed array"

    # Define ${ARGPARSER_SILENCE_ERRORS}.
             all_short_options["ARGPARSER_SILENCE_ERRORS"]=""
              all_long_options["ARGPARSER_SILENCE_ERRORS"]="silence-errors"
               all_value_names["ARGPARSER_SILENCE_ERRORS"]=""
            all_default_values["ARGPARSER_SILENCE_ERRORS"]="false"
             all_choice_values["ARGPARSER_SILENCE_ERRORS"]=""
    all_resolved_choice_values["ARGPARSER_SILENCE_ERRORS"]=""
                     all_types["ARGPARSER_SILENCE_ERRORS"]="bool"
               all_arg_numbers["ARGPARSER_SILENCE_ERRORS"]="0"
                all_arg_groups["ARGPARSER_SILENCE_ERRORS"]="Error/warning message options"
                     all_notes["ARGPARSER_SILENCE_ERRORS"]=""
                all_help_texts["ARGPARSER_SILENCE_ERRORS"]="silence the emission (output) of error messages"

    # Define ${ARGPARSER_SILENCE_WARNINGS}.
             all_short_options["ARGPARSER_SILENCE_WARNINGS"]=""
              all_long_options["ARGPARSER_SILENCE_WARNINGS"]="silence-warnings"
               all_value_names["ARGPARSER_SILENCE_WARNINGS"]=""
            all_default_values["ARGPARSER_SILENCE_WARNINGS"]="false"
             all_choice_values["ARGPARSER_SILENCE_WARNINGS"]=""
    all_resolved_choice_values["ARGPARSER_SILENCE_WARNINGS"]=""
                     all_types["ARGPARSER_SILENCE_WARNINGS"]="bool"
               all_arg_numbers["ARGPARSER_SILENCE_WARNINGS"]="0"
                all_arg_groups["ARGPARSER_SILENCE_WARNINGS"]="Error/warning message options"
                     all_notes["ARGPARSER_SILENCE_WARNINGS"]=""
                all_help_texts["ARGPARSER_SILENCE_WARNINGS"]="silence the emission (output) of warning messages"

    # Define ${ARGPARSER_STYLE_FILE}.
             all_short_options["ARGPARSER_STYLE_FILE"]=""
              all_long_options["ARGPARSER_STYLE_FILE"]="style-file"
               all_value_names["ARGPARSER_STYLE_FILE"]="FILE"
            all_default_values["ARGPARSER_STYLE_FILE"]="''"
             all_choice_values["ARGPARSER_STYLE_FILE"]=""
    all_resolved_choice_values["ARGPARSER_STYLE_FILE"]=""
                     all_types["ARGPARSER_STYLE_FILE"]="file"
               all_arg_numbers["ARGPARSER_STYLE_FILE"]="1"
                all_arg_groups["ARGPARSER_STYLE_FILE"]="Stylization options"
                     all_notes["ARGPARSER_STYLE_FILE"]=""
                all_help_texts["ARGPARSER_STYLE_FILE"]="the path to a file holding the style definitions for the messages"

    # Define ${ARGPARSER_SUBCOMMAND_GROUP}.
             all_short_options["ARGPARSER_SUBCOMMAND_GROUP"]=""
              all_long_options["ARGPARSER_SUBCOMMAND_GROUP"]="subcommand-group"
               all_value_names["ARGPARSER_SUBCOMMAND_GROUP"]="NAME"
            all_default_values["ARGPARSER_SUBCOMMAND_GROUP"]="Subcommands"
             all_choice_values["ARGPARSER_SUBCOMMAND_GROUP"]=""
    all_resolved_choice_values["ARGPARSER_SUBCOMMAND_GROUP"]=""
                     all_types["ARGPARSER_SUBCOMMAND_GROUP"]="str"
               all_arg_numbers["ARGPARSER_SUBCOMMAND_GROUP"]="1"
                all_arg_groups["ARGPARSER_SUBCOMMAND_GROUP"]="Help/usage message options"
                     all_notes["ARGPARSER_SUBCOMMAND_GROUP"]=""
                all_help_texts["ARGPARSER_SUBCOMMAND_GROUP"]="the name of the argument group holding all subcommands"

    # Define ${ARGPARSER_TRANSLATION_FILE}.
             all_short_options["ARGPARSER_TRANSLATION_FILE"]=""
              all_long_options["ARGPARSER_TRANSLATION_FILE"]="translation-file"
               all_value_names["ARGPARSER_TRANSLATION_FILE"]="FILE"
            all_default_values["ARGPARSER_TRANSLATION_FILE"]="''"
             all_choice_values["ARGPARSER_TRANSLATION_FILE"]=""
    all_resolved_choice_values["ARGPARSER_TRANSLATION_FILE"]=""
                     all_types["ARGPARSER_TRANSLATION_FILE"]="file"
               all_arg_numbers["ARGPARSER_TRANSLATION_FILE"]="1"
                all_arg_groups["ARGPARSER_TRANSLATION_FILE"]="Localization options"
                     all_notes["ARGPARSER_TRANSLATION_FILE"]=""
                all_help_texts["ARGPARSER_TRANSLATION_FILE"]="the path to a simplified YAML file holding the translation to ARGPARSER_LANGUAGE"

    # Define ${ARGPARSER_UNSET_ARGS}.
             all_short_options["ARGPARSER_UNSET_ARGS"]=""
              all_long_options["ARGPARSER_UNSET_ARGS"]="unset-args"
               all_value_names["ARGPARSER_UNSET_ARGS"]=""
            all_default_values["ARGPARSER_UNSET_ARGS"]="true"
             all_choice_values["ARGPARSER_UNSET_ARGS"]=""
    all_resolved_choice_values["ARGPARSER_UNSET_ARGS"]=""
                     all_types["ARGPARSER_UNSET_ARGS"]="bool"
               all_arg_numbers["ARGPARSER_UNSET_ARGS"]="0"
                all_arg_groups["ARGPARSER_UNSET_ARGS"]="General options"
                     all_notes["ARGPARSER_UNSET_ARGS"]=""
                all_help_texts["ARGPARSER_UNSET_ARGS"]="unset (remove) all command-line arguments given to the script"

    # Define ${ARGPARSER_UNSET_ENV_VARS}.
             all_short_options["ARGPARSER_UNSET_ENV_VARS"]=""
              all_long_options["ARGPARSER_UNSET_ENV_VARS"]="unset-env-vars"
               all_value_names["ARGPARSER_UNSET_ENV_VARS"]=""
            all_default_values["ARGPARSER_UNSET_ENV_VARS"]="true"
             all_choice_values["ARGPARSER_UNSET_ENV_VARS"]=""
    all_resolved_choice_values["ARGPARSER_UNSET_ENV_VARS"]=""
                     all_types["ARGPARSER_UNSET_ENV_VARS"]="bool"
               all_arg_numbers["ARGPARSER_UNSET_ENV_VARS"]="0"
                all_arg_groups["ARGPARSER_UNSET_ENV_VARS"]="General options"
                     all_notes["ARGPARSER_UNSET_ENV_VARS"]=""
                all_help_texts["ARGPARSER_UNSET_ENV_VARS"]="unset (remove) the Argparser environment variables from the environment"

    # Define ${ARGPARSER_UNSET_FUNCTIONS}.
             all_short_options["ARGPARSER_UNSET_FUNCTIONS"]=""
              all_long_options["ARGPARSER_UNSET_FUNCTIONS"]="unset-functions"
               all_value_names["ARGPARSER_UNSET_FUNCTIONS"]=""
            all_default_values["ARGPARSER_UNSET_FUNCTIONS"]="true"
             all_choice_values["ARGPARSER_UNSET_FUNCTIONS"]=""
    all_resolved_choice_values["ARGPARSER_UNSET_FUNCTIONS"]=""
                     all_types["ARGPARSER_UNSET_FUNCTIONS"]="bool"
               all_arg_numbers["ARGPARSER_UNSET_FUNCTIONS"]="0"
                all_arg_groups["ARGPARSER_UNSET_FUNCTIONS"]="General options"
                     all_notes["ARGPARSER_UNSET_FUNCTIONS"]=""
                all_help_texts["ARGPARSER_UNSET_FUNCTIONS"]="unset (remove) the Argparser functions from the environment"

    # Define ${ARGPARSER_USAGE_EXIT_CODE}.
             all_short_options["ARGPARSER_USAGE_EXIT_CODE"]=""
              all_long_options["ARGPARSER_USAGE_EXIT_CODE"]="usage-exit-code"
               all_value_names["ARGPARSER_USAGE_EXIT_CODE"]="INT"
            all_default_values["ARGPARSER_USAGE_EXIT_CODE"]="0"
             all_choice_values["ARGPARSER_USAGE_EXIT_CODE"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_EXIT_CODE"]=""
                     all_types["ARGPARSER_USAGE_EXIT_CODE"]="int"
               all_arg_numbers["ARGPARSER_USAGE_EXIT_CODE"]="1"
                all_arg_groups["ARGPARSER_USAGE_EXIT_CODE"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_EXIT_CODE"]=""
                all_help_texts["ARGPARSER_USAGE_EXIT_CODE"]="the exit code for usage messages"

    # Define ${ARGPARSER_USAGE_FILE}.
             all_short_options["ARGPARSER_USAGE_FILE"]=""
              all_long_options["ARGPARSER_USAGE_FILE"]="usage-file"
               all_value_names["ARGPARSER_USAGE_FILE"]="FILE"
            all_default_values["ARGPARSER_USAGE_FILE"]="''"
             all_choice_values["ARGPARSER_USAGE_FILE"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_FILE"]=""
                     all_types["ARGPARSER_USAGE_FILE"]="file"
               all_arg_numbers["ARGPARSER_USAGE_FILE"]="1"
                all_arg_groups["ARGPARSER_USAGE_FILE"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_FILE"]=""
                all_help_texts["ARGPARSER_USAGE_FILE"]="the path to a file holding the extended usage message"

    # Define ${ARGPARSER_USAGE_FILE_INCLUDE_CHAR}.
             all_short_options["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]=""
              all_long_options["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="usage-file-include-char"
               all_value_names["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="CHAR"
            all_default_values["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="@"
             all_choice_values["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]=""
                     all_types["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="char"
               all_arg_numbers["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="1"
                all_arg_groups["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]=""
                all_help_texts["ARGPARSER_USAGE_FILE_INCLUDE_CHAR"]="the character that introduces an include directive in an ARGPARSER_USAGE_FILE"

    # Define ${ARGPARSER_USAGE_FILE_KEEP_COMMENTS}.
             all_short_options["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]=""
              all_long_options["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="usage-file-keep-comments"
               all_value_names["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]=""
            all_default_values["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="false"
             all_choice_values["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]=""
                     all_types["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="bool"
               all_arg_numbers["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="0"
                all_arg_groups["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]=""
                all_help_texts["ARGPARSER_USAGE_FILE_KEEP_COMMENTS"]="keep commented lines in the usage file"

    # Define ${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}.
             all_short_options["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]=""
              all_long_options["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="usage-message-option-type"
               all_value_names["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]=""
            all_default_values["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="short"
             all_choice_values["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="long,short"
    all_resolved_choice_values["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="long,short"
                     all_types["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="str"
               all_arg_numbers["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="1"
                all_arg_groups["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]=""
                all_help_texts["ARGPARSER_USAGE_MESSAGE_OPTION_TYPE"]="use short or long option names in usage messages"

    # Define ${ARGPARSER_USAGE_MESSAGE_ORIENTATION}.
             all_short_options["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]=""
              all_long_options["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="usage-message-orientation"
               all_value_names["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]=""
            all_default_values["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="row"
             all_choice_values["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="row,column"
    all_resolved_choice_values["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="row,column"
                     all_types["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="str"
               all_arg_numbers["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="1"
                all_arg_groups["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]=""
                all_help_texts["ARGPARSER_USAGE_MESSAGE_ORIENTATION"]="output the positional and keyword arguments in usage messages in a row or in a column"

    # Define ${ARGPARSER_USAGE_OPTIONS}.
             all_short_options["ARGPARSER_USAGE_OPTIONS"]=""
              all_long_options["ARGPARSER_USAGE_OPTIONS"]="usage-options"
               all_value_names["ARGPARSER_USAGE_OPTIONS"]="OPTION"
            all_default_values["ARGPARSER_USAGE_OPTIONS"]="u,usage"
             all_choice_values["ARGPARSER_USAGE_OPTIONS"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_OPTIONS"]=""
                     all_types["ARGPARSER_USAGE_OPTIONS"]="str"
               all_arg_numbers["ARGPARSER_USAGE_OPTIONS"]="+"
                all_arg_groups["ARGPARSER_USAGE_OPTIONS"]="Help/usage message options"
                     all_notes["ARGPARSER_USAGE_OPTIONS"]=""
                all_help_texts["ARGPARSER_USAGE_OPTIONS"]="the short and long option names to invoke the usage message"

    # Define ${ARGPARSER_USAGE_STYLE}.
             all_short_options["ARGPARSER_USAGE_STYLE"]=""
              all_long_options["ARGPARSER_USAGE_STYLE"]="usage-style"
               all_value_names["ARGPARSER_USAGE_STYLE"]="STYLE"
            all_default_values["ARGPARSER_USAGE_STYLE"]="italic"
             all_choice_values["ARGPARSER_USAGE_STYLE"]=""
    all_resolved_choice_values["ARGPARSER_USAGE_STYLE"]=""
                     all_types["ARGPARSER_USAGE_STYLE"]="str"
               all_arg_numbers["ARGPARSER_USAGE_STYLE"]="+"
                all_arg_groups["ARGPARSER_USAGE_STYLE"]="Stylization options"
                     all_notes["ARGPARSER_USAGE_STYLE"]="deprecated"
                all_help_texts["ARGPARSER_USAGE_STYLE"]="the color and style specification for usage messages, deprecated in favor of \"--style-file=FILE\""

    # Define ${ARGPARSER_USE_LONG_OPTIONS}.
             all_short_options["ARGPARSER_USE_LONG_OPTIONS"]=""
              all_long_options["ARGPARSER_USE_LONG_OPTIONS"]="use-long-options"
               all_value_names["ARGPARSER_USE_LONG_OPTIONS"]=""
            all_default_values["ARGPARSER_USE_LONG_OPTIONS"]="true"
             all_choice_values["ARGPARSER_USE_LONG_OPTIONS"]=""
    all_resolved_choice_values["ARGPARSER_USE_LONG_OPTIONS"]=""
                     all_types["ARGPARSER_USE_LONG_OPTIONS"]="bool"
               all_arg_numbers["ARGPARSER_USE_LONG_OPTIONS"]="0"
                all_arg_groups["ARGPARSER_USE_LONG_OPTIONS"]="Parsing options"
                     all_notes["ARGPARSER_USE_LONG_OPTIONS"]=""
                all_help_texts["ARGPARSER_USE_LONG_OPTIONS"]="use the long option names for parsing"

    # Define ${ARGPARSER_USE_SHORT_OPTIONS}.
             all_short_options["ARGPARSER_USE_SHORT_OPTIONS"]=""
              all_long_options["ARGPARSER_USE_SHORT_OPTIONS"]="use-short-options"
               all_value_names["ARGPARSER_USE_SHORT_OPTIONS"]=""
            all_default_values["ARGPARSER_USE_SHORT_OPTIONS"]="true"
             all_choice_values["ARGPARSER_USE_SHORT_OPTIONS"]=""
    all_resolved_choice_values["ARGPARSER_USE_SHORT_OPTIONS"]=""
                     all_types["ARGPARSER_USE_SHORT_OPTIONS"]="bool"
               all_arg_numbers["ARGPARSER_USE_SHORT_OPTIONS"]="0"
                all_arg_groups["ARGPARSER_USE_SHORT_OPTIONS"]="Parsing options"
                     all_notes["ARGPARSER_USE_SHORT_OPTIONS"]=""
                all_help_texts["ARGPARSER_USE_SHORT_OPTIONS"]="use the short option names for parsing"

    # Define ${ARGPARSER_USE_COLORS}.
             all_short_options["ARGPARSER_USE_COLORS"]=""
              all_long_options["ARGPARSER_USE_COLORS"]="use-colors"
               all_value_names["ARGPARSER_USE_COLORS"]=""
            all_default_values["ARGPARSER_USE_COLORS"]="true"
             all_choice_values["ARGPARSER_USE_COLORS"]=""
    all_resolved_choice_values["ARGPARSER_USE_COLORS"]=""
                     all_types["ARGPARSER_USE_COLORS"]="bool"
               all_arg_numbers["ARGPARSER_USE_COLORS"]="0"
                all_arg_groups["ARGPARSER_USE_COLORS"]="Stylization options"
                     all_notes["ARGPARSER_USE_COLORS"]=""
                all_help_texts["ARGPARSER_USE_COLORS"]="colorize the help, usage, version, error, and warning messages, applied in conjunction with \"--use-styles\""

    # Define ${ARGPARSER_USE_STYLES}.
             all_short_options["ARGPARSER_USE_STYLES"]=""
              all_long_options["ARGPARSER_USE_STYLES"]="use-styles"
               all_value_names["ARGPARSER_USE_STYLES"]=""
            all_default_values["ARGPARSER_USE_STYLES"]="tty"
             all_choice_values["ARGPARSER_USE_STYLES"]="always,never,file,tty"
    all_resolved_choice_values["ARGPARSER_USE_STYLES"]="always,never,file,tty"
                     all_types["ARGPARSER_USE_STYLES"]="str"
               all_arg_numbers["ARGPARSER_USE_STYLES"]="1"
                all_arg_groups["ARGPARSER_USE_STYLES"]="Stylization options"
                     all_notes["ARGPARSER_USE_STYLES"]=""
                all_help_texts["ARGPARSER_USE_STYLES"]="use the colors and styles \"always\", \"never\", or only when STDOUT/STDERR is (\"tty\") or is not (\"file\") a terminal"

    # Define ${ARGPARSER_USE_STYLES_IN_FILES}.
             all_short_options["ARGPARSER_USE_STYLES_IN_FILES"]=""
              all_long_options["ARGPARSER_USE_STYLES_IN_FILES"]="use-styles-in-files"
               all_value_names["ARGPARSER_USE_STYLES_IN_FILES"]=""
            all_default_values["ARGPARSER_USE_STYLES_IN_FILES"]="false"
             all_choice_values["ARGPARSER_USE_STYLES_IN_FILES"]=""
    all_resolved_choice_values["ARGPARSER_USE_STYLES_IN_FILES"]=""
                     all_types["ARGPARSER_USE_STYLES_IN_FILES"]="bool"
               all_arg_numbers["ARGPARSER_USE_STYLES_IN_FILES"]="0"
                all_arg_groups["ARGPARSER_USE_STYLES_IN_FILES"]="Stylization options"
                     all_notes["ARGPARSER_USE_STYLES_IN_FILES"]="deprecated"
                all_help_texts["ARGPARSER_USE_STYLES_IN_FILES"]="use the colors and styles when STDOUT/STDERR is not a terminal, deprecated in favor of \"--use-styles=always\""

    # Define ${ARGPARSER_USE_UNICODE}.
             all_short_options["ARGPARSER_USE_UNICODE"]=""
              all_long_options["ARGPARSER_USE_UNICODE"]="use-unicode"
               all_value_names["ARGPARSER_USE_UNICODE"]=""
            all_default_values["ARGPARSER_USE_UNICODE"]="false"
             all_choice_values["ARGPARSER_USE_UNICODE"]=""
    all_resolved_choice_values["ARGPARSER_USE_UNICODE"]=""
                     all_types["ARGPARSER_USE_UNICODE"]="bool"
               all_arg_numbers["ARGPARSER_USE_UNICODE"]="0"
                all_arg_groups["ARGPARSER_USE_UNICODE"]="Stylization options"
                     all_notes["ARGPARSER_USE_UNICODE"]=""
                all_help_texts["ARGPARSER_USE_UNICODE"]="use Unicode characters for frames and messages, instead of only ASCII characters"

    # Define ${ARGPARSER_VERSION_EXIT_CODE}.
             all_short_options["ARGPARSER_VERSION_EXIT_CODE"]=""
              all_long_options["ARGPARSER_VERSION_EXIT_CODE"]="version-exit-code"
               all_value_names["ARGPARSER_VERSION_EXIT_CODE"]="INT"
            all_default_values["ARGPARSER_VERSION_EXIT_CODE"]="0"
             all_choice_values["ARGPARSER_VERSION_EXIT_CODE"]=""
    all_resolved_choice_values["ARGPARSER_VERSION_EXIT_CODE"]=""
                     all_types["ARGPARSER_VERSION_EXIT_CODE"]="int"
               all_arg_numbers["ARGPARSER_VERSION_EXIT_CODE"]="1"
                all_arg_groups["ARGPARSER_VERSION_EXIT_CODE"]="Version message options"
                     all_notes["ARGPARSER_VERSION_EXIT_CODE"]=""
                all_help_texts["ARGPARSER_VERSION_EXIT_CODE"]="the exit code for version messages"

    # Define ${ARGPARSER_VERSION_NUMBER}.
             all_short_options["ARGPARSER_VERSION_NUMBER"]=""
              all_long_options["ARGPARSER_VERSION_NUMBER"]="version-number"
               all_value_names["ARGPARSER_VERSION_NUMBER"]="VERSION"
            all_default_values["ARGPARSER_VERSION_NUMBER"]="1.0.0"
             all_choice_values["ARGPARSER_VERSION_NUMBER"]=""
    all_resolved_choice_values["ARGPARSER_VERSION_NUMBER"]=""
                     all_types["ARGPARSER_VERSION_NUMBER"]="str"
               all_arg_numbers["ARGPARSER_VERSION_NUMBER"]="1"
                all_arg_groups["ARGPARSER_VERSION_NUMBER"]="Version message options"
                     all_notes["ARGPARSER_VERSION_NUMBER"]=""
                all_help_texts["ARGPARSER_VERSION_NUMBER"]="the script's version number for the version message"

    # Define ${ARGPARSER_VERSION_OPTIONS}.
             all_short_options["ARGPARSER_VERSION_OPTIONS"]=""
              all_long_options["ARGPARSER_VERSION_OPTIONS"]="version-options"
               all_value_names["ARGPARSER_VERSION_OPTIONS"]="OPTION"
            all_default_values["ARGPARSER_VERSION_OPTIONS"]="V,version"
             all_choice_values["ARGPARSER_VERSION_OPTIONS"]=""
    all_resolved_choice_values["ARGPARSER_VERSION_OPTIONS"]=""
                     all_types["ARGPARSER_VERSION_OPTIONS"]="str"
               all_arg_numbers["ARGPARSER_VERSION_OPTIONS"]="+"
                all_arg_groups["ARGPARSER_VERSION_OPTIONS"]="Version message options"
                     all_notes["ARGPARSER_VERSION_OPTIONS"]=""
                all_help_texts["ARGPARSER_VERSION_OPTIONS"]="the short and long option names to invoke the version message"

    # Define ${ARGPARSER_VERSION_STYLE}.
             all_short_options["ARGPARSER_VERSION_STYLE"]=""
              all_long_options["ARGPARSER_VERSION_STYLE"]="version-style"
               all_value_names["ARGPARSER_VERSION_STYLE"]="STYLE"
            all_default_values["ARGPARSER_VERSION_STYLE"]="bold"
             all_choice_values["ARGPARSER_VERSION_STYLE"]=""
    all_resolved_choice_values["ARGPARSER_VERSION_STYLE"]=""
                     all_types["ARGPARSER_VERSION_STYLE"]="str"
               all_arg_numbers["ARGPARSER_VERSION_STYLE"]="+"
                all_arg_groups["ARGPARSER_VERSION_STYLE"]="Stylization options"
                     all_notes["ARGPARSER_VERSION_STYLE"]="deprecated"
                all_help_texts["ARGPARSER_VERSION_STYLE"]="the color and style specification for version messages, deprecated in favor of \"--style-file=FILE\""

    # Define ${ARGPARSER_WARNING_STYLE}.
             all_short_options["ARGPARSER_WARNING_STYLE"]=""
              all_long_options["ARGPARSER_WARNING_STYLE"]="warning-style"
               all_value_names["ARGPARSER_WARNING_STYLE"]="STYLE"
            all_default_values["ARGPARSER_WARNING_STYLE"]="red,bold"
             all_choice_values["ARGPARSER_WARNING_STYLE"]=""
    all_resolved_choice_values["ARGPARSER_WARNING_STYLE"]=""
                     all_types["ARGPARSER_WARNING_STYLE"]="str"
               all_arg_numbers["ARGPARSER_WARNING_STYLE"]="+"
                all_arg_groups["ARGPARSER_WARNING_STYLE"]="Stylization options"
                     all_notes["ARGPARSER_WARNING_STYLE"]="deprecated"
                all_help_texts["ARGPARSER_WARNING_STYLE"]="the color and style specification for warning messages, deprecated in favor of \"--style-file=FILE\""

    # Define ${ARGPARSER_WRITE_ARGS}.
             all_short_options["ARGPARSER_WRITE_ARGS"]=""
              all_long_options["ARGPARSER_WRITE_ARGS"]="write-args"
               all_value_names["ARGPARSER_WRITE_ARGS"]=""
            all_default_values["ARGPARSER_WRITE_ARGS"]="false"
             all_choice_values["ARGPARSER_WRITE_ARGS"]=""
    all_resolved_choice_values["ARGPARSER_WRITE_ARGS"]=""
                     all_types["ARGPARSER_WRITE_ARGS"]="bool"
               all_arg_numbers["ARGPARSER_WRITE_ARGS"]="0"
                all_arg_groups["ARGPARSER_WRITE_ARGS"]="General options"
                     all_notes["ARGPARSER_WRITE_ARGS"]=""
                all_help_texts["ARGPARSER_WRITE_ARGS"]="write the arguments from ARGPARSER_ARG_ARRAY_NAME to STDOUT"

    # Define ${script_args}, the argument that later holds the script's
    # command line.
                         all_positional_args+=("script_args")
               all_value_names["script_args"]="command_line"
            all_default_values["script_args"]="--"
             all_choice_values["script_args"]=""
    all_resolved_choice_values["script_args"]=""
                     all_types["script_args"]="str"
               all_arg_numbers["script_args"]="*"
                all_arg_groups["script_args"]="Positional arguments"
                     all_notes["script_args"]=""
                all_help_texts["script_args"]="the indexed array in which the Argparser stores the script's command line upon parsing its own arguments"

    # Define ${help}, the Argparser's help option.
             all_short_options["help"]=""
              all_long_options["help"]="help"
               all_value_names["help"]=""
            all_default_values["help"]="false"
             all_choice_values["help"]=""
    all_resolved_choice_values["help"]=""
                     all_types["help"]="bool"
               all_arg_numbers["help"]="0"
                all_arg_groups["help"]="Help options"
                     all_notes["help"]=""
                all_help_texts["help"]="display this help and exit"

    # Define ${usage}, the Argparser's usage option.
             all_short_options["usage"]=""
              all_long_options["usage"]="usage"
               all_value_names["usage"]=""
            all_default_values["usage"]="false"
             all_choice_values["usage"]=""
    all_resolved_choice_values["usage"]=""
                     all_types["usage"]="bool"
               all_arg_numbers["usage"]="0"
                all_arg_groups["usage"]="Help options"
                     all_notes["usage"]=""
                all_help_texts["usage"]="display the usage and exit"

    # Define ${version}, the Argparser's version option.
             all_short_options["version"]=""
              all_long_options["version"]="version"
               all_value_names["version"]=""
            all_default_values["version"]="false"
             all_choice_values["version"]=""
    all_resolved_choice_values["version"]=""
                     all_types["version"]="bool"
               all_arg_numbers["version"]="0"
                all_arg_groups["version"]="Help options"
                     all_notes["version"]=""
                all_help_texts["version"]="display the version and exit"

    # Define ${argparser_logo}, the Argparser's hidden logo option with
    # the magic string "--argparser".
             all_short_options["argparser_logo"]=""
              all_long_options["argparser_logo"]="argparser"
               all_value_names["argparser_logo"]=""
            all_default_values["argparser_logo"]="false"
             all_choice_values["argparser_logo"]=""
    all_resolved_choice_values["argparser_logo"]=""
                     all_types["argparser_logo"]="bool"
               all_arg_numbers["argparser_logo"]="0"
                all_arg_groups["argparser_logo"]="Miscellaneous options"
                     all_notes["argparser_logo"]="hidden"
                all_help_texts["argparser_logo"]="display the logo and exit"
}

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_ALLOW_POSITIONAL_DELIMITER_END
    # - ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START
    # - 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_FLAG_NEGATION_PREFIXES
    # - 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_SUBCOMMAND_GROUP
    # - 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_COLORS
    # - ARGPARSER_USE_LONG_OPTIONS
    # - ARGPARSER_USE_SHORT_OPTIONS
    # - ARGPARSER_USE_STYLES
    # - ARGPARSER_USE_STYLES_IN_FILES
    # - ARGPARSER_USE_UNICODE
    # - 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_id
    local -a args
    local value

    # Read the arguments.

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

    # 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).
    # As ${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START} is set to "true",
    # all arguments after the first "--" are deemed the script's command
    # line.  As ${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END} is set to
    # "false", a "++" later on cannot reset this.
    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_ALLOW_POSITIONAL_DELIMITER_END=false \
        ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START=true \
        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_FLAG_NEGATION_PREFIXES="no" \
        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,?,help" \
        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_SUBCOMMAND_GROUP="Subcommands" \
        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,usage" \
        ARGPARSER_USE_COLORS="${ARGPARSER_USE_COLORS:-true}" \
        ARGPARSER_USE_LONG_OPTIONS=true \
        ARGPARSER_USE_SHORT_OPTIONS=false \
        ARGPARSER_USE_STYLES="${ARGPARSER_USE_STYLES:-tty}" \
        ARGPARSER_USE_UNICODE="${ARGPARSER_USE_UNICODE:-false}" \
        ARGPARSER_VERSION_EXIT_CODE=0 \
        ARGPARSER_VERSION_NUMBER="${argparser_version}" \
        ARGPARSER_VERSION_OPTIONS="V,version" \
        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_id in "${!ARGPARSER_ARGS[@]}"; do
        if [[ "${arg_id}" == "script_args" ]]; then
            # Set ${script_args} (the command line) as array.
            IFS="," read -d "" -r -a script_args \
                <<< "${ARGPARSER_ARGS[${arg_id}]}"

            script_args[-1]="${script_args[-1]%$'\n'}"  # '\n' from herestring.

            if [[ -z "${script_args[-1]}" ]]; then
                unset 'script_args[-1]'
            fi
        elif argparser_in_array "${arg_id}" "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_id}" ]]; 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_id}" ]]; then
                    value="${ARGPARSER_ARGS[${arg_id}]}"
                    if [[ "${value}" == "''" ]]; then
                        value=""
                    fi
                    declare -g "${arg_id}"="${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_id}]}"
            if [[ "${value}" == "''" ]]; then
                value=""
            fi
            declare -g "${arg_id}"="${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_ALLOW_POSITIONAL_DELIMITER_END
    # - ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START
    # - 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_FLAG_NEGATION_PREFIXES
    # - 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_SUBCOMMAND_GROUP
    # - 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_COLORS
    # - ARGPARSER_USE_LONG_OPTIONS
    # - ARGPARSER_USE_SHORT_OPTIONS
    # - ARGPARSER_USE_STYLES
    # - ARGPARSER_USE_UNICODE
    # - 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_ALLOW_POSITIONAL_DELIMITER_END=true
    ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START=true
    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_FLAG_NEGATION_PREFIXES="no"
    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,?,help"
    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_SUBCOMMAND_GROUP="Subcommands"
    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,usage"
    ARGPARSER_USE_COLORS=true
    ARGPARSER_USE_LONG_OPTIONS=true
    ARGPARSER_USE_SHORT_OPTIONS=false
    ARGPARSER_USE_STYLES="tty"
    ARGPARSER_USE_UNICODE=false
    ARGPARSER_VERSION_EXIT_CODE=0
    ARGPARSER_VERSION_NUMBER="${argparser_version}"
    ARGPARSER_VERSION_OPTIONS="V,version"
    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_SUBCOMMAND_GROUP (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_ALLOW_POSITIONAL_DELIMITER_END (read-only)
    # - ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START (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 (read-only)
    # - ARGPARSER_ERROR_STYLE (read-only)
    # - ARGPARSER_FLAG_NEGATION_PREFIXES (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_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_COLORS (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)
    # - ARGPARSER_USE_STYLES (read-only)
    # - ARGPARSER_USE_UNICODE (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_long_options
    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 option_name
    local -a option_names_arr
    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_ALLOW_POSITIONAL_DELIMITER_END
        ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START
        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_COLORS
        ARGPARSER_USE_LONG_OPTIONS
        ARGPARSER_USE_SHORT_OPTIONS
        ARGPARSER_USE_UNICODE
        ARGPARSER_WRITE_ARGS
    )
    for var in "${vars[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -d "" -r -a values \
            <<< "${!var}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi

        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_USAGE_FILE_INCLUDE_CHAR
    )
    for var in "${vars[@]}"; do
        if [[ "${var}" == "ARGPARSER_ARG_DELIMITER_2" ]]; then
            values=("${!var}")
        else
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -d "" -r -a values \
                <<< "${!var}"
            values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

            if [[ -z "${values[-1]}" ]]; then
                unset 'values[-1]'
            fi
        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 -d "" -r -a values \
            <<< "${!var}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi

        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 -d "" -r -a values \
            <<< "${!var}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi

        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 -d "" -r -a values \
            <<< "${!var}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi

        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 and long 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 -d "" -r -a option_names_arr \
            <<< "${!var}"
        option_names_arr[-1]="${option_names_arr[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${option_names_arr[-1]}" ]]; then
            unset 'option_names_arr[-1]'
        fi

        # Check if any option name is the empty string.
        if argparser_in_array "" "${option_names_arr[@]}"; then
            # Check if the empty string is included in the option names.
            error_message="Error: The environment variable \"\$1\" has an "
            error_message+="empty string given as one of the \$2 option "
            error_message+="names, instead of a legit name."

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

        # Check if any option name is given multiple times in the
        # current environment variable's value or across all yet
        # investigated environment variables' values.
        for option_name in "${option_names_arr[@]}"; do
            # Check if the option name is given multiple times in the
            # current environment variable's value.
            argparser_count "${option_name}" "${option_names_arr[@]}"
            if (( count > 1 )); then
                if (( "${#option_name}" == 1 )); then
                    error_message="Error: The environment variable \"\$1\" "
                    error_message+="has the short option \"-\$2\" given \$3 "
                    error_message+="times."

                    argparser_translate "Error env var option name duplication 1" \
                        "${error_message}" "${var}" "${option_name}" "${count}"
                else
                    error_message="Error: The environment variable \"\$1\" "
                    error_message+="has the long option \"--\$2\" given \$3 "
                    error_message+="times."

                    argparser_translate "Error env var option name duplication 2" \
                        "${error_message}" "${var}" "${option_name}" "${count}"
                fi
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi

            # Check if the option name is already given in another
            # environment variable's value.
            if (( "${#option_name}" == 1 )) \
                && [[ -n "${checked_short_options[${option_name}]+set}" \
                && "${checked_short_options[${option_name}]}" != "${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 option name duplication 3" \
                    "${error_message}" "${var}" "${option_name}" \
                    "${checked_short_options[${option_name}]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif (( "${#option_name}" > 1 )) \
                && [[ -n "${checked_long_options[${option_name}]+set}" \
                && "${checked_long_options[${option_name}]}" != "${var}" ]]
            then
                error_message="Error: The environment variable \"\$1\" has "
                error_message+="the long option \"--\$2\" given, but that is "
                error_message+="already in use by \"\$3\"."

                argparser_translate "Error env var option name duplication 4" \
                    "${error_message}" "${var}" "${option_name}" \
                    "${checked_long_options[${option_name}]}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi

            # Add the option name to the respective associative array of
            # all short/long option names.
            if (( "${#option_name}" == 1 )); then
                checked_short_options[${option_name}]="${var}"
            elif (( "${#option_name}" > 1 )); then
                checked_long_options[${option_name}]="${var}"
            fi
        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

    # Then, check that at least one flag negation prefix is given, and
    # none is empty.
    if [[ -z "${ARGPARSER_FLAG_NEGATION_PREFIXES}" ]]; then
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -d "" -r -a prefixes \
            <<< "${ARGPARSER_FLAG_NEGATION_PREFIXES}"
        prefixes[-1]="${prefixes[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${prefixes[-1]}" ]]; then
            unset 'prefixes[-1]'
        fi

        if argparser_in_array "" "${prefixes[@]}"; then
            error_message="Error: The environment variable "
            error_message+="\"ARGPARSER_FLAG_NEGATION_PREFIXES\" has an "
            error_message+="empty string given as prefix, instead of a legit "
            error_message+="prefix."

            argparser_translate "Error env var negation prefix empty" \
                "${error_message}"
            error_message="${translation}"
            error_messages+=("${error_message}")
        fi
    fi

    # 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 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
    # invocation, 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 translation identifier of the string in the dictionary
    # - $2: the string to use as fallback if no translation file is
    #       given or the identifier 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_LANGUAGE (read-only)
    # - ARGPARSER_TRANSLATION_FILE (read-only)

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

    # Read the arguments.
    translation_id="$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 translation identifier
    # does not exist in ${dictionary}, output a warning message and the
    # untranslated string.  Translate the warning message only if the
    # identifier 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[${translation_id}]+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 [[ "${translation_id}" == "Warning" ]]; then
                translation="${translation_id}"
                return
            elif [[ "${translation_id}" == "Warning no identifier" ]]; then
                warning_message="${warning_message/"\$1"/${ARGPARSER_TRANSLATION_FILE}}"
                warning_message="${warning_message/"\$2"/${translation_id}}"
            else
                argparser_translate "Warning no identifier" \
                    "${warning_message}" "${ARGPARSER_TRANSLATION_FILE}" \
                        "${translation_id}"
                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[${translation_id}]}" == "?" ]]; 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 [[ "${translation_id}" == "Warning" ]]; then
                translation="${translation_id}"
                return
            elif [[ "${translation_id}" == "Warning no translation" ]]; then
                warning_message="${warning_message/"\$1"/${ARGPARSER_TRANSLATION_FILE}}"
                warning_message="${warning_message/"\$2"/${ARGPARSER_LANGUAGE}}"
                warning_message="${warning_message/"\$3"/${translation_id}}"
            else
                argparser_translate "Warning no translation" \
                    "${warning_message}" "${ARGPARSER_TRANSLATION_FILE}" \
                    "${ARGPARSER_LANGUAGE}" "${translation_id}"
                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[${translation_id}]}"
        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_CHECK_ENV_VARS (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_SILENCE_ERRORS (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 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 invocation, 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%%=*}"
            name="${name##+( )}"
            name="${name%%+( )}"

            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#*=}"
                style="${style##+( )}"
                style="${style%%+( )}"
                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

    if (( "${#error_messages[@]}" > 0 && "${#warning_messages[@]}" > 0 )); then
        argparser_print_error_messages true false "${error_messages[@]}"

        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            printf '\n' >&2
        fi

        argparser_print_warning_messages true "${warning_messages[@]}"

        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    elif (( "${#error_messages[@]}" > 0 )); then
        argparser_print_error_messages true false "${error_messages[@]}"
        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    elif (( "${#warning_messages[@]}" > 0 )); then
        argparser_print_warning_messages true "${warning_messages[@]}"
    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_id
    local arg_number
    local -a args
    local -a args_definition
    local choice_values
    local -a col_arg_groups
    local -a col_arg_ids
    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_ids=("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_id 2>&1
        if [[ -z "${arg_id}" ]]; 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_ids+=("${arg_id}")
        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_ids[@]}"
    col_arg_ids=("${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_ids[@]}"; do
        # shellcheck disable=SC2190  # Indexed, not associative array.
        args+=("${col_arg_ids[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_id
    local -a args
    local error_message
    local header
    local line
    local lines
    local translation

    # 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 identifier.  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 identifier, and an arguments definition file
            # is given. Iterate over all arguments definition lines from
            # the file.  When the argument identifier in one line
            # matches the given identifier, output the identifier 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_id="${line%%"${ARGPARSER_ARG_DELIMITER_1}"*}"
                arg_id="${arg_id##+( )}"
                arg_id="${arg_id%%+( )}"

                if [[ "${arg_id}" == "${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_subcommands: the associative array holding the subcommands
    # - 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_id
    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 subcommand
    local translation
    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
        header[column_index]="${header[column_index]##+( )}"
        header[column_index]="${header[column_index]%%+( )}"
    done

    # Get the column indices of all fields.
    column_indices=(
        [id]=""
        [subcommand]=""
        [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 (or as subcommand, which will be removed
    # from the array later) 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}"
        fields=("${fields[@]##+( )}")
        fields=("${fields[@]%%+( )}")

        # 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.
        arg_id="${fields[${column_indices["id"]}]}"

        # Get the subcommand.
        if [[ -n "${column_indices["subcommand"]}" ]]; then
            subcommand="${fields[${column_indices["subcommand"]}]}"
        else
            subcommand=""
        fi
        all_subcommands[${arg_id}]="${subcommand}"

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

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

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

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

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

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

            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_id}"
                    error_messages+=("${error_message}")
                elif [[ "${range}" == *-*-* ]]; then
                    range_start="${range%%-*}"
                    range_stop="${range#*-}"
                    range_step="${range_stop#*-}"
                    range_stop="${range_stop%%-*}"

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

                    argparser_seq "${arg_id}" "${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_id}]="${choice_values_str}"
        all_resolved_choice_values[${arg_id}]="${resolved_choice_values_str}"

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

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

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

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

        # Get the help text.
        if [[ -n "${column_indices["help"]}" ]]; then
            help_text="${fields[${column_indices["help"]}]}"
        else
            help_text=""
        fi
        all_help_texts[${arg_id}]="${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_id
    local -a arg_ids
    local count
    local -A checked_long_options
    local -A checked_short_options
    local error_message
    local long_option
    local -a long_help_options
    local -a long_options
    local -a long_usage_options
    local -a long_version_options
    local option_name
    local -a option_names_arr
    local short_option
    local -a short_help_options
    local -a short_options
    local -a short_usage_options
    local -a short_version_options
    local -a sorted_array
    local translation

    # Read the help, usage, and version option names and separate them
    # by short and long names.
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_HELP_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_help_options+=("${option_name}")
        else
            long_help_options+=("${option_name}")
        fi
    done

    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_USAGE_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_usage_options+=("${option_name}")
        else
            long_usage_options+=("${option_name}")
        fi
    done

    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_VERSION_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_version_options+=("${option_name}")
        else
            long_version_options+=("${option_name}")
        fi
    done

    # Get and sort all argument 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_ids=("${sorted_array[@]}")

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

        # 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 uses a character reserved for the help, usage, or version
        # message, if it 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_id}" "${#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}" \
                    "${short_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_id}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_USAGE}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]] \
                && argparser_in_array "${short_option}" \
                    "${short_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_id}" "${short_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_VERSION}" == true \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]] \
                && argparser_in_array "${short_option}" \
                    "${short_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_id}" "${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_id}" "${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_id}" "${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_id}" ]]
                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_id}" "${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_id}"
            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 uses a string reserved for the help, usage, or
        # version message, if it 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_id}" "${#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 ]] \
                && argparser_in_array "${long_option}" \
                    "${long_help_options[@]}"
            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 \"--\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="help message."

                argparser_translate "Error arg def long name help" \
                    "${error_message}" "${arg_id}" "${long_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_USAGE}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true ]] \
                && argparser_in_array "${long_option}" \
                    "${long_usage_options[@]}"
            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 \"--\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="usage message."

                argparser_translate "Error arg def long name usage" \
                    "${error_message}" "${arg_id}" "${long_option}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            elif [[ "${ARGPARSER_ADD_VERSION}" == true \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true ]] \
                && argparser_in_array "${long_option}" \
                    "${long_version_options[@]}"
            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 \"--\$2\" "
                error_message+="defined, which is reserved for invoking the "
                error_message+="version message."

                argparser_translate "Error arg def long name version" \
                    "${error_message}" "${arg_id}" "${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_id}" "${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_id}" "${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_id}" ]]
                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_id}" "${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_id}"
            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_id
    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_id in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
            <<< "${default_values_str}"
        choice_values_str="${all_choice_values[${arg_id}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
            resolved_choice_values_arr \
                <<< "${resolved_choice_values_str}"
        type="${all_types[${arg_id}]}"
        arg_number="${all_arg_numbers[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_id}]}"

        # 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_id}" "${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_id}" "${#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_id}" "${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_id}" "${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_id}" \
                            "${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_id}" \
                            "${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_id}" "${optional_arg}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            else
                optional_arg="${arg_id}"
            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_id}" "${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_id}"
            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_id}" "${infinite_arg_number_arg}"
                error_messages+=("${error_message}")
            else
                infinite_arg_number_arg="${arg_id}"
            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_id}" ]]; 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_id}"
                    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_id}" "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done

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

                argparser_translate "Error arg def pos note" \
                    "${error_message}" "${arg_id}" "${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_id
    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_id in "${!all_short_options[@]}"; do
        # Read the argument's definition.
        default_values_str="${all_default_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
            <<< "${default_values_str}"
        choice_values_str="${all_choice_values[${arg_id}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a \
            resolved_choice_values_arr \
                <<< "${resolved_choice_values_str}"
        type="${all_types[${arg_id}]}"
        arg_number="${all_arg_numbers[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_id}]}"

        # 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_id}" "${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_id}" "${#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_id}" "${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_id}" "${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_id}" \
                            "${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_id}" \
                            "${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_id}" \
                            "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${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_id}" "${choice_value}"
                error_message="${translation}"
                error_messages+=("${error_message}")
            fi
        done

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

                argparser_translate "Error arg def option note" \
                    "${error_message}" "${arg_id}" "${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_ARG_DELIMITER_2 (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_id
    local -a arg_ids
    local -a help_texts
    local i
    local joined_array
    local -a long_help_options
    local -a long_options
    local -a long_usage_options
    local -a long_version_options
    local option_name
    local -a option_names_arr
    local -a short_help_options
    local -a short_options
    local -a short_usage_options
    local -a short_version_options
    local translation
    local value
    local var
    local -a vars

    # Set the definition fields for the help, usage, and version message
    # options.  Read the help, usage, and version option names and
    # separate them by short and long names.
    arg_ids=(
        "help"
        "usage"
        "version"
    )
    short_options=()
    long_options=()

    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_HELP_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_help_options+=("${option_name}")
        else
            long_help_options+=("${option_name}")
        fi
    done

    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${short_help_options[@]}"
        short_options+=("${joined_array}")
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${long_help_options[@]}"
        long_options+=("${joined_array}")

    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_USAGE_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_usage_options+=("${option_name}")
        else
            long_usage_options+=("${option_name}")
        fi
    done

    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${short_usage_options[@]}"
        short_options+=("${joined_array}")
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${long_usage_options[@]}"
        long_options+=("${joined_array}")

    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a option_names_arr \
        <<< "${ARGPARSER_VERSION_OPTIONS}"

    for option_name in "${option_names_arr[@]}"; do
        if (( "${#option_name}" == 1 )); then
            short_version_options+=("${option_name}")
        else
            long_version_options+=("${option_name}")
        fi
    done

    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${short_version_options[@]}"
        short_options+=("${joined_array}")
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${long_version_options[@]}"
        long_options+=("${joined_array}")

    # Translate the strings for the help texts.
    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_id="${arg_ids[i]}"

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

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

function argparser_get_args_definition() {
    # Set up the arguments definition, reading, parsing, and verifying
    # it.
    #
    # Nonlocals:
    # - all_positional_args: the indexed array holding the positional
    #   argument names
    # - all_subcommands: the associative array holding the subcommands
    #   (read-only)
    # - is_sourced: whether the Argparser has been sourced (read-only)
    #
    # Environment:
    # - ARGPARSER_ARG_ARRAY_NAME
    # - ARGPARSER_CHECK_ARG_DEF (read-only)
    # - ARGPARSER_SCRIPT_NAME (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 error_message
    local -a error_messages
    local i
    local message
    local -a messages
    local name
    local -a names
    local subcommand
    local translated_error
    local translation

    # Get the arguments definition.
    if [[ "${is_sourced}" == false ]]; then
        # The Argparser is run as standalone script and not sourced, so
        # read the arguments definition from STDIN into ${args} and
        # remove leading blank lines.  If STDIN is empty, output an
        # error message.
        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
        # The Argparser is sourced, but the variable that
        # ${ARGPARSER_ARG_ARRAY_NAME} refers to is not defined.  Guess
        # how it may be called by searching the set variables for a
        # variable name starting with "arg" (ignoring the internal
        # ${argparser_version} variable that's already set at this
        # point) to give a clearer error message.  If no such variable
        # name is found, skip that part of the message.
        names=("${!arg@}")
        for name in "${names[@]}"; do
            if [[ "${name}" != "argparser_version" ]]; then
                break
            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}" "${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 -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}"

    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.
    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

    # Remove the subcommands from the positional arguments.
    for i in "${!all_positional_args[@]}"; do
        for subcommand in "${all_subcommands[@]}"; do
            if [[ -n "${subcommand}" \
                && "${all_positional_args[i]}" == "${subcommand}" ]]
            then
                unset 'all_positional_args[i]'
            fi
        done
    done

    all_positional_args=("${all_positional_args[@]}")  # Remove empty fields.

    # Add the help, usage, and version message options to the arguments
    # definition.
    argparser_add_args_definition_help_options
}

# Define the Argparser functions for the argument parsing.
function argparser_get_arg_id() {
    # Get the argument identifier 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_id: the argument identifier, if the option 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_id in "${!all_short_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
                <<< "${all_short_options[${arg_id}]}"

            # 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_id in "${!all_long_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                <<< "${all_long_options[${arg_id}]}"

            # 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_id=""
}

function argparser_get_display_names() {
    # Get the argument's display names formatted for pretty-printing.
    # For subcommands and positional arguments, these are the value
    # names.  For keyword arguments, these are the short and/or long
    # option names, or the value names.  In the latter case, these need
    # to be explicitly requested.
    #
    # Arguments:
    # - $1: the argument identifier
    # - $2: which names to use ("short+long", "long+short", "short",
    #       "long", or "value")
    # - $3: whether to colorize the display names by argparser_colorize
    #
    # Nonlocals:
    # - all_arg_numbers: the associative array holding the argument
    #   numbers (read-only)
    # - 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)
    # - display_names_arr: all short and/or long option names or all
    #   value names as indexed array
    # - display_names_str: all short and/or long option names or all
    #   value names 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_id
    local arg_number
    local colorize
    local -a colorized_array
    local joined_array
    local long_option
    local -a long_options
    local names
    local short_option
    local -a short_options
    local value_name
    local -a value_names

    # Read the arguments.
    arg_id="$1"
    names="$2"
    colorize="$3"

    # Read the argument's definition.
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a short_options \
        <<< "${all_short_options[${arg_id}]}"
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
        <<< "${all_long_options[${arg_id}]}"
    IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a value_names \
        <<< "${all_value_names[${arg_id}]}"
    arg_number="${all_arg_numbers[${arg_id}]}"

    # If no value name is given, create one by capitalizing the first
    # long option name, if existing, or else from the first short option
    # name.
    if (( "${#value_names[@]}" == 0 )); then
        if (( "${#long_options[@]}" > 0 )); then
            value_name="${long_options[0]//-/_}"
        else
            value_name="${short_options[0]//-/_}"
        fi
        value_names=("${value_name^^}")
    fi

    # If there are now less value names than the argument number
    # suggests (and the argument is not variadic), create the remaining
    # value names by repeating the last value name.
    if ! argparser_in_array "${arg_number}" "+" "*" "?"; then
        while (( "${#value_names[@]}" < arg_number )); do
            value_names+=("${value_names[-1]}")
        done
    fi

    # Add the leading hyphen(s) to the short and long option names.
    # This needs to be done after possibly having created the value
    # names from them, as otherwise, the latter would start with the
    # underscore-turned hyphens, which would need to be stripped, again.
    short_options=("${short_options[@]/#/-}")
    long_options=("${long_options[@]/#/--}")

    # Possibly colorize the short and long option names, and the value
    # names.
    if [[ "${colorize}" == true ]]; then
        argparser_colorize "${styles["short_options"]}" 1 "array" \
            "${short_options[@]}"
        short_options=("${colorized_array[@]}")

        argparser_colorize "${styles["long_options"]}" 1 "array" \
            "${long_options[@]}"
        long_options=("${colorized_array[@]}")

        argparser_colorize "${styles["value_names"]}" 1 "array" \
            "${value_names[@]}"
        value_names=("${colorized_array[@]}")
    fi

    # Merge and concatenate the short and/or long option names or the
    # value names.
    if (( "${#short_options[@]}" > 0 && "${#long_options[@]}" > 0 )); then
        if [[ "${names}" == "short+long" ]]; then
            display_names_arr=("${short_options[@]}" "${long_options[@]}")
        elif [[ "${names}" == "long+short" ]]; then
            display_names_arr=("${long_options[@]}" "${short_options[@]}")
        elif [[ "${names}" == "short" ]]; then
            display_names_arr=("${short_options[@]}")
        elif [[ "${names}" == "long" ]]; then
            display_names_arr=("${long_options[@]}")
        else
            display_names_arr=("${value_names[@]}")
        fi
    elif (( "${#short_options[@]}" > 0 )); then
        if argparser_in_array "${names}" "short+long" "long+short" "short"
        then
            display_names_arr=("${short_options[@]}")
        elif [[ "${names}" == "value" ]]; then
            display_names_arr=("${value_names[@]}")
        else
            display_names_arr=()
        fi
    elif (( "${#long_options[@]}" > 0 )); then
        if argparser_in_array "${names}" "short+long" "long+short" "long"; then
            display_names_arr=("${long_options[@]}")
        elif [[ "${names}" == "value" ]]; then
            display_names_arr=("${value_names[@]}")
        else
            display_names_arr=()
        fi
    else
        display_names_arr=("${value_names[@]}")
    fi

    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${display_names_arr[@]}"
    display_names_str="${joined_array}"
}

function argparser_parse_arg() {
    # Parse an argument given to the script.
    #
    # Arguments:
    # - $1: the argument to parse
    #
    # Nonlocals:
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - is_positional: whether the arguments are to be interpreted as
    #   positional
    # - is_positional_only: whether the positional-only arguments
    #   delimiter "--" has already been set and has not been unset by
    #   "++"
    # - is_self_parsing: whether the Argparser currently parses its own
    #   arguments (read-only)
    # - messages: the parsed argument as message, starting with
    #   "Argument: " 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, also output 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}" != [-+]* ]]; then
        # The argument doesn't start with a hyphen ("-") or plus sign
        # ("+"), so deem it a value to a previous keyword argument, a
        # positional argument, or a subcommand.
        messages+=("Value: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}" == true \
        && "${is_positional_only}" == true \
        && "${given_arg}" != "++" \
        && "${given_arg}" != "++="* ]]
    then
        # The positional-only arguments delimiter "--" has already been
        # set and not been unset by the allowed "++", and the current
        # argument isn't this "++", so deem the value a positional
        # argument.
        messages+=("Value: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}" == false \
        && "${is_positional_only}" == true ]]
    then
        # The positional-only arguments delimiter "--" has already been
        # set and cannot be unset by the disallowed "++", so deem the
        # value a positional argument.
        messages+=("Value: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START}" == true \
        && "${given_arg}" == "--" ]]
    then
        # The argument is the (allowed) positional-only arguments
        # delimiter "--".  Set the flag that it has been set, such that
        # all following arguments are interpreted as positional.
        is_positional=true
        is_positional_only=true
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START}" == true \
        && "${given_arg}" == "--="* ]]
    then
        # The argument is the (allowed) positional-only 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}"
        error_messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_START}" == false \
        && ("${given_arg}" == "--" || "${given_arg}" == "--="*) ]]
    then
        # The argument is the positional-only arguments delimiter "--",
        # which is disallowed, so deem the value a positional
        # argument.
        messages+=("Value: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}" == true \
        && "${given_arg}" == "++" ]]
    then
        # The argument is the (allowed) positional-only arguments
        # delimiter "++".  Set the flag that it has been set (and thus
        # "--" has been unset), such that all following arguments are
        # interpreted as usual.
        is_positional=true
        is_positional_only=false
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}" == true \
        && "${given_arg}" == "++="* ]]
    then
        # The argument is the (allowed) positional-only 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}"
        error_messages+=("${error_message}")
        messages+=("Argument: ${given_arg}")
    elif [[ "${ARGPARSER_ALLOW_POSITIONAL_DELIMITER_END}" == false \
        && ("${given_arg}" == "++" || "${given_arg}" == "++="*) ]]
    then
        # The argument is the positional-only arguments delimiter "++",
        # which is disallowed, so deem the value a positional
        # argument.
        messages+=("Value: ${given_arg}")
    elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true \
        && "${given_arg::2}" == "--" ]]
    then
        # The argument is a long option with a double hyphen as prefix,
        # so check whether the given argument is defined.
        argparser_parse_long_option "${given_arg}"
    elif [[ "${ARGPARSER_USE_LONG_OPTIONS}" == true \
        && "${ARGPARSER_ALLOW_FLAG_INVERSION}" == true \
        && "${given_arg::2}" == "++" ]]
    then
        # The argument is a long option with an (allowed) 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}" == -[!-+] ]]
    then
        # The argument is a short option with a single hyphen as prefix,
        # so check whether the given argument is defined.
        argparser_parse_short_option "${given_arg}"
    elif [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true \
        && "${ARGPARSER_ALLOW_FLAG_INVERSION}" == true \
        && "${given_arg::2}" == +[!-+] ]]
    then
        # The argument is a short option with an (allowed) doubled plus
        # sign as prefix, 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}"
        error_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}"
        error_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)
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - messages: the parsed argument as message, starting with
    #   starting with "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_id
    local count
    local error_message
    local given_arg
    local is_negated
    local long_option
    local -a long_options
    local negation_prefix
    local -a negation_prefixes
    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 -d "" -r -a values \
            <<< "${given_arg#*=}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi
    else
        values=("")
    fi
    argparser_get_arg_id "long" "${option_name}"

    # If no argument identifier for the entire option name has been
    # found, the option name starts with one of the
    # ${ARGPARSER_FLAG_NEGATION_PREFIXES}, and flag negation is enabled,
    # strip the negating prefix, convert it to a "+", and set the option
    # name's remainder as new option name.
    if [[ "${ARGPARSER_ALLOW_FLAG_NEGATION}" == true && -z "${arg_id}" ]]; then
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a negation_prefixes \
            <<< "${ARGPARSER_FLAG_NEGATION_PREFIXES}"

        for negation_prefix in "${negation_prefixes[@]}"; do
            if [[ "${option_name}" == "${negation_prefix}-"* ]]; then
                is_negated=true
                option_name="${option_name#"${negation_prefix}-"}"
                argparser_get_arg_id "long" "${option_name}"

                actual_prefix="${prefix}"
                if [[ "${prefix}" == "-" ]]; then
                    prefix="+"
                else
                    prefix="-"
                fi
            fi
        done
    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_id}" ]]
    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_id in "${!all_long_options[@]}"; do
            # Read the argument's definition.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                <<< "${all_long_options[${arg_id}]}"

            # 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_id in "${!all_long_options[@]}"; do
                # Read the argument's definition.
                IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a long_options \
                    <<< "${all_long_options[${arg_id}]}"

                # 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_id}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_id}")
                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}"
            error_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}"
                error_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}"
                error_messages+=("${error_message}")
                messages+=("Argument: ${given_arg}")
            fi
        fi
    else
        if [[ -n "${arg_id}" ]]; then
            if [[ -n "${values[0]}" ]]; then
                # Output the argument identifier, the prefix, and the
                # values.
                messages+=("Argument: ${arg_id}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_id}")
                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}"
                error_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}"
                error_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)
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - messages: the parsed argument as message, starting with
    #   starting with "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_id
    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 -d "" -r -a values \
            <<< "${given_arg#*=}"
        values[-1]="${values[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values[-1]}" ]]; then
            unset 'values[-1]'
        fi
    else
        values=("")
    fi
    argparser_get_arg_id "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_id "short" "${char}"
            if [[ -z "${arg_id}" ]]; 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}"
                error_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_id}")
            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_id}]}"
            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_id}" ]]; then
            if [[ -n "${values[0]}" ]]; then
                # Output the argument identifier, the prefix, and the
                # values.
                messages+=("Argument: ${arg_id}")
                messages+=("Prefix: ${prefix}")
                for value in "${values[@]}"; do
                    messages+=("Value: ${value}")
                done
            else
                # Output the argument identifier and the prefix.
                messages+=("Argument: ${arg_id}")
                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}"
            error_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)
    # - args: the associative array holding the parsed arguments' values
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - given_subcommand: the active subcommand, if given, or the empty
    #   string, else
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)

    # Define the local variables.
    local arg_id
    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 index
    local joined_array
    local -a positional_args
    local positional_args_count
    local required_args_count
    local subcommand
    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 -d "" -r -a given_args \
            <<< "${given_arg}"
        given_args[-1]="${given_args[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${given_args[-1]}" ]]; then
            unset 'given_args[-1]'
        fi

        values+=("${given_args[@]}")
    done

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

        # Skip those arguments that belong to a different subcommand
        # than given.
        if [[ "${subcommand}" != "${given_subcommand}" ]]; then
            continue
        fi
        positional_args+=("${arg_id}")

        # 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, for a given subcommand (if any), there cannot
    # be arguments with an arbitrary number of values defined when there
    # are arguments with default values defined, except if both are the
    # same, single argument, 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, or
    # there is only one argument defined).  This allows to distinguish
    # these two cases.
    args_count="${#values[@]}"
    positional_args_count="${#positional_args[@]}"
    if (( args_count > required_args_count \
        && default_args_count > 0 \
        && positional_args_count > 1 ))
    then
        # There are arguments having default values given, and there are
        # at least two arguments defined.  Get the argument identifiers
        # for all given arguments and pass them their values.
        index=0
        for arg_id in "${all_positional_args[@]}"; do
            # Read the argument's definition.
            subcommand="${all_subcommands[${arg_id}]}"
            arg_number="${all_arg_numbers[${arg_id}]}"

            # Skip those arguments that belong to a different subcommand
            # than given.
            if [[ "${subcommand}" != "${given_subcommand}" ]]; then
                continue
            fi

            # Pass the positional argument as many values as requested.
            argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                "${values[@]:index:arg_number}"
            args[${arg_id}]="${joined_array}"
            (( index += arg_number ))
        done
    else
        # There are no arguments having default values given, or there
        # is only one argument defined, that may have a default value.
        # Get the argument identifiers for all given arguments and pass
        # them their values.
        index=0
        for arg_id in "${all_positional_args[@]}"; do
            # Read the argument's definition.
            subcommand="${all_subcommands[${arg_id}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a default_values_arr \
                <<< "${all_default_values[${arg_id}]}"
            arg_number="${all_arg_numbers[${arg_id}]}"

            # Skip those arguments that belong to a different subcommand
            # than given.
            if [[ "${subcommand}" != "${given_subcommand}" ]]; then
                continue
            fi

            # Skip the defined arguments having default values, but
            # which aren't (and cannot be) given, as long as there is
            # only one positional argument.
            if [[ -n "${default_values_arr[0]}" ]] \
                && (( positional_args_count > 1 ))
            then
                continue
            fi

            # If the positional argument accepts an arbitrary number of
            # values, pass it all remaining given arguments.  For "?",
            # pass one argument, if existing, or else zero.  Else, pass
            # only as many arguments as requested.
            if [[ "${arg_number}" == "+" || "${arg_number}" == "*" ]]; then
                argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                    "${values[@]:index}"
                args[${arg_id}]="${joined_array}"
                index="${args_count}"

                break
            elif [[ "${arg_number}" == "?" ]]; then
                if (( index < args_count)); then
                    args[${arg_id}]="${values[index]}"
                    (( index++ ))
                else
                    args[${arg_id}]=""
                fi
            else
                argparser_join "${ARGPARSER_ARG_DELIMITER_2}" \
                    "${values[@]:index:arg_number}"
                args[${arg_id}]="${joined_array}"
                (( 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}"
        elif (( args_count == 1 )); then
            error_message="Error: \$1 positional arguments are required, but "
            error_message+="1 is given."

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

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

function argparser_check_arg_values() {
    # Check if a script's argument accords to its definition.
    #
    # Arguments:
    # - $1: the argument identifier
    # - $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_subcommands: the associative array holding the subcommands
    #   (read-only)
    # - all_types: the associative array holding the argument types
    #   (read-only)
    # - arg_values: the parsed argument's value
    # - given_subcommand: the active subcommand, if given, or the empty
    #   string, else
    # - error_messages: the error messages, starting with "Error: "
    #   (translated), as indexed array
    # - warning_messages: the warning messages, starting with
    #   "Warning: " (translated), as indexed array
    #
    # Environment:
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_COUNT_FLAGS (read-only)

    # Define the local variables.
    local arg_id
    local arg_names
    local arg_number
    local choice_values_str
    local count
    local count_hyphen
    local count_plus
    local default_values_str
    local -a display_names_arr
    local display_names_str
    local error_message
    local i
    local joined_array
    local note
    local -a notes
    local prefix
    local -a prefixes
    local -a resolved_choice_values_arr
    local resolved_choice_values_str
    local subcommand
    local subcommand_names_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_id="$1"
    if argparser_in_array "${arg_id}" "${all_positional_args[@]}"; then
        prefixes=()
    else
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a prefixes <<< "$2"
    fi

    if [[ "${arg_id}" == "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.
        subcommand="${all_subcommands[${arg_id}]}"
        default_values_str="${all_default_values[${arg_id}]}"
        choice_values_str="${all_choice_values[${arg_id}]}"
        resolved_choice_values_str="${all_resolved_choice_values[${arg_id}]}"
        resolved_choice_values_arr=("${resolved_choice_values_str}")
        type="${all_types[${arg_id}]}"
        arg_number="${all_arg_numbers[${arg_id}]}"
        notes=("${all_notes[${arg_id}]}")
    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 -d "" -r -a values_arr \
            <<< "${values_str}"
        values_arr[-1]="${values_arr[-1]%$'\n'}"  # '\n' from herestring.

        if [[ -z "${values_arr[-1]}" ]]; then
            unset 'values_arr[-1]'
        fi

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

    # Concatenate the name of all short and long options for the error
    # and warning messages.
    argparser_get_display_names "${arg_id}" "short+long" false
    arg_names="${display_names_str}"

    # If the argument doesn't belong to the given subcommand (if any),
    # but was given, output an error message.  If it wasn't given, skip
    # the subsequent checks.
    if [[ "${subcommand}" != "${given_subcommand}" ]]; then
        if (( "${#values_arr[@]}" == 0 && "${#prefixes[@]}" == 0 )); then
            return
        fi

        if [[ -z "${given_subcommand}" ]]; then
            argparser_get_display_names "${subcommand}" "value" false
            subcommand_names_str="${display_names_str}"

            error_message="Error: The argument \"\$1\" is known, but defined "
            error_message+="for the subcommand \"\$2\", which is not given."

            argparser_translate "Error arg subcommand 1" "${error_message}" \
                "${arg_names}" "${subcommand_names_str}"
            error_message="${translation}"
            error_messages+=("${error_message}")
            return
        else
            argparser_get_display_names "${given_subcommand}" "value" false
            subcommand_names_str="${display_names_str}"

            error_message="Error: The argument \"\$1\" is known, but not "
            error_message+="defined for the given subcommand \"\$2\"."

            argparser_translate "Error arg subcommand 2" "${error_message}" \
                "${arg_names}" "${subcommand_names_str}"
            error_message="${translation}"
            error_messages+=("${error_message}")
            return
        fi
    fi

    # 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}" \
                "${arg_names}"
            warning_message="${translation}"
            warning_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.
    if argparser_in_array "" "${values_arr[@]}" \
        && ! argparser_in_array "${arg_number}" "*" "?" 0
    then
        error_message="Error: The option \"\$1\" is no flag and thus needs a "
        error_message+="value after the option name."

        argparser_translate "Error arg no flag 1" "${error_message}" \
            "${arg_names}"
        error_message="${translation}"
        error_messages+=("${error_message}")
        return
    fi

    # 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 "+" prefix or one of the ${ARGPARSER_FLAG_NEGATION_PREFIXES}
    # 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 \"{\$2}-\" prefix."

            argparser_translate "Error arg no flag 2" "${error_message}" \
                "${arg_names}" "${ARGPARSER_FLAG_NEGATION_PREFIXES}"
            error_message="${translation}"
            error_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 \"{\$2}-\" prefix."

            argparser_translate "Error arg no flag 3" "${error_message}" \
                "${arg_names}" "${ARGPARSER_FLAG_NEGATION_PREFIXES}"
            error_message="${translation}"
            error_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}" \
                "${arg_names}"
            error_message="${translation}"
            error_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
                arg_values=1
            else
                arg_values=-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.
            arg_values="${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}" \
                "${arg_names}" "${#values_arr[@]}"
            error_message="${translation}"
            error_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}" "${arg_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            warning_messages+=("${warning_message}")

            arg_values="${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}" "${arg_names}" "${#values_arr[@]}"
            error_message="${translation}"
            error_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}" "${arg_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            warning_messages+=("${warning_message}")

            arg_values="${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}" "${arg_names}" "${#values_arr[@]}"
            error_message="${translation}"
            error_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}" "${arg_names}" "${#values_arr[@]}" \
                "${default_values_str}"
            warning_message="${translation}"
            warning_messages+=("${warning_message}")

            arg_values="${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 ))
            arg_values="${count}"
        else
            if [[ "${prefixes[-1]}" == "-" ]]; then
                arg_values=true
            else
                arg_values=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}" \
                "${arg_names}" "${arg_number}" "${#values_arr[@]}"
            error_message="${translation}"
            error_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}" "${arg_names}" "${arg_number}" \
                "${#values_arr[@]}" "${default_values_str}"
            warning_message="${translation}"
            warning_messages+=("${warning_message}")

            arg_values="${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}" \
                    "${arg_names}" "${choice_values_str}" "${values_str}"
                error_message="${translation}"
                error_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}" \
                "${arg_names}" "${value}"
            error_message="${translation}"
            error_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}" \
                "${arg_names}" "${value}"
            error_message="${translation}"
            error_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}" \
                "${arg_names}" "${value}"
            error_message="${translation}"
            error_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}" \
                "${arg_names}" "${value}"
            error_message="${translation}"
            error_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}" \
                "${arg_names}" "${value}"
            error_message="${translation}"
            error_messages+=("${error_message}")
            return
        fi
    done

    # Output the checked values.
    argparser_join "${ARGPARSER_ARG_DELIMITER_2}" "${values_arr[@]}"
    arg_values="${joined_array}"
}

function argparser_parse_args() {
    # Parse the script's given arguments and check if they accord to
    # their definition.  Possibly, print a help, usage, or version
    # 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 (read-only)
    # - all_short_options: the associative array holding the short
    #   option names (read-only)
    # - all_subcommands: the associative array holding the subcommands
    #   (read-only)
    # - is_self_parsing: whether the Argparser currently parses its own
    #   arguments (read-only)
    #
    # Globals:
    # - ${ARGPARSER_ARG_ARRAY_NAME}: the parsed and checked arguments
    #   with identifier and value as associative array
    #
    # Environment:
    # - ARGPARSER_ALLOW_ARG_INTERMIXING (read-only)
    # - ARGPARSER_ARG_ARRAY_NAME
    # - ARGPARSER_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (read-only)
    # - ARGPARSER_SILENCE_ERRORS (read-only)
    # - ARGPARSER_SILENCE_WARNINGS (read-only)

    # Define the local variables.
    local arg_id
    local arg_number
    local -A arg_numbers
    local -a arg_prefixes
    local arg_value
    local arg_values
    local declaration
    local -a error_messages
    local given_arg
    local -a given_args
    local -a given_positional_args
    local given_subcommand
    local is_help
    local is_positional
    local is_positional_only
    local is_positional_start
    local is_usage
    local is_version
    local message
    local -a messages
    local prefix
    local -A prefixes
    local subcommand
    local -a warning_messages

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

    # Parse the script's given arguments.
    unset args
    local -A args

    is_positional=true
    is_positional_only=false
    is_positional_start=true

    given_positional_args=()
    given_subcommand=""

    error_messages=()

    for given_arg in "${given_args[@]}"; do
        # Parse the argument, then read the output message and set the
        # argument's value or prefix. In case of arguments given
        # multiple times, i.e., when the identifier already exists in
        # ${!args[@]}, add the new value or prefix to the previously
        # given ones.
        messages=()
        argparser_parse_arg "${given_arg}"

        for message in "${messages[@]}"; do
            if [[ "${message}" == "Argument"* ]]; then
                # 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_id="${message#Argument: }"
                if [[ -z "${args[${arg_id}]+set}" ]]; then
                    args[${arg_id}]="${ARGPARSER_ARG_DELIMITER_2}"
                else
                    args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                fi
                arg_numbers[${arg_id}]=0
            elif [[ "${message}" == "Prefix"* ]]; then
                # Set the current argument's prefix ("-" or "+").
                prefix="${message#Prefix: }"
                if [[ -z "${prefixes[${arg_id}]+set}" ]]; then
                    prefixes[${arg_id}]="${prefix}"
                else
                    prefixes[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                    prefixes[${arg_id}]+="${prefix}"
                fi
            elif [[ "${message}" == "Value"* ]]; then
                # 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.
                arg_value="${message#Value: }"
                if [[ "${is_positional_start}" == true \
                    && "${is_positional}" == true ]]
                then
                    # The value is given in the initial positional
                    # location and could be a positional argument or a
                    # subcommand.
                    if argparser_in_array "${arg_value}" "${all_subcommands[@]}"
                    then
                        given_subcommand="${arg_value}"
                    else
                        given_positional_args+=("${arg_value}")
                    fi
                elif [[ "${is_positional}" == true ]]; then
                    # The value is given in a positional-only location.
                    given_positional_args+=("${arg_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_id}]}"
                    if [[ "${arg_numbers[${arg_id}]}" == 1 \
                        && "${arg_number}" == "?" ]]
                    then
                        # The value is a positional argument.
                        given_positional_args+=("${arg_value}")
                    elif [[ "${arg_numbers[${arg_id}]}" == "${arg_number}" \
                        && "${arg_number}" != "+" \
                        && "${arg_number}" != "*" ]]
                    then
                        # The value is a positional argument.
                        given_positional_args+=("${arg_value}")
                    elif [[ "${args[${arg_id}]}" \
                        == "${ARGPARSER_ARG_DELIMITER_2}" ]]
                    then
                        # The value is the first value to the current
                        # keyword argument.
                        args[${arg_id}]="${arg_value}"
                        args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        (( arg_numbers[${arg_id}]++ ))
                    elif (( "${#args[${arg_id}]}" >= 2 )) \
                        && [[ "${args[${arg_id}]: -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_id}]="${args[${arg_id}]::-1}"
                        args[${arg_id}]+="${arg_value}"
                        args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        (( arg_numbers[${arg_id}]++ ))
                    else
                        # The value is at least on the second place
                        # after one of the current keyword argument's
                        # option names.
                        args[${arg_id}]+="${arg_value}"
                        args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                        (( arg_numbers[${arg_id}]++ ))
                    fi
                else
                    if [[ "${args[${arg_id}]}" \
                        == "${ARGPARSER_ARG_DELIMITER_2}" ]]
                    then
                        # The value is the first value to the current
                        # keyword argument.
                        args[${arg_id}]="${arg_value}"
                        args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                    elif (( "${#args[${arg_id}]}" >= 2 )) \
                        && [[ "${args[${arg_id}]: -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_id}]="${args[${arg_id}]::-1}"
                        args[${arg_id}]+="${arg_value}"
                        args[${arg_id}]+="${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_id}]+="${arg_value}"
                        args[${arg_id}]+="${ARGPARSER_ARG_DELIMITER_2}"
                    fi
                    (( arg_numbers[${arg_id}]++ ))
                fi
            fi
        done

        is_positional_start=false
    done

    # If the help, usage, or version message was requested (in this
    # order of priority), print it.  To this end, check whether the
    # respective argument identifier 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
    # set to "true", and check their values afterwards in the intended
    # order (since 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_id in "${!prefixes[@]}"; do
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a arg_prefixes \
            <<< "${prefixes[${arg_id}]}"

        for prefix in "${arg_prefixes[@]}"; do
            if [[ "${prefix}" != "-" ]]; then
                continue
            elif [[ "${arg_id}" == "help" ]]; then
                is_help=true
            elif [[ "${arg_id}" == "usage" ]]; then
                is_usage=true
            elif [[ "${arg_id}" == "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
    fi

    # If the Argparser logo was requested, and the Argparser is parsing
    # its own command line, print the logo.
    if [[ "${argparser_logo}" == true && "${is_self_parsing}" == 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.  Thereby, set each argument's
    # value.
    messages=()
    argparser_parse_positional_args "${given_positional_args[@]}"

    # Sort, filter, colorize, and print all error messages, a blank
    # line, and the usage message, then abort the script.
    if (( "${#error_messages[@]}" > 0 )); then
        argparser_print_error_messages true false "${error_messages[@]}"

        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            printf '\n'
            argparser_print_usage_message false
        fi

        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    fi >&2

    # If a subcommand is given, set it to "true", while setting all
    # others always to "false".
    for subcommand in "${all_subcommands[@]}"; do
        if [[ -n "${subcommand}" ]]; then
            args[${subcommand}]=false
        fi
    done

    if [[ -n "${given_subcommand}" ]]; then
        args[${given_subcommand}]=true
    fi

    # Check the arguments' values.
    error_messages=()
    warning_messages=()
    for arg_id 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_id}]+set}" ]]; then
            prefix="${prefixes[${arg_id}]}"
        else
            prefix=""
        fi

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

        # Check the argument's values and assign the checked values to
        # it.
        argparser_check_arg_values "${arg_id}" "${prefix}" "${arg_values}"
        args[${arg_id}]="${arg_values}"
    done

    # Sort, filter, colorize, and print all error and warning messages.
    # If any argument was not or wrongly given (i.e., there were errors
    # and not just warnings), print also the usage message and abort the
    # script.
    if (( "${#error_messages[@]}" > 0 && "${#warning_messages[@]}" > 0 )); then
        argparser_print_error_messages true false "${error_messages[@]}"

        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            printf '\n'
        fi

        argparser_print_warning_messages true "${warning_messages[@]}"

        if [[ "${ARGPARSER_SILENCE_WARNINGS}" == false ]]; then
            printf '\n'
        fi

        if [[  "${ARGPARSER_SILENCE_ERRORS}" == false \
            || "${ARGPARSER_SILENCE_WARNINGS}" == false ]]
        then
            argparser_print_usage_message false
        fi

        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    elif (( "${#error_messages[@]}" > 0 )); then
        argparser_print_error_messages true false "${error_messages[@]}"

        if [[ "${ARGPARSER_SILENCE_ERRORS}" == false ]]; then
            printf '\n'
            argparser_print_usage_message false
        fi

        exit "${ARGPARSER_ERROR_EXIT_CODE}"
    elif (( "${#warning_messages[@]}" > 0 )); then
        argparser_print_warning_messages true "${warning_messages[@]}"
    fi >&2

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

    # Copy the values of the associative array ${args} to the variable
    # ${ARGPARSER_ARG_ARRAY_NAME} refers to.

    # shellcheck disable=SC2124  # False positive, output is string.
    declaration="${args[@]@A}"
    declaration="${declaration#declare -A }"
    declaration="${declaration/#"args"/"${ARGPARSER_ARG_ARRAY_NAME}"}"
    declare -g -A "${declaration}"
}

function argparser_set_args() {
    # Set the keyword and positional arguments to global variables.
    #
    # Globals:
    # - ${${ARGPARSER_ARG_ARRAY_NAME}[@]}: the parsed and checked
    #   arguments with identifier 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_id
    local declaration
    local -a values_arr

    # 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_id in "${!args[@]}"; do
        if [[ "${args[${arg_id}]}" == *"${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.

            # shellcheck disable=SC2229  # Indirect variable reference.
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a "${arg_id}" \
                <<< "${args[${arg_id}]}"

            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -d "" -r -a values_arr \
                <<< "${args[${arg_id}]}"
            values_arr[-1]="${values_arr[-1]%$'\n'}"  # '\n' from herestring.

            if [[ -z "${values_arr[-1]}" ]]; then
                unset 'values_arr[-1]'
            fi

            # shellcheck disable=SC2124  # False positive, output is string.
            declaration="${values_arr[@]@A}"
            declaration="${declaration#declare -a }"
            declaration="${declaration/#"values_arr"/"${arg_id}"}"
            declare -g -a "${declaration}"
        else
            # Set the argument as variable, while keeping it in ${args}
            # for potential usage by the calling script.
            declare -g "${arg_id}"="${args[${arg_id}]}"
        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 identifier 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_id
    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_id in "${!args[@]}"; do
        args_repr+=("${arg_id}=${args[${arg_id}]}")
    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_subcommands: the associative array holding the subcommands
    #   (read-only)
    # - all_value_names: the associative array holding the value names
    #   (read-only)
    # - given_subcommand: the active subcommand, if given, or the empty
    #   string, else
    # - 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_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_SUBCOMMAND_GROUP (read-only)
    # - ARGPARSER_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)

    # Define the local variables.
    local -a all_option_names
    local arg_group
    local -a arg_groups
    local arg_id
    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 display_names_arr
    local display_names_str
    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 is_hidden
    local -a joined_array
    local line
    local long_option
    local -a long_options
    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 optional_arguments_hint
    local pad_width
    local -a padded_array
    local -a positional_args
    local remark
    local script_name
    local short_option
    local -a short_options
    local -a sorted_array
    local -A sorted_col_1
    local -A sorted_col_2
    local -A sorted_col_3
    local subcommand
    local -a subcommand_names_arr
    local subcommand_names_str
    local -a subcommands
    local translation
    local type
    local -a uncolorized_array
    local usage
    local value_names

    # Sort the defined subcommands.
    subcommands=()
    for subcommand in "${all_subcommands[@]}"; do
        if [[ -n "${subcommand}" ]] \
            && ! argparser_in_array "${subcommand}" "${subcommands[@]}"
        then
            subcommands+=("${subcommand}")
        fi
    done

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

    # 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_SUBCOMMAND_GROUP}" \
            && "${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 subcommands.
    for subcommand in "${subcommands[@]}"; do
        # Read the subcommand's definition.
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${subcommand}]}"
        help_text="${all_help_texts[${subcommand}]}"

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

        # If a subcommand is given or the subcommand shall be hidden,
        # skip it.
        if [[ -n "${given_subcommand}" || "${is_hidden}" == true ]]; then
            continue
        fi

        # Get the (colorized) subcommand name and colorize the help
        # text.
        argparser_get_display_names "${subcommand}" "value" true
        subcommand_names_str="${display_names_str}"

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

        # Define the columns' next line, for the current subcommand.
        # Depending on whether there are short options, i.e., the first
        # column may or may not be used, put the subcommand into the
        # first or second column.
        if [[ "${ARGPARSER_USE_SHORT_OPTIONS}" == true ]]; then
            # Set the first column's value.
            new_col_1_value="${subcommand_names_str}"
            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.
            new_col_2_value="${subcommand_names_str}"
            col_2+=("${new_col_2_value}")
        fi

        # Set the third column's value.
        if [[ "${is_deprecated}" == true ]]; then
            # Deprecated.
            argparser_translate "Deprecated" "DEPRECATED"
            argparser_colorize "${styles["deprecation_note"]}" 1 note \
                "${translation}"
            new_col_3_value="(${note}) ${help_text}"
        else
            # Not 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 (( "${#subcommands[@]}" > 0 )) && [[ -z "${given_subcommand}" ]]; then
        col_1+=("")
        col_2+=("")
        col_3+=("")
    fi

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

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

        # If the argument belongs to a different subcommand than given
        # or shall be hidden, skip it.
        if [[ "${subcommand}" != "${given_subcommand}" \
            || "${is_hidden}" == true ]]
        then
            continue
        fi
        positional_args+=("${arg_id}")

        # 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

        # Get the colorized value names.  Concatenate and colorize the 
        # default values and choice values.  Then, colorize the help
        # text.
        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}"

        # 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, i.e., the first column may or may not
        # be used, put the argument into the first or second column.
        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}"
                    new_col_1_value+="={${choice_values_str}}...]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_1_value="${value_names}"
                    new_col_1_value+="={${choice_values_str}}..."
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_1_value="[${value_names}...]"
                else
                    # No choice nor default.
                    new_col_1_value="${value_names}..."
                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}"
                    new_col_1_value+="={${choice_values_str}}]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_1_value="${value_names}"
                    new_col_1_value+="={${choice_values_str}}"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_1_value="[${value_names}]"
                else
                    # No choice nor default.
                    new_col_1_value="${value_names}"
                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}"
                    new_col_2_value+="={${choice_values_str}}...]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value="${value_names}"
                    new_col_2_value+="={${choice_values_str}}..."
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value="[${value_names}...]"
                else
                    # No choice nor default.
                    new_col_2_value="${value_names}..."
                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}"
                    new_col_2_value+="={${choice_values_str}}]"
                elif [[ -n "${choice_values_str}" ]]; then
                    # Choice only.
                    new_col_2_value="${value_names}"
                    new_col_2_value+="={${choice_values_str}}"
                elif [[ -n "${default_values_str}" ]]; then
                    # Default only.
                    new_col_2_value="[${value_names}]"
                else
                    # No choice nor default.
                    new_col_2_value="${value_names}"
                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 (( "${#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_id in "${!all_short_options[@]}"; do
            # Read the argument's group to check whether it belongs to
            # the current group.
            if [[ "${all_arg_groups[${arg_id}]}" != "${arg_group}" ]]; then
                continue
            fi

            # Read the argument's remaining definition.
            subcommand="${all_subcommands[${arg_id}]}"
            default_values_str="${all_default_values[${arg_id}]}"
            if [[ "${arg_id}" == "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_id}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
                <<< "${choice_values_str}"
            type="${all_types[${arg_id}]}"
            arg_number="${all_arg_numbers[${arg_id}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
                <<< "${all_notes[${arg_id}]}"
            help_text="${all_help_texts[${arg_id}]}"

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

            # If the argument belongs to a different subcommand than
            # given, and is no help option, or if it shall be hidden,
            # skip it.
            if [[ "${subcommand}" != "${given_subcommand}" \
                && "${arg_group}" != "${ARGPARSER_HELP_ARG_GROUP}" ]]
            then
                continue
            elif [[ "${is_hidden}" == true ]]; then
                continue
            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
                if [[ "${default_values_str}" == true ]]; then
                    argparser_translate "true" "${default_values_str}"
                else
                    argparser_translate "false" "${default_values_str}"
                fi

                default_values_arr=("${translation}")
                default_values_str="${translation}"
            fi

            # Get the colorized short and long option names, and the
            # colorized value names.  Concatenate and colorize the
            # default values and choice values.  Then, colorize the help
            # text.
            argparser_get_display_names "${arg_id}" "short" true
            short_options=("${display_names_arr[@]}")

            argparser_get_display_names "${arg_id}" "long" true
            long_options=("${display_names_arr[@]}")

            argparser_get_display_names "${arg_id}" "value" true
            value_names="${display_names_str}"

            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

            # Concatenate the name of all short and long options for the
            # sorting of all arguments, later.
            argparser_get_display_names "${arg_id}" "long+short" false
            all_option_names+=("${display_names_str}")

            # 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 (( "${#short_options}" == 0 )); then
                # No short option.
                new_col_1_value=""
            elif (( "${#long_options}" == 0 )); 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[@]}"; 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[@]}"; 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[@]}"; 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[@]}"; 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[@]}"; do
                            new_col_1_value+="[${short_options[i]}"
                            new_col_1_value+="=${value_names}...], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options[@]}"; do
                            new_col_1_value+="${short_options[i]}"
                            new_col_1_value+="=${value_names}..., "
                        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[@]}"; 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[@]}"; 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[@]}"; do
                            new_col_1_value+="[${short_options[i]}"
                            new_col_1_value+="[=${value_names}...]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options[@]}"; do
                            new_col_1_value+="${short_options[i]}"
                            new_col_1_value+="[=${value_names}...], "
                        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[@]}"; 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[@]}"; 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[@]}"; do
                            new_col_1_value+="[${short_options[i]}"
                            new_col_1_value+="[=${value_names}]], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options[@]}"; do
                            new_col_1_value+="${short_options[i]}"
                            new_col_1_value+="[=${value_names}], "
                        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[@]}"; 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[@]}"; 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[@]}"; do
                            new_col_1_value+="[${short_options[i]}"
                            new_col_1_value+="=${value_names}], "
                        done
                        new_col_1_value="${new_col_1_value%, }"
                    else
                        # No choice nor default.
                        new_col_1_value=""
                        for i in "${!short_options[@]}"; do
                            new_col_1_value+="${short_options[i]}"
                            new_col_1_value+="=${value_names}, "
                        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[@]}"; 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[@]}"; 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 (( "${#long_options}" == 0 )); 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[@]}"; 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[@]}"; 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[@]}"; 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[@]}"; 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[@]}"; do
                        new_col_2_value+="[${long_options[i]}"
                        new_col_2_value+="=${value_names}...], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options[@]}"; do
                        new_col_2_value+="${long_options[i]}"
                        new_col_2_value+="=${value_names}..., "
                    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[@]}"; 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[@]}"; 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[@]}"; do
                        new_col_2_value+="[${long_options[i]}"
                        new_col_2_value+="[=${value_names}...]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options[@]}"; do
                        new_col_2_value+="${long_options[i]}"
                        new_col_2_value+="[=${value_names}...], "
                    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[@]}"; 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[@]}"; 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[@]}"; do
                        new_col_2_value+="[${long_options[i]}"
                        new_col_2_value+="[=${value_names}]], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options[@]}"; do
                        new_col_2_value+="${long_options[i]}"
                        new_col_2_value+="[=${value_names}], "
                    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[@]}"; 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[@]}"; 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[@]}"; do
                        new_col_2_value+="[${long_options[i]}"
                        new_col_2_value+="=${value_names}], "
                    done
                    new_col_2_value="${new_col_2_value%, }"
                else
                    # No choice nor default.
                    new_col_2_value=""
                    for i in "${!long_options[@]}"; do
                        new_col_2_value+="${long_options[i]}"
                        new_col_2_value+="=${value_names}, "
                    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 subcommands, and none is given, include the
    # subcommand argument group as first one.  If there are positional
    # arguments defined for the given subcommand (or the general program
    # if no subcommand is given), include the positional argument group
    # as next one (by possibly setting the subcommand argument group
    # before the positional argument group).  Then, add the help
    # options' group, if existing, as last one.
    if (( "${#positional_args[@]}" > 0 )); then
        arg_groups=(
            "${ARGPARSER_POSITIONAL_ARG_GROUP}"
            "${arg_groups[@]}"
        )
    fi

    if (( "${#subcommands[@]}" > 0 )) && [[ -z "${given_subcommand}" ]]; then
        arg_groups=(
            "${ARGPARSER_SUBCOMMAND_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" 1 "${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" 1 "${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, the script
    # name, and either the given subcommand, if any, or all subcommands.
    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}"

    if (( "${#subcommands[@]}" > 0 )); then
        if [[ -n "${given_subcommand}" ]]; then
            argparser_get_display_names "${given_subcommand}" "value" true
            subcommand_names_str="${display_names_str}"
            usage+=" ${subcommand_names_str}"
        else
            subcommand_names_arr=()
            for subcommand in "${subcommands[@]}"; do
                argparser_get_display_names "${subcommand}" "value" true
                subcommand_names_arr+=("${display_names_arr[@]}")
            done

            argparser_join " | " "${subcommand_names_arr[@]}"
            usage+=" [${joined_array}]"
        fi
    fi

    # 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 positional argument delimiter and the names of the
    # positional arguments for the given subcommand (if any), if
    # existing.
    if (( "${#positional_args[@]}" > 0 )); then
        if [[ "${has_required_args}" == true ]]; then
            usage+=" --"
        elif [[ "${has_default_args}" == true ]]; then
            usage+=" [--]"
        fi
    fi

    for arg_id in "${positional_args[@]}"; do
        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

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

    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.  Skip the entire argument group if it is
        # empty (i.e., if all its options are hidden).
        if (( "${#help_message[@]}" > 0 )); then
            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'
        else
            help_message_blocks[${arg_group}]=""
        fi
    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_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_subcommands: the associative array holding the subcommands
    #   (read-only)
    # - all_value_names: the associative array holding the value names
    #   (read-only)
    # - given_subcommand: the active subcommand, if given, or the empty
    #   string, else
    # - 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_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_HELP_ARG_GROUP (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_USE_LONG_OPTIONS (read-only)
    # - ARGPARSER_USE_SHORT_OPTIONS (read-only)

    # Define the local variables.
    local arg_id
    local arg_number
    local caption
    local -a choice_values_arr
    local choice_values_str
    local -a colorized_array
    local default_values
    local -a display_names_arr
    local display_names_str
    local -a framed_array
    local header
    local -a help_option_args
    local -a help_options
    local joined_array
    local length
    local -a lines
    local long_option
    local -a long_option_default_args
    local -a long_option_required_args
    local long_options
    local -a notes
    local -a positional_default_args
    local -a positional_required_args
    local -a padded_array
    local script_name
    local short_option
    local -a short_option_default_args
    local -a short_option_required_args
    local short_options
    local -a sorted_array
    local subcommand
    local -a subcommand_names_arr
    local subcommand_names_str
    local -a subcommands
    local translation
    local -a usage_message
    local uncolorized_line
    local value_names
    local whitespace

    # Get the defined subcommands.
    subcommands=()
    for subcommand in "${all_subcommands[@]}"; do
        if [[ -n "${subcommand}" ]] \
            && ! argparser_in_array "${subcommand}" "${subcommands[@]}"
        then
            subcommands+=("${subcommand}")
        fi
    done

    # If there are subcommands defined, but none is given, add the
    # colorized subcommands to the usage message, forming a separate
    # line.  If a subcommand is given, it will be added later (between
    # the script name and the help options).
    usage_message=()

    if (( "${#subcommands[@]}" > 0 )) && [[ -z "${given_subcommand}" ]]; then
        subcommand_names_arr=()
        for subcommand in "${subcommands[@]}"; do
            argparser_get_display_names "${subcommand}" "value" true
            subcommand_names_arr+=("${display_names_arr[@]}")
        done

        argparser_join " | " "${subcommand_names_arr[@]}"
        usage_message+=("[${joined_array}]")
    fi

    # 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_id in "${!all_short_options[@]}"; do
        if [[ "${all_arg_groups[${arg_id}]}" == "${ARGPARSER_HELP_ARG_GROUP}" ]]
        then
            help_option_args+=("${arg_id}")
        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 and
    # colorize them, then add the help options to the usage message.
    help_options=()
    for arg_id in "${help_option_args[@]}"; do
        if [[ ("${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "short" \
                && "${ARGPARSER_USE_SHORT_OPTIONS}" == true) \
            || "${ARGPARSER_USE_LONG_OPTIONS}" == false ]]
        then
            argparser_get_display_names "${arg_id}" "short" true
            help_options+=("${display_names_str}")
        elif [[ ("${ARGPARSER_USAGE_MESSAGE_OPTION_TYPE}" == "long" \
                && "${ARGPARSER_USE_LONG_OPTIONS}" == true) \
            || "${ARGPARSER_USE_SHORT_OPTIONS}" == false ]]
        then
            argparser_get_display_names "${arg_id}" "long" true
            help_options+=("${display_names_str}")
        fi
    done

    if (( "${#help_options[@]}" > 0 )); then
        argparser_join " | " "${help_options[@]}"
        usage_message+=("[${joined_array}]")
    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_id in "${!all_short_options[@]}"; do
            # Skip the help options.
            if [[ "${all_arg_groups[${arg_id}]}" \
                == "${ARGPARSER_HELP_ARG_GROUP}" ]]
            then
                continue
            fi

            # Read the argument's definition.
            subcommand="${all_subcommands[${arg_id}]}"
            short_options="${all_short_options[${arg_id}]}"
            default_values="${all_default_values[${arg_id}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
                <<< "${all_notes[${arg_id}]}"

            # If the argument belongs to a different subcommand than
            # given or shall be hidden, skip it.
            if [[ "${subcommand}" != "${given_subcommand}" ]] \
                || argparser_in_array "hidden" "${notes[@]}"
            then
                continue
            fi

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

            # Read the argument's definition.
            subcommand="${all_subcommands[${arg_id}]}"
            long_options="${all_long_options[${arg_id}]}"
            default_values="${all_default_values[${arg_id}]}"
            IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
                <<< "${all_notes[${arg_id}]}"

            # If the argument belongs to a different subcommand than
            # given or shall be hidden, skip it.
            if [[ "${subcommand}" != "${given_subcommand}" ]] \
                || argparser_in_array "hidden" "${notes[@]}"
            then
                continue
            fi

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

    # Likewise, separate positional arguments with default values from
    # those without.
    positional_default_args=()
    positional_required_args=()
    for arg_id in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        subcommand="${all_subcommands[${arg_id}]}"
        default_values="${all_default_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a notes \
            <<< "${all_notes[${arg_id}]}"

        # If the argument belongs to a different subcommand than given
        # or shall be hidden, skip it.
        if [[ "${subcommand}" != "${given_subcommand}" ]] \
            || argparser_in_array "hidden" "${notes[@]}"
        then
            continue
        fi

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

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

        # Concatenate and colorize the short option names, value names,
        # and choice values.
        argparser_get_display_names "${arg_id}" "short" true
        short_options="${display_names_str}"

        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}]")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options}={${choice_values_str}}...]")
            else
                # Default only.
                lines+=("[${short_options}=${value_names}...]")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options}[={${choice_values_str}}...]]")
            else
                # Default only.
                lines+=("[${short_options}[=${value_names}...]]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options}[={${choice_values_str}}]]")
            else
                # Default only.
                lines+=("[${short_options}[=${value_names}]]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${short_options}={${choice_values_str}}]")
            else
                # Default only.
                lines+=("[${short_options}=${value_names}]")
            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_id in "${long_option_default_args[@]}"; do
        # Read the argument's definition.
        choice_values_str="${all_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_id}]}"

        # Concatenate and colorize the long option names, value names,
        # and choice values.
        argparser_get_display_names "${arg_id}" "long" true
        long_options="${display_names_str}"

        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}]")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options}={${choice_values_str}}...]")
            else
                # Default only.
                lines+=("[${long_options}=${value_names}...]")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options}[={${choice_values_str}}...]]")
            else
                # Default only.
                lines+=("[${long_options}[=${value_names}...]]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options}[={${choice_values_str}}]]")
            else
                # Default only.
                lines+=("[${long_options}[=${value_names}]]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice and default.
                lines+=("[${long_options}={${choice_values_str}}]")
            else
                # Default only.
                lines+=("[${long_options}=${value_names}]")
            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_id in "${short_option_required_args[@]}"; do
        # Read the argument's definition.
        choice_values_str="${all_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_id}]}"

        # Concatenate and colorize the short option names, value names,
        # and choice values.
        argparser_get_display_names "${arg_id}" "short" true
        short_options="${display_names_str}"

        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options}={${choice_values_str}}...")
            else
                # No choice nor default.
                lines+=("${short_options}=${value_names}...")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options}[={${choice_values_str}}...]")
            else
                # No choice nor default.
                lines+=("${short_options}[=${value_names}...]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options}[={${choice_values_str}}]")
            else
                # No choice nor default.
                lines+=("${short_options}[=${value_names}]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${short_options}={${choice_values_str}}")
            else
                # No choice nor default.
                lines+=("${short_options}=${value_names}")
            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_id in "${long_option_required_args[@]}"; do
        # Read the argument's definition.
        choice_values_str="${all_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_id}]}"

        # Concatenate and colorize the long option names, value names,
        # and choice values.
        argparser_get_display_names "${arg_id}" "long" true
        long_options="${display_names_str}"

        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}")
        elif [[ "${arg_number}" == "+" ]]; then
            # [1, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options}={${choice_values_str}}...")
            else
                # No choice nor default.
                lines+=("${long_options}=${value_names}...")
            fi
        elif [[ "${arg_number}" == "*" ]]; then
            # [0, inf) values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options}[={${choice_values_str}}...]")
            else
                # No choice nor default.
                lines+=("${long_options}[=${value_names}...]")
            fi
        elif [[ "${arg_number}" == "?" ]]; then
            # [0, 1] values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options}[={${choice_values_str}}]")
            else
                # No choice nor default.
                lines+=("${long_options}[=${value_names}]")
            fi
        else
            # Integer-count values.
            if [[ -n "${choice_values_str}" ]]; then
                # Choice only.
                lines+=("${long_options}={${choice_values_str}}")
            else
                # No choice nor default.
                lines+=("${long_options}=${value_names}")
            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_id in "${positional_default_args[@]}"; do
        # Read the argument's definition.
        choice_values_str="${all_choice_values[${arg_id}]}"
        IFS="${ARGPARSER_ARG_DELIMITER_2}" read -r -a choice_values_arr \
            <<< "${choice_values_str}"
        arg_number="${all_arg_numbers[${arg_id}]}"

        # Concatenate and colorize the value names and choice values.
        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}...]")
            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}]")
            fi
        fi
    done

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

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

        # Concatenate and colorize the value names and choice values.
        argparser_get_display_names "${arg_id}" "value" true
        value_names="${display_names_str}"

        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}...")
            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}")
            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 (translated) caption (if no usage frame is given),
    # the header with the script name, and the given subcommand's name.
    # 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
        if [[ -n "${given_subcommand}" ]]; then
            header="${ARGPARSER_SCRIPT_NAME} ${given_subcommand} "
        else
            header="${ARGPARSER_SCRIPT_NAME} "
        fi
    else
        if [[ -n "${given_subcommand}" ]]; then
            header="${caption}: ${ARGPARSER_SCRIPT_NAME} ${given_subcommand} "
        else
            header="${caption}: ${ARGPARSER_SCRIPT_NAME} "
        fi
    fi

    length=0
    for line in "${usage_message[@]}"; do
        argparser_uncolorize uncolorized_line 1 "${line}"
        (( length += "${#uncolorized_line}" ))
    done

    if (( "${length}" + "${#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
        argparser_join " " "${usage_message[@]}"
        usage_message=("${joined_array}")
    fi

    # Colorize the caption, the script name, and the given subcommand's
    # name, (if any).  If a usage frame style is given, prepend the
    # script and given subcommand's names 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 and subcommand names, heading,
    # and the first option line in one line.  Finally, join the lines
    # into a single string.
    if [[ -n "${styles["usage_frame"]}" ]]; then
        argparser_colorize "${styles["usage_caption"]}" 1 caption \
            " ${caption} "
    else
        argparser_colorize "${styles["usage_caption"]}" 1 caption "${caption}:"
    fi

    argparser_colorize "${styles["script_name"]}" 1 script_name \
        "${ARGPARSER_SCRIPT_NAME}"

    if [[ -n "${given_subcommand}" ]]; then
        argparser_get_display_names "${given_subcommand}" "value" true
        subcommand_names_str="${display_names_str}"
    fi

    if [[ -n "${styles["usage_frame"]}" ]]; then
        if [[ -n "${given_subcommand}" ]]; then
            usage_message[0]="${script_name} ${subcommand_names_str} ${usage_message[0]}"
        else
            usage_message[0]="${script_name} ${usage_message[0]}"
        fi

        argparser_pad "right" "auto" "${usage_message[@]}"
        argparser_draw_frame "${styles["usage_frame"]}" 1 "array" \
            "${caption}" "${padded_array[@]}"
        usage_message=("${framed_array[@]}")
    else
        if [[ -n "${given_subcommand}" ]]; then
            usage_message[0]="${caption} ${script_name} ${subcommand_names_str} ${usage_message[0]}"
        else
            usage_message[0]="${caption} ${script_name} ${usage_message[0]}"
        fi
    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 positional_args
    local -a resolved_lines
    local skip_blank_line
    local -a sorted_array
    local -a subcommands
    local translation
    local uncolorized_caption

    # Read the argument.
    exit="$1"

    # Get the defined subcommands.
    subcommands=()
    for subcommand in "${all_subcommands[@]}"; do
        if [[ -n "${subcommand}" ]] \
            && ! argparser_in_array "${subcommand}" "${subcommands[@]}"
        then
            subcommands+=("${subcommand}")
        fi
    done

    # Get the positional arguments for the given subcommand, if any, or
    # the general program.
    positional_args=()
    for arg_id in "${all_positional_args[@]}"; do
        # Read the argument's definition.
        subcommand="${all_subcommands[${arg_id}]}"

        # If the argument belongs to a different subcommand than given
        # or shall be hidden, skip it.
        if [[ "${subcommand}" == "${given_subcommand}" ]]; then
            positional_args+=("${arg_id}")
        fi
    done

    # 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_SUBCOMMAND_GROUP}" \
            && "${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.
    argparser_sort false "${arg_groups[@]}"
    arg_groups=("${sorted_array[@]}")

    # If there are subcommands, and none is given, include the
    # subcommand argument group as first one.  If there are positional
    # arguments defined for the given subcommand (or the general program
    # if no subcommand is given), include the positional argument group
    # as next one (by possibly setting the subcommand argument group
    # before the positional argument group).  Then, add the help
    # options' group, if existing, as last one.
    if (( "${#positional_args[@]}" > 0 )); then
        arg_groups=(
            "${ARGPARSER_POSITIONAL_ARG_GROUP}"
            "${arg_groups[@]}"
        )
    fi

    if (( "${#subcommands[@]}" > 0 )) && [[ -z "${given_subcommand}" ]]; then
        arg_groups=(
            "${ARGPARSER_SUBCOMMAND_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.
            for i in "${!arg_groups[@]}"; do
                if (( i < "${#arg_groups[@]}" - 1 )); then
                    resolved_lines+=(
                        "${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 1 "${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

                if [[ -n "${block}" ]]; then
                    help_message+="${block}"
                else
                    skip_blank_line=true
                fi
            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_ARG_DELIMITER_2 (read-only)
    # - ARGPARSER_ERROR_EXIT_CODE (read-only)
    # - ARGPARSER_MAX_WIDTH (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_ARG_DELIMITER_2 (read-only)
    # - 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_SUBCOMMAND_GROUP
    # - 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_COLORS
    # - 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_subcommands
    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}
    # and ${argparser_logo} must be set in global scope, later, they
    # cannot be declared local, here.
    declare -g -A ARGPARSER_ARGS
    declare -g argparser_logo
    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.  If ${ARGPARSER_USE_UNICODE} is set to
    # "true", use Unicode characters for the frame styles, else, use
    # ASCII characters.
    styles=(
        ["argument_group"]="cyan,bold,reverse"
        ["choice_values"]="yellow"
        ["default_text"]="italic"
        ["default_values"]="cyan,italic"
        ["deprecation_note"]="red,bold"
        ["description_text"]="italic"
        ["error_caption"]="red,bold,reverse"
        ["error_text"]="red"
        ["help_caption"]="green,bold"
        ["help_text"]="normal"
        ["long_options"]="magenta,bold"
        ["remark_text"]="italic"
        ["script_name"]="bold"
        ["short_options"]="green,bold"
        ["subcommand"]="blue,bold"
        ["usage_caption"]="green,bold,reverse"
        ["value_names"]="blue"
        ["version_caption"]="magenta,bold,reverse"
        ["version_text"]="normal"
        ["warning_caption"]="yellow,bold,reverse"
        ["warning_text"]="yellow"
    )

    if [[ "${ARGPARSER_USE_UNICODE}" == true ]]; then
        styles["error_frame"]="red,rounded"
        styles["help_frame"]="cyan,rounded"
        styles["usage_frame"]="green,rounded"
        styles["version_frame"]="magenta,rounded"
        styles["warning_frame"]="yellow,rounded"
    else
        styles["error_frame"]="red,ASCII"
        styles["help_frame"]="cyan,ASCII"
        styles["usage_frame"]="green,ASCII"
        styles["version_frame"]="magenta,ASCII"
        styles["warning_frame"]="yellow,ASCII"
    fi

    # If ${ARGPARSER_USE_COLORS} isn't given, check for ${FORCE_COLOR}
    # and ${NO_COLOR}.  If ${FORCE_COLOR} is given and not set to the
    # empty string, forcefully enable the colors.  If ${NO_COLOR} is
    # given and not set to the empty string, forcefully disable the
    # colors.  ${NO_COLOR} overrides ${FORCE_COLOR}.
    if [[ ! -v ARGPARSER_USE_COLORS ]]; then
        if [[ -v FORCE_COLOR && -n "${FORCE_COLOR}" ]]; then
            ARGPARSER_USE_COLORS=true
        fi
        if [[ -v NO_COLOR && -n "${NO_COLOR}" ]]; then
            ARGPARSER_USE_COLORS=false
        fi
    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_define_env_vars
    argparser_set_env_vars "$@"
    argparser_modify_env_vars "$@"
    set -- "${script_args[@]}"
    is_self_parsing=false

    all_arg_groups=()
    all_arg_numbers=()
    all_choice_values=()
    all_default_values=()
    all_help_texts=()
    all_long_options=()
    all_notes=()
    all_positional_args=()
    all_resolved_choice_values=()
    all_short_options=()
    all_subcommands=()
    all_types=()
    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_SUBCOMMAND_GROUP},
    # ${ARGPARSER_POSITIONAL_ARG_GROUP}, and ${ARGPARSER_HELP_ARG_GROUP}
    # in the arguments definition and help message, translate them
    # in-place.
    if [[ -n "${ARGPARSER_TRANSLATION_FILE}" ]]; then
        argparser_read_translation

        argparser_translate "Help description" "${ARGPARSER_HELP_DESCRIPTION}"
        ARGPARSER_HELP_DESCRIPTION="${translation}"

        argparser_translate "Subcommands" "${ARGPARSER_SUBCOMMAND_GROUP}"
        ARGPARSER_SUBCOMMAND_GROUP="${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}"
    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_USE_UNICODE} is now set to "true", enable the
    # Unicode characters for the frame styles.
    if [[ "${ARGPARSER_USE_UNICODE}" == true ]]; then
        styles["error_frame"]="red,rounded"
        styles["help_frame"]="cyan,rounded"
        styles["usage_frame"]="green,rounded"
        styles["version_frame"]="magenta,rounded"
        styles["warning_frame"]="yellow,rounded"
    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

    # Set up the arguments definition, reading, parsing, and verifying
    # it.
    argparser_get_args_definition

    # 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

    # Clean up the Argparser functions and environment variables.
    argparser_cleanup

    # Possibly disable extglob, if it was previously unset.
    if (( is_extglob_set == 1 )); then
        shopt -u extglob
    fi
}

# Run the Argparser.
argparser_main "$@"