     }
     
     
-    /// move cursor down and modify selection (⇧↓).
+    /// move cursor down and modify selection (⇧↓ / ^⇧N).
     override func moveDownAndModifySelection(_ sender: Any?) {
         
         guard self.hasMultipleInsertions else { return super.moveDownAndModifySelection(sender) }

    }
    
    
    /// move cursor up and modify selection (⇧↑).
    override func moveUpAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveUpAndModifySelection(sender) }

    
    
    
    // MARK: Text View Methods - Emacs
    
    /// Move cursor backward (^B).
    ///
    /// - Note: `opt↑` invokes first this method and then `moveToBeginningOfParagraph(_:)`.
    override func moveBackward(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveBackward(sender) }
        
        self.moveLeft(sender)
    }
    
    
    /// Move cursor backward and modify selection (^⇧B).
    ///
    /// - Note: `opt⇧↓` invokes first this method and then `moveToEndOfParagraphAndModifySelection(_:)`.
    override func moveBackwardAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveBackwardAndModifySelection(sender) }
        
        self.moveLeftAndModifySelection(sender)
    }
    
    
    /// Move cursor forward (^F).
    ///
    /// - Note: `opt↓` invokes first this method and then `moveToEndOfParagraph(_:)`.
    override func moveForward(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveForward(sender) }
        
        self.moveRight(sender)
    }
    
    
    /// Move cursor forward and modify selection (^⇧F).
    ///
    /// - Note: `opt⇧↓` invokes first this method and then `moveToEndOfParagraphAndModifySelection(_:)`.
    override func moveForwardAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveForwardAndModifySelection(sender) }
        
        self.moveRightAndModifySelection(sender)
    }
    
    
    /// Move cursor to the beginning of the logical line (^A).
    ///
    /// - Note: `opt↑` invokes first `moveBackward(_:)` and then this method.
    override func moveToBeginningOfParagraph(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveToBeginningOfParagraph(sender) }
        
        self.moveCursors(affinity: .downstream) { (self.string as NSString).lineRange(at: $0.lowerBound).lowerBound }
    }
    
    
    /// move cursor to the beginning of the logical line and modify selection (^⇧A).
    override func moveToBeginningOfParagraphAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveToBeginningOfParagraphAndModifySelection(sender) }
        
        self.moveCursorsAndModifySelection(affinity: .downstream) { (range, origin) in
            if let origin = origin, origin < range.upperBound {
                return ((self.string as NSString).lineRange(at: range.upperBound).lowerBound, range.lowerBound)
            } else {
                return ((self.string as NSString).lineRange(at: range.lowerBound).lowerBound, range.upperBound)
            }
        }
    }
    
    
    /// Move cursor to the end of the logical line (^E).
    ///
    /// - Note: `opt↓` invokes first `moveForward(_:)` and then this method.
    override func moveToEndOfParagraph(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveToEndOfParagraph(sender) }
        
        self.moveCursors(affinity: .upstream) { (self.string as NSString).lineRange(at: $0.upperBound, excludingLastLineEnding: true).upperBound }
    }
    
    
    /// move cursor to the end of the logical line and modify selection (^⇧E).
    override func moveToEndOfParagraphAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveToEndOfParagraphAndModifySelection(sender) }
        
        self.moveCursorsAndModifySelection(affinity: .upstream) { (range, origin) in
            if let origin = origin, origin > range.lowerBound {
                return ((self.string as NSString).lineRange(at: range.lowerBound, excludingLastLineEnding: true).upperBound, range.upperBound)
            } else {
                return ((self.string as NSString).lineRange(at: range.upperBound, excludingLastLineEnding: true).upperBound, range.lowerBound)
            }
        }
    }
    
    
    /// move cursor to the beginning of the word (^⌥B)
    override func moveWordBackward(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveWordBackward(sender) }
        
        self.moveCursors(affinity: .downstream) { self.wordRange(at: $0.lowerBound).lowerBound }
    }
    
    
    /// move cursor to the beginning of the word and modify selection (^⌥⇧B).
    override func moveWordBackwardAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveWordBackwardAndModifySelection(sender) }
        
        self.moveCursorsAndModifySelection(affinity: .downstream) { (range, origin) in
            if let origin = origin, origin < range.upperBound {
                return (self.wordRange(at: range.upperBound).lowerBound, range.lowerBound)
            } else {
                return (self.wordRange(at: range.lowerBound).lowerBound, range.upperBound)
            }
        }
    }
    
    
    /// move cursor to the end of the word (^⌥F)
    override func moveWordForward(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveWordForward(sender) }
        
        self.moveCursors(affinity: .upstream) { self.wordRange(at: $0.upperBound).upperBound }
    }
    
    
    /// move cursor to the end of the word and modify selection (^⌥⇧F).
    override func moveWordForwardAndModifySelection(_ sender: Any?) {
        
        guard self.hasMultipleInsertions else { return super.moveWordForwardAndModifySelection(sender) }
        
        self.moveCursorsAndModifySelection(affinity: .upstream) { (range, origin) in
            if let origin = origin, origin > range.lowerBound {
                return (self.wordRange(at: range.lowerBound).upperBound, range.upperBound)
            } else {
                return (self.wordRange(at: range.upperBound).upperBound, range.lowerBound)
            }
        }
    }
    
    // The following actions are also a part of NSStandardKeyBindingResponding but not implemented
    // since they seem just to bridge to `moveTo{Beginning|End}OfLine*` series. (2019-01 macOS 10.14)
    
    // moveToLeftEndOfLine(_ sender: Any?)
    // moveToLeftEndOfLineAndModifySelection(_ sender: Any?)
    // moveToRightEndOfLine(_ sender: Any?)
    // moveToRightEndOfLineAndModifySelection(_ sender: Any?)
    
    
    
    // MARK: - Actions
    
    @IBAction func selectColumnUp(_ sender: Any?) {
