A complementary set of scripts, align_text_right.py and align_text_right_1.py, use this new option. Here’s the complete set of scripts.

align_text.py:

#------------------------------------------------------------------------
# If the character specified in the current selection is a white space,
# then prompt the user to enter the alignment character (or characters),
# using this character as the initial default.
#------------------------------------------------------------------------
default_align_char = ','

from enum import Enum
class PaddingSide(Enum):
    LEFT = 0
    RIGHT = 1


def align_selected_text(max_align_char_count = None,
                        padding_side = PaddingSide.LEFT):
    """Insert padding into the lines in the selection, as needed, to align up to max_align_char_count instances of a specific character or string of characters

    The default is to align all instances of the specific character.

    At present, the alignment character is taken as the character at the top of
    the current selection. You can uncomment some code below to change this
    policy to instead take the alignment character from within the selection at
    whichever end has the cursor. Either way, if that character is white space,
    the user is prompted to type the character (or characters). If you really
    wish to align on a white space character, you can just click OK at the
    prompt.

    When prompted to type the alignment character, the user may enter a
    sequence of characters, e.g., "-->", in which case the alignment is on the
    instances of that entire character sequence. For example, if the user
    enters "-->" at the prompt, then instances of the "-" character get
    aligned only if they're followed immediately by the characters "->", while
    instances of, say, "-1" and "- " remain unaltered.

    If there is no current selection, then aligns all lines in the editor.
    If there is a current selection, then aligns only the lines that are
    at least partially included in the selection, and the selection is
    changed to the entire block of newly-padded lines.

    Parameters
    ----------
      max_align_char_count : positive integer, optional
          The maximum number of instances to align of the specific
          character.  For example, set to 1 to align only the first
          instance of the character on each line. The default is to
          align all instances of the specific character.
      padding_side : instance of PaddingSide, optional
          Indicates which side of the character gets the padding. The 
          default is PaddingSide.LEFT, so the character itself gets aligned.
          Set to PaddingSide.RIGHT to preserve the character's position and
          instead align the non-space text to the right of the character.
    """
    from Npp import editor

    #----------------------------------------------------------------------------
    # For the alignment character, take the character just inside the bounds of
    # the selection block (at either the start or the end, as determined below).
    #----------------------------------------------------------------------------
    editor.targetFromSelection()
    selected_text = editor.getTargetText()

    #----------------------------------------------------------------------------
    # Use this code to get the align_char unconditionally from the start
    # of the selection.  If there is no selection, use the character at the
    # current cursor position; if that is unavailable, fall through to the
    # prompt below by treating the alignment character as whitespace.
    #----------------------------------------------------------------------------
    if selected_text:
        align_char = selected_text[0]
    else:
        current_pos = editor.getCurrentPos()
        align_char = editor.getTextRangeFull(current_pos, current_pos + 1)
        if not align_char:
            align_char = ' '

    #----------------------------------------------------------------------------
    # Optionally use this code to get the align_char from within the selection
    # at whichever end has the cursor.
    #----------------------------------------------------------------------------
    # if selected_text:
    #     (startByte, endByte) = editor.getUserCharSelection()
    #     if startByte == editor.getCurrentPos():
    #         align_char = selected_text[0]
    #     else:
    #         align_char = selected_text[-1]
    # else:
    #     current_pos = editor.getCurrentPos()
    #     align_char = editor.getTextRangeFull(current_pos, current_pos + 1)
    #     if not align_char:
    #         align_char = ' '

    # If the character from the selection seems implausible as the
    # align_char, then prompt the user for it.
    if align_char.isspace():
        from Npp import notepad
        global default_align_char
        align_char = notepad.prompt('Align character:',
                                    'Enter Alignment Character',
                                    default_align_char)
        if align_char is not None:
            default_align_char = align_char

    #----------------------------------------------------------------------------
    #%% Get the lines of text within the selected alignment block
    #----------------------------------------------------------------------------
    (startLine, endLine) = editor.getUserLineSelection()
    startPos = editor.positionFromLine(startLine)
    endPos = editor.getLineEndPosition(endLine)
    text_lines = editor.getTextRangeFull(startPos, endPos).splitlines(True)

    #----------------------------------------------------------------------------
    # Remember whether there is a user-selected block, so we can restore a
    # corresponding selection after aligning the text.
    #----------------------------------------------------------------------------
    restore_selection = editor.getSelectionStart() != editor.getSelectionEnd()

    #----------------------------------------------------------------------------
    # Align all instances of align_char within the lines of text
    #----------------------------------------------------------------------------
    if align_char is not None:
        # Enable the following to save the align_char, however it was determined,
        # to be the default_align_char when prompting for it next time.
        # default_align_char = align_char

        if max_align_char_count is None:
            align_char_count = max(line.count(align_char) for line in text_lines)
        else:
            align_char_count = max_align_char_count

        start = 0
        for instance in range(align_char_count):
            # Set the target column using the index of the align_char, ignoring
            # immediately preceding space, or the length of the line
            align_char_cols = [line.find(align_char, start) for line in text_lines]

            # Only lines that contain this instance participate in this pass.
            # A failed find() returns -1, and using that as a slice index would
            # make lines without this instance incorrectly affect the target.
            lines_with_instance = [(line, col)
                                   for (line, col) in zip(text_lines, align_char_cols)
                                   if col >= 0]
            if not lines_with_instance:
                break

            if padding_side == PaddingSide.LEFT:
                # Align the alignment character itself, removing any spaces
                # immediately to its left before inserting the required padding.
                target_col = max(len(line[:col].rstrip())
                                 for (line, col) in lines_with_instance)

                for (idx, line) in enumerate(text_lines):
                    align_char_col = align_char_cols[idx]
                    if align_char_col >= 0:
                        text_lines[idx] = line[:align_char_col].rstrip().ljust(target_col) \
                                        + line[align_char_col:]

                start = target_col + len(align_char)

            elif padding_side == PaddingSide.RIGHT:
                # Align the non-space text after the alignment character.
                # Preserve the alignment character itself, but
                # replace any existing spaces after it with the required
                # padding.
                suffix_starts = []
                for (line, col) in lines_with_instance:
                    suffix_start = col + len(align_char)
                    while suffix_start < len(line) and line[suffix_start] == ' ':
                        suffix_start += 1
                    suffix_starts.append(suffix_start)

                target_col = max(suffix_starts)

                for (idx, line) in enumerate(text_lines):
                    align_char_col = align_char_cols[idx]
                    if align_char_col >= 0:
                        suffix_start = align_char_col + len(align_char)
                        while suffix_start < len(line) and line[suffix_start] == ' ':
                            suffix_start += 1
                        text_lines[idx] = line[:align_char_col + len(align_char)].ljust(target_col) \
                                        + line[suffix_start:]

                start = target_col

            else:
                raise ValueError('Unsupported padding_side: {}'.format(padding_side))

        editor.setTarget(startPos, endPos)
        editor.replaceTarget(''.join(text_lines))

        if restore_selection:
            startPos = editor.positionFromLine(startLine)
            endPos = editor.getLineEndPosition(endLine)
            editor.setSelectionStart(startPos)
            editor.setSelectionEnd(endPos)


