Using range-based for loops and range adaptors with non-copyable input iterators

While the legacy C++17 named requirement InputIterator requires the iterator to be copyable, the new C++20 concept std::input_iterator does not.

But I tried to use std::views::drop(1) on a custom range that uses non-copyable iterators, and it didn't compile, issuing errors about my InputIterator not being copyable. So it seems that in fact a range does require their iterators to be copyable.

Minimal example:

#include <iterator>
#include <ranges>
#include <iostream>

class InputIterator {
public:
    using difference_type = std::ptrdiff_t;
    using value_type = int; 
    
    // Movable
    InputIterator(InputIterator&&) = default;
    InputIterator& operator=(InputIterator&&) = default;
    
    // Non-copyable
    InputIterator(const InputIterator&) = delete;
    InputIterator& operator=(const InputIterator&) = delete;
    
    int operator*() const { return *p_; } 
    InputIterator& operator++() { ++p_; return *this; }
    void operator++(int) { ++*this; }
    
    // Not required for input_iterator concept, but used for the rest of the example
    InputIterator() = default;
    InputIterator(const int* p) : p_(p) {}
    bool operator==(const InputIterator& other) const = default;
    bool operator!=(const InputIterator& other) const = default;
    
private:  
    const int* p_ = {};
};
 
static_assert(std::input_iterator<InputIterator>);

class InputView : public std::ranges::view_interface<InputView> {
public:
    InputIterator begin() const { return {array}; };   // RVO so OK even if non-copyable
    InputIterator end() const { return {array + 4}; }; // RVO so OK even if non-copyable
    
private:
    int array[4] = {1, 2, 3, 4};
};

int main() {
    // OK
    InputView view;

    // OK
    for (int x : view) {
        std::cout << x << " ";
    }
    
    // Does not compile
    for (int x : view | std::views::drop(1)) {
        std::cout << x << " ";
    }

    // Does not compile
    static_assert(std::ranges::input_range<InputView>);
}

The compile errors include things like:

[...]
note: because type constraint 'sentinel_for<InputIterator, __range_iter_t<InputView &> >' was not satisfied:
note: because 'InputIterator' does not satisfy 'semiregular'
note: because 'InputIterator' does not satisfy 'copyable'
note: because 'InputIterator' does not satisfy 'copy_constructible'
[...]

Is there a workaround to be able to use range adaptors (such as drop) with non-copyable iterators?