if __name__ == '__main__':
    align_selected_text()

align_text_1.py:

from align_text import align_selected_text

align_selected_text(max_align_char_count = 1)

align_text_right.py:

from align_text import align_selected_text, PaddingSide

align_selected_text(padding_side = PaddingSide.RIGHT)

align_text_right_1.py:

from align_text import align_selected_text, PaddingSide

align_selected_text(max_align_char_count = 1,
                    padding_side = PaddingSide.RIGHT)

#------------------------------------------------------------------------
# If the character specified in the current selection is a white space,
# then prompt the user to enter the alignment character (or characters),
# using this character as the initial default.
#------------------------------------------------------------------------
default_align_char = ','

from enum import Enum
class PaddingSide(Enum):
    LEFT = 0
    RIGHT = 1


def align_selected_text(max_align_char_count = None,
                        padding_side = PaddingSide.LEFT):
    """Insert padding into the lines in the selection, as needed, to align up to max_align_char_count instances of a specific character or string of characters

    The default is to align all instances of the specific character.

    At present, the alignment character is taken as the character at the top of
    the current selection. You can uncomment some code below to change this
    policy to instead take the alignment character from within the selection at
    whichever end has the cursor. Either way, if that character is white space,
    the user is prompted to type the character (or characters). If you really
    wish to align on a white space character, you can just click OK at the
    prompt.

    When prompted to type the alignment character, the user may enter a
    sequence of characters, e.g., "-->", in which case the alignment is on the
    instances of that entire character sequence. For example, if the user
    enters "-->" at the prompt, then instances of the "-" character get
    aligned only if they're followed immediately by the characters "->", while
    instances of, say, "-1" and "- " remain unaltered.

    If there is no current selection, then aligns all lines in the editor.
    If there is a current selection, then aligns only the lines that are
    at least partially included in the selection, and the selection is
    changed to the entire block of newly-padded lines.

    Parameters
    ----------
      max_align_char_count : positive integer, optional
          The maximum number of instances to align of the specific
          character.  For example, set to 1 to align only the first
          instance of the character on each line. The default is to
          align all instances of the specific character.
    """
    from Npp import editor

    #----------------------------------------------------------------------------
    # For the alignment character, take the character just inside the bounds of
    # the selection block (at either the start or the end, as determined below).
    #----------------------------------------------------------------------------
    editor.targetFromSelection()
    selected_text = editor.getTargetText()

    # Use this code to get the align_char unconditionally from the start
    # of the selection.
    align_char = selected_text[0]

    # Optionally use this code to get the align_char from within the selection
    # at whichever end has the cursor.
    # (startByte, endByte) = editor.getUserCharSelection()
    # if startByte == editor.getCurrentPos():
    #     align_char = selected_text[0]
    # else:
    #     align_char = selected_text[-1]

    # If the character from the selection seems implausible as the
    # align_char, then prompt the user for it.
    if align_char.isspace():
        from Npp import notepad
        global default_align_char
        align_char = notepad.prompt('Align character:',
                                    'Enter Alignment Character',
                                    default_align_char)
        if align_char is not None:
            default_align_char = align_char

    #----------------------------------------------------------------------------
    #%% Get the lines of text within the selected alignment block
    #----------------------------------------------------------------------------
    (startLine, endLine) = editor.getUserLineSelection()
    startPos = editor.positionFromLine(startLine)
    endPos = editor.getLineEndPosition(endLine)
    text_lines = editor.getTextRangeFull(startPos, endPos).splitlines(True)

    #----------------------------------------------------------------------------
    # Remember whether there is a user-selected block, so we can restore a
    # corresponding selection after aligning the text.
    #----------------------------------------------------------------------------
    restore_selection = editor.getSelectionStart() != editor.getSelectionEnd()

    #----------------------------------------------------------------------------
    # Align all instances of align_char within the lines of text
    #----------------------------------------------------------------------------
    if align_char is not None:
        # Enable the following to save the align_char, however it was determined,
        # to be the default_align_char when prompting for it next time.
        # default_align_char = align_char

        padding_side_offset = padding_side.value * len(align_char)

        if max_align_char_count is None:
            align_char_count = max(line.count(align_char) for line in text_lines)
        else:
            align_char_count = max_align_char_count
        start = 0
        for instance in range(align_char_count):
            # Set the target column using the index of the align_char, ignoring
            # immediately preceding space, or the length of the line
            tgt_char_col = max(len(line[:line.find(align_char, start)].rstrip())
                               for line in text_lines)

            for (idx,line) in enumerate(text_lines):
                align_char_col = line.find(align_char, start)
                if align_char_col >= 0:
                    text_lines[idx] = line[:align_char_col+padding_side_offset].rstrip().ljust(tgt_char_col) \
                                    + line[align_char_col+padding_side_offset:]
            start = tgt_char_col + len(align_char)

        editor.setTarget(startPos, endPos)
        editor.replaceTarget(''.join(text_lines))

        if restore_selection:
            startPos = editor.positionFromLine(startLine)
            endPos = editor.getLineEndPosition(endLine)
            editor.setSelectionStart(startPos)
            editor.setSelectionEnd(endPos)


if __name__ == '__main__':
    align_selected_text()

align_text.py:

#------------------------------------------------------------------------
# If the character specified in the current selection is a white space,
# then prompt the user to enter the alignment character (or characters),
# using this character as the initial default.
#------------------------------------------------------------------------
default_align_char = ','

def align_selected_text(max_align_char_count = None):
    """Insert padding into the lines in the selection, as needed, to align up to max_align_char_count instances of a specific character or string of characters

    The default is to align all instances of the specific character.

    At present, the alignment character is taken as the character at the top of
    the current selection. You can uncomment some code below to change this
    policy to instead take the alignment character from within the selection at
    whichever end has the cursor. Either way, if that character is white space,
    the user is prompted to type the character (or characters). If you really
    wish to align on a white space character, you can just click OK at the
    prompt.

    When prompted to type the alignment character, the user may enter a
    sequence of characters, e.g., "-->", in which case the alignment is on the
    instances of that entire character sequence. For example, if the user
    enters "-->" at the prompt, then instances of the "-" character get
    aligned only if they're followed immediately by the characters "->", while
    instances of, say, "-1" and "- " remain unaltered.

    If there is no current selection, then aligns all lines in the editor.
    If there is a current selection, then aligns only the lines that are
    at least partially included in the selection, and the selection is
    changed to the entire block of newly-padded lines.

    Parameters
    ----------
      max_align_char_count : positive integer, optional
          The maximum number of instances to align of the specific
          character.  For example, set to 1 to align only the first
          instance of the character on each line. The default is to
          align all instances of the specific character.
    """
    from Npp import editor

    #----------------------------------------------------------------------------
    # For the alignment character, take the character just inside the bounds of
    # the selection block (at either the start or the end, as determined below).
    #----------------------------------------------------------------------------
    editor.targetFromSelection()
    selected_text = editor.getTargetText()

    # Use this code to get the align_char unconditionally from the start
    # of the selection.
    align_char = selected_text[0]

    # Optionally use this code to get the align_char from within the selection
    # at whichever end has the cursor.
    # (startByte, endByte) = editor.getUserCharSelection()
    # if startByte == editor.getCurrentPos():
    #     align_char = selected_text[0]
    # else:
    #     align_char = selected_text[-1]

    # If the character from the selection seems implausible as the
    # align_char, then prompt the user for it.
    if align_char.isspace():
        from Npp import notepad
        global default_align_char
        align_char = notepad.prompt('Align character:',
                                    'Enter Alignment Character',
                                    default_align_char)
        if align_char is not None:
            default_align_char = align_char

    #----------------------------------------------------------------------------
    #%% Get the lines of text within the selected alignment block
    #----------------------------------------------------------------------------
    (startLine, endLine) = editor.getUserLineSelection()
    startPos = editor.positionFromLine(startLine)
    endPos = editor.getLineEndPosition(endLine)
    text_lines = editor.getTextRange(startPos, endPos).splitlines(True)

    #----------------------------------------------------------------------------
    # Remember whether there is a user-selected block, so we can restore a
    # corresponding selection after aligning the text.
    #----------------------------------------------------------------------------
    restore_selection = editor.getSelectionStart() != editor.getSelectionEnd()

    #----------------------------------------------------------------------------
    # Align all instances of align_char within the lines of text
    #----------------------------------------------------------------------------
    if align_char is not None:
        # Enable the following to save the align_char, however it was determined,
        # to be the default_align_char when prompting for it next time.
        # default_align_char = align_char

        if max_align_char_count is None:
            align_char_count = max(line.count(align_char) for line in text_lines)
        else:
            align_char_count = max_align_char_count
        start = 0
        for instance in range(align_char_count):
            # Set the target column using the index of the align_char, ignoring
            # immediately preceding space, or the length of the line
            tgt_char_col = max(len(line[:line.find(align_char, start)].rstrip())
                               for line in text_lines)

            for (idx,line) in enumerate(text_lines):
                align_char_col = line.find(align_char, start)
                if align_char_col >= 0:
                    text_lines[idx] = line[:align_char_col].rstrip().ljust(tgt_char_col) \
                                    + line[align_char_col:]
            start = tgt_char_col + len(align_char)

        editor.setTarget(startPos, endPos)
        editor.replaceTarget(''.join(text_lines))

        if restore_selection:
            startPos = editor.positionFromLine(startLine)
            endPos = editor.getLineEndPosition(endLine)
            editor.setSelectionStart(startPos)
            editor.setSelectionEnd(endPos)


if __name__ == '__main__':
    align_selected_text()