From cfb2a9b1f645459c33e727b247416a5c61aec373 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Fri, 17 Jun 2022 03:41:55 -0500
Subject: [PATCH 01/13] Support zeroarray for heterogeneous axes (#182)

Previously `ZeroArrayPromise` required homogeneous axes
(all `AbstractUnitRange`s having the same type).
This supports promotion prior to construction.

The test requires BlockArrays 0.16.17 (specifically
https://github.com/JuliaArrays/BlockArrays.jl/pull/213)
but it's not a dependency of the package, so let's just
trust in the lack of conflicts.
---
 Project.toml          |  6 +++---
 src/stackedviews.jl   |  1 +
 test/colorchannels.jl | 15 +++++++++++++++
 3 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/Project.toml b/Project.toml
index 69109a5..ad83716 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,6 +1,6 @@
 name = "ImageCore"
 uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
-version = "0.9.3"
+version = "0.9.4"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -29,7 +29,7 @@ julia = "1"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
-ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4"
+BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254"
@@ -40,4 +40,4 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Aqua", "ColorVectorSpace", "Documenter", "FFTW", "ImageInTerminal", "ImageMagick", "Random", "ReferenceTests", "Statistics", "Test"]
+test = ["Aqua", "BlockArrays", "Documenter", "FFTW", "ImageInTerminal", "ImageMagick", "Random", "ReferenceTests", "Statistics", "Test"]
diff --git a/src/stackedviews.jl b/src/stackedviews.jl
index b6abd6a..93baeb3 100644
--- a/src/stackedviews.jl
+++ b/src/stackedviews.jl
@@ -103,6 +103,7 @@ struct ZeroArray{T,N,R<:AbstractUnitRange} <: AbstractArray{T,N}
 end
 
 ZeroArrayPromise{T}(inds::NTuple{N,R}) where {T,N,R<:AbstractUnitRange} = ZeroArray{T,N,R}(inds)
+ZeroArrayPromise{T}(inds::NTuple{N,AbstractUnitRange}) where {T,N} = ZeroArrayPromise{T}(promote(inds...))
 Base.eltype(::Type{ZeroArrayPromise{T}}) where {T} = T
 
 Base.axes(A::ZeroArray) = A.inds
diff --git a/test/colorchannels.jl b/test/colorchannels.jl
index aea99bc..7e93e40 100644
--- a/test/colorchannels.jl
+++ b/test/colorchannels.jl
@@ -1,5 +1,6 @@
 using Colors, ImageCore, OffsetArrays, FixedPointNumbers, Test
 using OffsetArrays: IdentityUnitRange
+using BlockArrays
 
 # backward-compatibility to ColorTypes < v0.9 or Colors < v0.11
 using ImageCore: XRGB, RGBX
@@ -409,6 +410,20 @@ end
         a = OffsetArray(rand(3, 3, 5), 0:2, -1:1, -2:2)
         @test_throws (VERSION >= v"1.6.0-DEV.1083" ? ArgumentError : DimensionMismatch) colorview(RGB, a)
     end
+
+    @testset "Custom/divergent axis types" begin
+        img1 = rand(5, 4, 2)
+        img2_2 = mortar(reshape([rand(5, 4, 1), rand(5, 4, 1)], 1, 1, 2))
+        img2_all = mortar(reshape([rand(5, 4, 1), rand(5, 4, 1), rand(5, 4, 1)], 1, 1, 3))
+        img2_odd = img2_all[:,:,1:2:end]
+        for img2 in (img2_2, img2_odd)
+            for imgrgb in (colorview(RGB, img1, img2, zeroarray),
+                        colorview(RGB, img2, img1, zeroarray))
+                @test eltype(imgrgb) === RGB{Float64}
+                @test size(imgrgb) == size(img1)
+            end
+        end
+    end
 end
 
 end

From 6fc57c15ee0a6eb88af56fa2694b7c35eaacb861 Mon Sep 17 00:00:00 2001
From: Johnny Chen <johnnychen94@hotmail.com>
Date: Wed, 6 Jul 2022 10:34:03 +0800
Subject: [PATCH 02/13] test: Julia 1.8 Compat (#184)

9e64fecfdc6147753ebdd6b918d0bb435a89fb7f wrongly set the version
to 1.9, but it should be indeed 1.8
---
 test/views.jl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/views.jl b/test/views.jl
index 2668de0..897927b 100644
--- a/test/views.jl
+++ b/test/views.jl
@@ -70,7 +70,7 @@ end
         @test V[1,:,:] == A
         @test all(iszero, V[2,:,:])
         @test V[3,:,:] == B
-        err = VERSION >= v"1.9.0-DEV.351" ? CanonicalIndexError : ErrorException
+        err = VERSION >= v"1.8.0-rc1" ? CanonicalIndexError : ErrorException
         @test_throws err V[2,1,1] = 7
         V32 = @inferred(StackedView{Float32}(A, zeroarray, B))
         @test eltype(V32) == Float32
@@ -107,7 +107,7 @@ end
     @test @inferred(v[1,2]) === GrayA{N0f8}(0.25, 0.25)
     v = @inferred(colorview(GrayA{N0f8}, a, zeroarray))
     @test @inferred(v[2,1]) === GrayA{N0f8}(0.3,0)
-    err = VERSION >= v"1.9.0-DEV.351" ? CanonicalIndexError : ErrorException
+    err = VERSION >= v"1.8.0-rc1" ? CanonicalIndexError : ErrorException
     @test_throws err (v[1,2] = GrayA(0.25, 0.25))
     # RGB
     v = @inferred(colorview(RGB{N0f8}, a, zeroarray, b))

From 6d4b140096dd8244d704ce3174cce13b06a1d611 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Mon, 9 Jan 2023 05:34:12 -0600
Subject: [PATCH 03/13] Use error-hint for fft-related errors (#190)

Aqua was complaining about piracy. This eliminates some of the
piracy it was worried about, and the rest we temporarily (?)
circumvent by disabling Aqua's piracy test.

This package now only loads AbstractFFTs on Julia versions
that lack `Base.Experimental.register_error_hint` (Julia 1.4
and earlier).
---
 src/ImageCore.jl  | 22 +++++++++++++++++++++-
 test/functions.jl |  9 +++------
 test/runtests.jl  |  6 ++++--
 3 files changed, 28 insertions(+), 9 deletions(-)

diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index f835c9c..2a7a45c 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -99,7 +99,6 @@ include("convert_reinterpret.jl")
 include("traits.jl")
 include("map.jl")
 include("show.jl")
-include("functions.jl")
 include("deprecations.jl")
 
 """
@@ -170,6 +169,27 @@ function Base.transpose(a::AbstractVector{C}) where C<:Colorant
     out
 end
 
+# It's better not to define fft on Colorant arrays, because keeping
+# track of the color dimension and the fft-dims is prone to omissions
+# or problems due to later operations. So we put the bookkeeping on
+# the user, but we try to give helpful suggestions.
+function throw_ffterror(io, @nospecialize(f), x, dims=1:ndims(x))
+    newdims = plus(dims, channelview_dims_offset(x))
+    print(io, '\n', f, " not defined for eltype $(eltype(x)). Use channelview, and likely $newdims for the dims in the fft.")
+end
+
+if Base.VERSION >= v"1.5"
+    function __init__()
+        Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
+            if nameof(exc.f) ∈ (:fft, :rfft, :plan_fft, :plan_rfft, :realfloat) && argtypes[1] <: AbstractArray{<:Colorant}
+                throw_ffterror(io, exc.f, exc.args...)
+            end
+        end
+    end
+else
+    include("functions.jl")
+end
+
 if VERSION >= v"1.4.2" # work around https://github.com/JuliaLang/julia/issues/34121
     include("precompile.jl")
     _precompile_()
diff --git a/test/functions.jl b/test/functions.jl
index b6fb01c..837ccdf 100644
--- a/test/functions.jl
+++ b/test/functions.jl
@@ -7,15 +7,12 @@ using FFTW
                       (rfft, (ag,)), (rfft, (ag, 1:2)), (plan_rfft, (ag,)),
                       (fft, (ac,)), (fft, (ac, 1:2)), (plan_fft, (ac,)),
                       (rfft, (ac,)), (rfft, (ac, 1:2)), (plan_rfft, (ac,)))
-        ret = @test_throws ErrorException f(args...)
-        @test occursin("channelview", ret.value.msg)
-        @test occursin(eltype(args[1])<:Gray ? "1:2" : "2:3", ret.value.msg)
+        dims_str = eltype(args[1])<:Gray ? "1:2" : "2:3"
+        ret = @test_throws "channelview, and likely $dims_str" f(args...)
     end
     for (a, dims) in ((ag, 1:2), (ac, 2:3))
         @test ifft(fft(channelview(a), dims), dims) ≈ channelview(a)
-        ret = @test_throws ErrorException rfft(a)
-        @test occursin("channelview", ret.value.msg)
-        @test occursin("$dims", ret.value.msg)
+        ret = @test_throws "channelview, and likely $dims" rfft(a)
         @test irfft(rfft(channelview(a), dims), 4, dims) ≈ channelview(a)
     end
 
diff --git a/test/runtests.jl b/test/runtests.jl
index 4d2d76d..c7ae978 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -11,7 +11,9 @@ using Aqua, Documenter # for meta quality checks
                   ambiguities=false,
                   project_extras=true,
                   deps_compat=true,
-                  stale_deps=true,
+                  stale_deps=Base.VERSION < v"1.5", # we don't use AbstractFFTs on 1.5+
+                  # FIXME? re-enable the `piracy` test
+                  piracy=false, # Base.VERSION >= v"1.5",    # need the register_error_hint for AbstractFFTs
                   project_toml_formatting=true,
                   unbound_args=false, # FIXME: it fails when this is true
     )
@@ -31,7 +33,7 @@ include("views.jl")
 include("convert_reinterpret.jl")
 include("traits.jl")
 include("map.jl")
-include("functions.jl")
+Base.VERSION >= v"1.8" && include("functions.jl")   # requires @test_throws msg expr
 include("show.jl")
 
 # To ensure our deprecations work and don't break code

From fc9ac05630ac07876963d412a295fade46e0094e Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Tue, 10 Jan 2023 16:52:31 -0600
Subject: [PATCH 04/13] Switch to SnoopPrecompile (#189)

Using Julia nightly, this cuts the time required to execute the
workload in the `@precompile_all_calls` from 6.55s to 2.15s,
while also slightly reducing load time from 1.06s to 0.99s.
The fact that it's not even larger is surely due to compilation
of the helper functions `pcarray`, `pcm`, and `pcmv`.
---
 Project.toml      |   2 +
 src/ImageCore.jl  |   1 -
 src/precompile.jl | 176 ++++++++++++++++++++++------------------------
 test/runtests.jl  |   2 +-
 4 files changed, 88 insertions(+), 93 deletions(-)

diff --git a/Project.toml b/Project.toml
index ad83716..6d3a4f6 100644
--- a/Project.toml
+++ b/Project.toml
@@ -13,6 +13,7 @@ MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PaddedViews = "5432bcbf-9aad-5242-b902-cca2824c8663"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
 
 [compat]
 AbstractFFTs = "0.4, 0.5, 1.0"
@@ -25,6 +26,7 @@ MosaicViews = "0.3.3"
 OffsetArrays = "0.8, 0.9, 0.10, 0.11, 1.0.1"
 PaddedViews = "0.5.8"
 Reexport = "0.2, 1.0"
+SnoopPrecompile = "1"
 julia = "1"
 
 [extras]
diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index 2a7a45c..0a58dca 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -192,7 +192,6 @@ end
 
 if VERSION >= v"1.4.2" # work around https://github.com/JuliaLang/julia/issues/34121
     include("precompile.jl")
-    _precompile_()
 end
 
 end ## module
diff --git a/src/precompile.jl b/src/precompile.jl
index 382bac8..6d9626c 100644
--- a/src/precompile.jl
+++ b/src/precompile.jl
@@ -1,109 +1,103 @@
-macro warnpcfail(ex::Expr)
-    modl = __module__
-    file = __source__.file === nothing ? "?" : String(__source__.file)
-    line = __source__.line
-    quote
-        $(esc(ex)) || @warn """precompile directive
-     $($(Expr(:quote, ex)))
- failed. Please report an issue in $($modl) (after checking for duplicates) or remove this directive.""" _file=$file _line=$line
-    end
-end
+using SnoopPrecompile
 
-function pcarray(f::F, ::Type{A}, sz) where {F,A}
-    a = f(A(undef, sz))
-    fill!(a, zero(eltype(a)))
-    return first(a)
-end
-function pcm(a1, a2; fillvalue = zero(eltype(a1)))
-    v = mosaic(a1, a2; fillvalue=fillvalue)
-    return first(v)
-end
-function pcmv(a; fillvalue = zero(eltype(a)))
-    v = mosaicview(a; fillvalue=fillvalue)
-    return first(v)
-end
-
-function _precompile_()
-    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    eltypes = (N0f8, N0f16, Float32, Float64)        # eltypes of parametric colors
-    pctypes = (Gray, RGB, AGray, GrayA, ARGB, RGBA)  # parametric colors
-    cctypes = (Gray24, AGray32, RGB24, ARGB32)       # non-parametric colors
-    dims  = (1, 2, 3, 4)
-    szs   = ((2,), (2, 2), (2, 2, 2), (2, 2, 2, 2))
-
-    for T in eltypes
-        @warnpcfail precompile(clamp01, (T,))
-        @warnpcfail precompile(clamp01nan, (T,))
-        @warnpcfail precompile(scaleminmax, (T, T))
-        @warnpcfail precompile(scalesigned, (T,))
-        @warnpcfail precompile(scalesigned, (T,T,T))
-        for C in pctypes
-            @warnpcfail precompile(clamp01, (C{T},))
-            @warnpcfail precompile(clamp01nan, (C{T},))
-            @warnpcfail precompile(colorsigned, (C{T},C{T}))
-        end
+let
+@precompile_setup begin
+    function pcarray(f::F, ::Type{A}, sz) where {F,A}
+        a = f(A(undef, sz))
+        fill!(a, zero(eltype(a)))
+        return first(a)
     end
-    for C in cctypes
-        @warnpcfail precompile(clamp01, (C,))
-        @warnpcfail precompile(clamp01nan, (C,))
-        @warnpcfail precompile(colorsigned, (C,C))
+    function pcm(a1, a2; fillvalue = zero(eltype(a1)))
+        v = mosaic(a1, a2; fillvalue=fillvalue)
+        return first(v)
     end
-    # For the arrays, it's better to make them and exercise them so we get the getindex/setindex!
-    # methods precompiled too.
-    for sz in szs
-        for T in eltypes
-            T <: FixedPoint || continue
-            pcarray(rawview, Array{T,length(sz)}, sz)
-        end
-        pcarray(normedview, Array{UInt8,length(sz)}, sz)
-        pcarray(a->normedview(N0f8, a),  Array{UInt8, length(sz)}, sz)
-        pcarray(a->normedview(N0f16, a), Array{UInt16,length(sz)}, sz)
+    function pcmv(a; fillvalue = zero(eltype(a)))
+        v = mosaicview(a; fillvalue=fillvalue)
+        return first(v)
     end
-    for sz in szs
+
+    eltypes = (N0f8, N0f16, Float32, Float64)    # eltypes of parametric colors
+    pctypes = (Gray, RGB)                        # parametric colors
+    cctypes = ()                                 # non-parametric colors (e.g., Gray24)
+    dims  = (1, 2, 3, 4)
+    szs   = ((2,), (2, 2), (2, 2, 2), (2, 2, 2, 2))
+    @precompile_all_calls begin
         for T in eltypes
+            clamp01(zero(T))
+            clamp01nan(zero(T))
+            scaleminmax(zero(T), oneunit(T))
+            scalesigned(oneunit(T))
+            scalesigned(zero(T), oneunit(T) / 2, oneunit(T))
             for C in pctypes
-                nc = sizeof(C{T}) ÷ sizeof(T)
-                if nc == 1
-                    pcarray(a->colorview(C,    a), Array{T,length(sz)}, sz)
-                    pcarray(a->colorview(C{T}, a), Array{T,length(sz)}, sz)
-                else
-                    pcarray(a->colorview(C,    a), Array{T,length(sz)+1}, (nc, sz...))
-                    pcarray(a->colorview(C{T}, a), Array{T,length(sz)+1}, (nc, sz...))
-                end
-                pcarray(channelview, Array{C{T},length(sz)}, sz)
-                if T<:FixedPoint
-                    R = FixedPointNumbers.rawtype(T)
+                clamp01(zero(C{T}))
+                clamp01nan(zero(C{T}))
+                colorsigned(zero(C{T}), oneunit(C{T}))
+            end
+        end
+        for C in cctypes
+            clamp01(zero(C))
+            clamp01nan(zero(C))
+            C === AGray32 && continue
+            colorsigned(zero(C), oneunit(C))
+        end
+        # For the arrays, it's better to make them and exercise them so we get the getindex/setindex!
+        # methods precompiled too.
+        for sz in szs
+            for T in eltypes
+                T <: FixedPoint || continue
+                pcarray(rawview, Array{T,length(sz)}, sz)
+            end
+            pcarray(normedview, Array{UInt8,length(sz)}, sz)
+            pcarray(a->normedview(N0f8, a),  Array{UInt8, length(sz)}, sz)
+            pcarray(a->normedview(N0f16, a), Array{UInt16,length(sz)}, sz)
+        end
+        for sz in szs
+            for T in eltypes
+                for C in pctypes
+                    nc = sizeof(C{T}) ÷ sizeof(T)
                     if nc == 1
-                        pcarray(a->colorview(C,    normedview(T, a)), Array{R,length(sz)}, sz)
-                        pcarray(a->colorview(C{T}, normedview(T, a)), Array{R,length(sz)}, sz)
+                        pcarray(a->colorview(C,    a), Array{T,length(sz)}, sz)
+                        pcarray(a->colorview(C{T}, a), Array{T,length(sz)}, sz)
                     else
-                        pcarray(a->colorview(C,    normedview(T, a)), Array{R,length(sz)+1}, (nc, sz...))
-                        pcarray(a->colorview(C{T}, normedview(T, a)), Array{R,length(sz)+1}, (nc, sz...))
+                        pcarray(a->colorview(C,    a), Array{T,length(sz)+1}, (nc, sz...))
+                        pcarray(a->colorview(C{T}, a), Array{T,length(sz)+1}, (nc, sz...))
+                    end
+                    pcarray(channelview, Array{C{T},length(sz)}, sz)
+                    if T<:FixedPoint
+                        R = FixedPointNumbers.rawtype(T)
+                        if nc == 1
+                            pcarray(a->colorview(C,    normedview(T, a)), Array{R,length(sz)}, sz)
+                            pcarray(a->colorview(C{T}, normedview(T, a)), Array{R,length(sz)}, sz)
+                        else
+                            pcarray(a->colorview(C,    normedview(T, a)), Array{R,length(sz)+1}, (nc, sz...))
+                            pcarray(a->colorview(C{T}, normedview(T, a)), Array{R,length(sz)+1}, (nc, sz...))
+                        end
                     end
                 end
             end
+            T, C = Bool, Gray
+            pcarray(a->colorview(C,    a), Array{T,length(sz)}, sz)
+            pcarray(a->colorview(C{T}, a), Array{T,length(sz)}, sz)
+            pcarray(channelview, Array{C{T},length(sz)}, sz)
         end
-        T, C = Bool, Gray
-        pcarray(a->colorview(C,    a), Array{T,length(sz)}, sz)
-        pcarray(a->colorview(C{T}, a), Array{T,length(sz)}, sz)
-        pcarray(channelview, Array{C{T},length(sz)}, sz)
-    end
-    for T in eltypes
-        a = zeros(T, (2, 2))
-        a3 = zeros(T, (2, 2, 2))
-        pcm(a, a)
-        pcmv(a3)
-        for C in (Gray, RGB, GrayA, RGBA)
-            a = zeros(C{T}, (2, 2))
-            a3 = zeros(C{T}, (2, 2, 3))
+        for T in eltypes
+            a = zeros(T, (2, 2))
+            a3 = zeros(T, (2, 2, 2))
             pcm(a, a)
             pcmv(a3)
-            if C === RGB
-                pcm(a, a; fillvalue=zero(Gray{T}))
-            elseif C === RGBA
-                pcm(a, a; fillvalue=zero(GrayA{T}))
+            for C in (Gray, RGB, GrayA, RGBA)
+                a = zeros(C{T}, (2, 2))
+                a3 = zeros(C{T}, (2, 2, 3))
+                pcm(a, a)
+                pcmv(a3)
+                if C === RGB
+                    pcm(a, a; fillvalue=zero(Gray{T}))
+                elseif C === RGBA
+                    pcm(a, a; fillvalue=zero(GrayA{T}))
+                end
             end
         end
+        pcm(zeros(Float32, 2, 2), zeros(Float64, 2, 2))  # heterogeneous
     end
-    pcm(zeros(Float32, 2, 2), zeros(Float64, 2, 2))  # heterogeneous
+end
 end
diff --git a/test/runtests.jl b/test/runtests.jl
index c7ae978..f3a541e 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -11,7 +11,7 @@ using Aqua, Documenter # for meta quality checks
                   ambiguities=false,
                   project_extras=true,
                   deps_compat=true,
-                  stale_deps=Base.VERSION < v"1.5", # we don't use AbstractFFTs on 1.5+
+                  stale_deps= v"1.4" <= Base.VERSION < v"1.5", # we don't use AbstractFFTs on 1.5+, SnoopPrecompile on <1.4
                   # FIXME? re-enable the `piracy` test
                   piracy=false, # Base.VERSION >= v"1.5",    # need the register_error_hint for AbstractFFTs
                   project_toml_formatting=true,

From d7c472211a9419b35525c6454fef56206426176d Mon Sep 17 00:00:00 2001
From: Elias Carvalho <73039601+eliascarv@users.noreply.github.com>
Date: Sun, 5 Mar 2023 23:19:34 -0300
Subject: [PATCH 05/13] Make type aliases constant (#191)

* Make type aliases constant

* Make some more type aliases constant
---
 src/ImageCore.jl | 12 ++++++------
 src/show.jl      |  4 ++--
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index 0a58dca..79b3a59 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -24,13 +24,13 @@ plus(r::AbstractUnitRange, i::Integer) = broadcast(+, r, i)
 plus(a::AbstractArray, i::Integer) = a .+ i
 
 using .ColorTypes: AbstractGray, TransparentGray, Color3, Transparent3
-Color1{T} = Colorant{T,1}
-Color2{T} = Colorant{T,2}
-Color4{T} = Colorant{T,4}
-AColor{N,C,T} = AlphaColor{C,T,N}
-ColorA{N,C,T} = ColorAlpha{C,T,N}
+const Color1{T} = Colorant{T,1}
+const Color2{T} = Colorant{T,2}
+const Color4{T} = Colorant{T,4}
+const AColor{N,C,T} = AlphaColor{C,T,N}
+const ColorA{N,C,T} = ColorAlpha{C,T,N}
 const NonparametricColors = Union{RGB24,ARGB32,Gray24,AGray32}
-Color1Array{C<:Color1,N} = AbstractArray{C,N}
+const Color1Array{C<:Color1,N} = AbstractArray{C,N}
 # Type that arises from reshape(reinterpret(To, A), sz):
 if VERSION >= v"1.6.0-DEV.1083"
     const RRArray{To,From,M,P} = Base.ReinterpretArray{To,M,From,P,true}
diff --git a/src/show.jl b/src/show.jl
index dfc9f25..cd53e3f 100644
--- a/src/show.jl
+++ b/src/show.jl
@@ -1,5 +1,5 @@
 # rawview
-AAFixed{T<:FixedPoint,N} = AbstractArray{T,N}
+const AAFixed{T<:FixedPoint,N} = AbstractArray{T,N}
 function Base.showarg(io::IO, A::MappedArray{T,N,AA,typeof(reinterpret)}, toplevel=false) where {T<:Integer,N,AA<:AAFixed}
     print(io, "rawview(")
     Base.showarg(io, parent(A), false)
@@ -8,7 +8,7 @@ function Base.showarg(io::IO, A::MappedArray{T,N,AA,typeof(reinterpret)}, toplev
 end
 
 # normedview
-AAInteger{T<:Integer,N} = AbstractArray{T,N}
+const AAInteger{T<:Integer,N} = AbstractArray{T,N}
 function Base.showarg(io::IO, A::MappedArray{T,N,AA,F,typeof(reinterpret)}, toplevel=false) where {T<:FixedPoint,N,AA<:AAInteger,F}
     print(io, "normedview(")
     ColorTypes.showcoloranttype(io, T)

From eadeca101a620fd7c7b08a21d1595f649a3d5ff6 Mon Sep 17 00:00:00 2001
From: Johnny Chen <johnnychen94@hotmail.com>
Date: Thu, 20 Jul 2023 23:00:07 +0800
Subject: [PATCH 06/13] chore: remove Graphics dependency (#185)

---
 Project.toml     | 2 --
 src/ImageCore.jl | 9 ++-------
 src/traits.jl    | 4 ----
 test/traits.jl   | 2 --
 4 files changed, 2 insertions(+), 15 deletions(-)

diff --git a/Project.toml b/Project.toml
index 6d3a4f6..e594cc8 100644
--- a/Project.toml
+++ b/Project.toml
@@ -7,7 +7,6 @@ AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
 ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4"
 Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"
 FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
-Graphics = "a2bd30eb-e257-5431-a919-1863eab51364"
 MappedArrays = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
 MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
@@ -20,7 +19,6 @@ AbstractFFTs = "0.4, 0.5, 1.0"
 ColorVectorSpace = "0.9.7"
 Colors = "0.12"
 FixedPointNumbers = "0.8"
-Graphics = "0.4, 1.0"
 MappedArrays = "0.2, 0.3, 0.4"
 MosaicViews = "0.3.3"
 OffsetArrays = "0.8, 0.9, 0.10, 0.11, 1.0.1"
diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index 79b3a59..cc4eff5 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -7,7 +7,7 @@ using Reexport
 
 @reexport using MosaicViews
 @reexport using PaddedViews
-using MappedArrays, Graphics
+using MappedArrays
 using OffsetArrays # for show.jl
 using .ColorTypes: colorant_string
 using Colors: Fractional
@@ -16,8 +16,6 @@ using MappedArrays: AbstractMultiMappedArray
 using Base: tail, @pure, Indices
 import Base: float
 
-import Graphics: width, height
-
 # TODO: just use .+
 # See https://github.com/JuliaLang/julia/pull/22932#issuecomment-330711997
 plus(r::AbstractUnitRange, i::Integer) = broadcast(+, r, i)
@@ -81,7 +79,6 @@ export
     # traits
     assert_timedim_last,
     coords_spatial,
-    height,
     indices_spatial,
     namedaxes,
     nimages,
@@ -89,9 +86,7 @@ export
     sdims,
     size_spatial,
     spacedirections,
-    spatialorder,
-    width,
-    widthheight
+    spatialorder
 
 include("colorchannels.jl")
 include("stackedviews.jl")
diff --git a/src/traits.jl b/src/traits.jl
index c7c38c2..8ef6694 100644
--- a/src/traits.jl
+++ b/src/traits.jl
@@ -200,10 +200,6 @@ end
 assert_timedim_last(img::OffsetArray) = assert_timedim_last(parent(img))
 assert_timedim_last(img::SubArray) = assert_timedim_last(parent(img))
 
-widthheight(img::AbstractArray) = length(axes(img,2)), length(axes(img,1))
-
-width(img::AbstractArray) = widthheight(img)[1]
-height(img::AbstractArray) = widthheight(img)[2]
 
 
 # Traits whose only meaningful definitions occur in ImageAxes, but for
diff --git a/test/traits.jl b/test/traits.jl
index 866af39..6ee24f0 100644
--- a/test/traits.jl
+++ b/test/traits.jl
@@ -29,8 +29,6 @@ using ImageCore: Pixel, NumberLike, GenericImage, GenericGrayImage, default_name
             @test indices_spatial(B) == (Base.OneTo(3), Base.OneTo(5))
         end
         assert_timedim_last(B)
-        @test width(B) == 5
-        @test height(B) == 3
     end
 end
 

From 0046ec78ec117103f05d9e3a2b00287ce88d6d34 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Thu, 20 Jul 2023 10:01:22 -0500
Subject: [PATCH 07/13] Restrict clamp01 to gray & RGB (#181)

The 0-to-1 colorscale does not have meaning for colors like HSV,
so supporting arbitrary colorants seems wrong.
---
 src/map.jl | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/map.jl b/src/map.jl
index 8ccd44f..7c13253 100644
--- a/src/map.jl
+++ b/src/map.jl
@@ -11,8 +11,8 @@ channel separately.
 See also: [`clamp01!`](@ref), [`clamp01nan`](@ref).
 """
 clamp01(x::Union{N0f8,N0f16}) = x
-clamp01(x::Number) = clamp(x, zero(x), oneunit(x))
-clamp01(c::Colorant) = mapc(clamp01, c)
+clamp01(x::NumberLike) = clamp(x, zero(x), oneunit(x))
+clamp01(c::Union{TransparentGray,AbstractRGB,TransparentRGB}) = mapc(clamp01, c)
 
 """
     clamp01!(array::AbstractArray)
@@ -35,8 +35,8 @@ Similar to `clamp01`, except that any `NaN` values are changed to 0.
 See also: [`clamp01nan!`](@ref), [`clamp01`](@ref).
 """
 clamp01nan(x) = clamp01(x)
-clamp01nan(x::AbstractFloat) = ifelse(isnan(x), zero(x), clamp01(x))
-clamp01nan(c::Colorant) = mapc(clamp01nan, c)
+clamp01nan(x::Union{AbstractFloat,AbstractGray{<:AbstractFloat}}) = ifelse(isnan(x), zero(x), clamp01(x))
+clamp01nan(c::Union{TransparentGray,AbstractRGB,TransparentRGB}) = mapc(clamp01nan, c)
 
 """
     clamp01nan!(array::AbstractArray)

From 9523bd997cfdeff75956a3ab472e0005f1303134 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Thu, 20 Jul 2023 10:45:05 -0500
Subject: [PATCH 08/13] Require CVS 0.10 (#192)

This sets the stage for the entire JuliaImages ecosystem switching
to ColorVectorSpace 0.10. We can also anticipate the removal
of ColorVectorSpace.Future.abs2 internally, so the switch to
CVS 0.11 won't require a breaking change here or elsewhere.
---
 Project.toml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/Project.toml b/Project.toml
index e594cc8..3620827 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,6 +1,6 @@
 name = "ImageCore"
 uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
-version = "0.9.4"
+version = "0.10.0"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -16,7 +16,7 @@ SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
 
 [compat]
 AbstractFFTs = "0.4, 0.5, 1.0"
-ColorVectorSpace = "0.9.7"
+ColorVectorSpace = "0.10"
 Colors = "0.12"
 FixedPointNumbers = "0.8"
 MappedArrays = "0.2, 0.3, 0.4"
@@ -33,11 +33,10 @@ BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
 ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254"
-ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 ReferenceTests = "324d217c-45ce-50fc-942e-d289b448e8cf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Aqua", "BlockArrays", "Documenter", "FFTW", "ImageInTerminal", "ImageMagick", "Random", "ReferenceTests", "Statistics", "Test"]
+test = ["Aqua", "BlockArrays", "Documenter", "FFTW", "ImageInTerminal", "Random", "ReferenceTests", "Statistics", "Test"]

From 81b7e08a952b5785bfe6c386f585a34e14e78828 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Thu, 20 Jul 2023 10:49:09 -0500
Subject: [PATCH 09/13] Switch to PrecompileTools (#193)

---
 Project.toml      | 4 ++--
 src/precompile.jl | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Project.toml b/Project.toml
index 3620827..081cc14 100644
--- a/Project.toml
+++ b/Project.toml
@@ -12,7 +12,7 @@ MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PaddedViews = "5432bcbf-9aad-5242-b902-cca2824c8663"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
-SnoopPrecompile = "66db9d55-30c0-4569-8b51-7e840670fc0c"
+PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 
 [compat]
 AbstractFFTs = "0.4, 0.5, 1.0"
@@ -24,7 +24,7 @@ MosaicViews = "0.3.3"
 OffsetArrays = "0.8, 0.9, 0.10, 0.11, 1.0.1"
 PaddedViews = "0.5.8"
 Reexport = "0.2, 1.0"
-SnoopPrecompile = "1"
+PrecompileTools = "1"
 julia = "1"
 
 [extras]
diff --git a/src/precompile.jl b/src/precompile.jl
index 6d9626c..67fe15b 100644
--- a/src/precompile.jl
+++ b/src/precompile.jl
@@ -1,7 +1,7 @@
-using SnoopPrecompile
+using PrecompileTools
 
 let
-@precompile_setup begin
+@setup_workload begin
     function pcarray(f::F, ::Type{A}, sz) where {F,A}
         a = f(A(undef, sz))
         fill!(a, zero(eltype(a)))
@@ -21,7 +21,7 @@ let
     cctypes = ()                                 # non-parametric colors (e.g., Gray24)
     dims  = (1, 2, 3, 4)
     szs   = ((2,), (2, 2), (2, 2, 2), (2, 2, 2, 2))
-    @precompile_all_calls begin
+    @compile_workload begin
         for T in eltypes
             clamp01(zero(T))
             clamp01nan(zero(T))

From 145ffd40aa253e5bdeffc0dfab1d61c541ed2991 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Fri, 21 Jul 2023 09:27:40 -0500
Subject: [PATCH 10/13] Drop Julia 1.0 support, alphabetize [compat] (#194)

---
 .github/workflows/UnitTest.yml |  4 ++--
 Project.toml                   | 11 ++++++-----
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/UnitTest.yml b/.github/workflows/UnitTest.yml
index b1f5fe7..00e415b 100644
--- a/.github/workflows/UnitTest.yml
+++ b/.github/workflows/UnitTest.yml
@@ -14,7 +14,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        julia-version: ['1.0', '1', 'nightly']
+        julia-version: ['1.6', '1', 'nightly']
         os: [ubuntu-latest]
         arch: [x64]
         include:
@@ -41,7 +41,7 @@ jobs:
         env:
           cache-name: cache-artifacts
         with:
-          path: ~/.julia/artifacts 
+          path: ~/.julia/artifacts
           key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
           restore-keys: |
             ${{ runner.os }}-test-${{ env.cache-name }}-
diff --git a/Project.toml b/Project.toml
index 081cc14..a10cc4f 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,6 +1,6 @@
 name = "ImageCore"
 uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
-version = "0.10.0"
+version = "0.10.1"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
@@ -11,8 +11,8 @@ MappedArrays = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900"
 MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PaddedViews = "5432bcbf-9aad-5242-b902-cca2824c8663"
-Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 
 [compat]
 AbstractFFTs = "0.4, 0.5, 1.0"
@@ -23,15 +23,16 @@ MappedArrays = "0.2, 0.3, 0.4"
 MosaicViews = "0.3.3"
 OffsetArrays = "0.8, 0.9, 0.10, 0.11, 1.0.1"
 PaddedViews = "0.5.8"
-Reexport = "0.2, 1.0"
 PrecompileTools = "1"
-julia = "1"
+Reexport = "0.2, 1.0"
+julia = "1.6"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
+ImageIO = "82e4d734-157c-48bb-816b-45c225c6df19"
 ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 ReferenceTests = "324d217c-45ce-50fc-942e-d289b448e8cf"
@@ -39,4 +40,4 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 
 [targets]
-test = ["Aqua", "BlockArrays", "Documenter", "FFTW", "ImageInTerminal", "Random", "ReferenceTests", "Statistics", "Test"]
+test = ["Aqua", "BlockArrays", "Documenter", "FFTW", "ImageIO", "ImageInTerminal", "Random", "ReferenceTests", "Statistics", "Test"]

From d9eeb6da8d4525ed922ce1f397e63e928858e6f0 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Fri, 21 Jul 2023 16:26:58 -0500
Subject: [PATCH 11/13] Eliminate old version cruft (#195)

Now that we require Julia 1.6, a lot of cruft can be removed.
This includes the nominal dependency on AbstractFFTs.

This also improves a few method definitions and now
passes Aqua's `unbound_args` test.
---
 Project.toml               |  2 --
 src/ImageCore.jl           | 22 ++++-----------
 src/colorchannels.jl       | 51 +++++++++++-----------------------
 src/convert_reinterpret.jl | 57 ++------------------------------------
 src/deprecations.jl        | 24 +++++++---------
 src/functions.jl           | 20 -------------
 src/stackedviews.jl        |  2 +-
 test/colorchannels.jl      |  2 +-
 test/runtests.jl           |  6 ++--
 test/show.jl               | 16 ++++-------
 10 files changed, 44 insertions(+), 158 deletions(-)
 delete mode 100644 src/functions.jl

diff --git a/Project.toml b/Project.toml
index a10cc4f..5aa9fba 100644
--- a/Project.toml
+++ b/Project.toml
@@ -3,7 +3,6 @@ uuid = "a09fc81d-aa75-5fe9-8630-4744c3626534"
 version = "0.10.1"
 
 [deps]
-AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
 ColorVectorSpace = "c3611d14-8923-5661-9e6a-0046d554d3a4"
 Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"
 FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
@@ -15,7 +14,6 @@ PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 
 [compat]
-AbstractFFTs = "0.4, 0.5, 1.0"
 ColorVectorSpace = "0.10"
 Colors = "0.12"
 FixedPointNumbers = "0.8"
diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index cc4eff5..76bb1b6 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -30,11 +30,7 @@ const ColorA{N,C,T} = ColorAlpha{C,T,N}
 const NonparametricColors = Union{RGB24,ARGB32,Gray24,AGray32}
 const Color1Array{C<:Color1,N} = AbstractArray{C,N}
 # Type that arises from reshape(reinterpret(To, A), sz):
-if VERSION >= v"1.6.0-DEV.1083"
-    const RRArray{To,From,M,P} = Base.ReinterpretArray{To,M,From,P,true}
-else
-    const RRArray{To,From,N,M,P} = Base.ReshapedArray{To,N,Base.ReinterpretArray{To,M,From,P}}
-end
+const RRArray{To,From,M,P} = Base.ReinterpretArray{To,M,From,P,true}
 const RGArray = Union{Base.ReinterpretArray{<:AbstractGray,M,<:Number,P}, Base.ReinterpretArray{<:Number,M,<:AbstractGray,P}} where {M,P}
 
 # delibrately not export these constants to enable extensibility for downstream packages
@@ -173,20 +169,14 @@ function throw_ffterror(io, @nospecialize(f), x, dims=1:ndims(x))
     print(io, '\n', f, " not defined for eltype $(eltype(x)). Use channelview, and likely $newdims for the dims in the fft.")
 end
 
-if Base.VERSION >= v"1.5"
-    function __init__()
-        Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
-            if nameof(exc.f) ∈ (:fft, :rfft, :plan_fft, :plan_rfft, :realfloat) && argtypes[1] <: AbstractArray{<:Colorant}
-                throw_ffterror(io, exc.f, exc.args...)
-            end
+function __init__()
+    Base.Experimental.register_error_hint(MethodError) do io, exc, argtypes, kwargs
+        if nameof(exc.f) ∈ (:fft, :rfft, :plan_fft, :plan_rfft, :realfloat) && argtypes[1] <: AbstractArray{<:Colorant}
+            throw_ffterror(io, exc.f, exc.args...)
         end
     end
-else
-    include("functions.jl")
 end
 
-if VERSION >= v"1.4.2" # work around https://github.com/JuliaLang/julia/issues/34121
-    include("precompile.jl")
-end
+include("precompile.jl")
 
 end ## module
diff --git a/src/colorchannels.jl b/src/colorchannels.jl
index 811c835..ffca438 100644
--- a/src/colorchannels.jl
+++ b/src/colorchannels.jl
@@ -27,22 +27,19 @@ dimorder(::Type{<:AlphaColor{<:Color3,T,N}}) where {T,N} = ColorChanPerm((4, 1,
 
 const ColorChanPermSubArray{T,N,P,I<:Tuple,L} =
     SubArray{T,N,P,I,L}
-if VERSION >= v"1.6.0-DEV.1083"
-    const RRPermArray{To,From,M,P<:ColorChanPermSubArray} =
-        RRArray{To,From,M,P}
-else
-    const RRPermArray{To,From,N,M,P<:ColorChanPermSubArray} =
-        RRArray{To,From,N,M,P}
-end
+const RRPermArray{To,From,M,P<:ColorChanPermSubArray} =
+    RRArray{To,From,M,P}
 
 # This type exists solely to set multiple values in the color channel axis
 struct NVector{T,N} <: AbstractVector{T}
     v::NTuple{N,T}
+
+    NVector{T,N}(x::NTuple{N}) where {T,N} = new{T,N}(x)
 end
 Base.IndexStyle(::Type{<:NVector}) = IndexLinear()
 Base.size(v::NVector{T,N}) where {T,N} = (N,)
 Base.getindex(v::NVector, i::Int) = v.v[i]
-NVector(x::Vararg{T,N}) where {T,N} = NVector{T,N}(x)
+NVector(x1::T, x::Vararg{T,N}) where {T,N} = NVector{T,N+1}((x1, x...))
 
 @inline Base.setindex!(A::RRPermArray{<:RGBX,<:Number,N}, val::AbstractRGB, i::Vararg{Int,N}) where N =
     setindex!(parent(parent(parent(A))), NVector(red(val), green(val), blue(val)), :, i...)
@@ -66,13 +63,8 @@ A = channelview(img)   # a 3×10×10 array
 See also: [`colorview`](@ref)
 """
 channelview(A::AbstractArray{T}) where {T<:Number} = A
-if VERSION >= v"1.6.0-DEV.1083"
-    channelview(A::RRArray{<:Colorant,<:Number}) = parent(A)
-    channelview(A::RRPermArray{<:Colorant,<:Number}) = parent(parent(A))
-else
-    channelview(A::RRArray{<:Colorant,<:Number}) = parent(parent(A))
-    channelview(A::RRPermArray{<:Colorant,<:Number}) = parent(parent(parent(A)))
-end
+channelview(A::RRArray{<:Colorant,<:Number}) = parent(A)
+channelview(A::RRPermArray{<:Colorant,<:Number}) = parent(parent(A))
 channelview(A::Base.ReinterpretArray{<:AbstractGray,M,<:Number}) where M = parent(A)
 channelview(A::AbstractArray{RGB{T}}) where {T} = reinterpretc(T, A)
 function channelview(A::AbstractArray{C}) where {C<:AbstractRGB}
@@ -117,25 +109,14 @@ _ccolorview(::Type{C}, A::RRPermArray{T,C}) where {C<:Colorant,T<:Number} =
     parent(parent(parent(A)))
 _ccolorview(::Type{C}, A::RRArray{T,C}) where {C<:Colorant,T<:Number} =
     parent(parent(A))
-if VERSION >= v"1.6.0-DEV.1083"
-    _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,false}) where {C<:RGB,T<:Number,M,AA} =
-        reshape(parent(A), Base.tail(axes(parent(A))))
-    # _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,true}) where {C<:RGB,T<:Number,M,AA} =
-    #     parent(A)
-    _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,false}) where {C<:Color,T<:Number,M,AA} =
-        reshape(parent(A), Base.tail(axes(parent(A))))
-    # _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,true}) where {C<:Color,T<:Number,M,AA} =
-    #     parent(A)
-else
-    _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C}) where {C<:AbstractGray,T<:Number,M} =
-        parent(A)
-    _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C}) where {C<:RGB,T<:Number,M} =
-        reshape(parent(A), Base.tail(axes(parent(A))))
-    _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C}) where {C<:Color,T<:Number,M} =
-        reshape(parent(A), Base.tail(axes(parent(A))))
-    end
-# _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C}) where {C<:AbstractRGB,T<:Number,M} =
-#     _colorview_reorder(C, A)
+_ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,false}) where {C<:RGB,T<:Number,M,AA} =
+    reshape(parent(A), Base.tail(axes(parent(A))))
+# _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,true}) where {C<:RGB,T<:Number,M,AA} =
+#     parent(A)
+_ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,false}) where {C<:Color,T<:Number,M,AA} =
+    reshape(parent(A), Base.tail(axes(parent(A))))
+# _ccolorview(::Type{C}, A::Base.ReinterpretArray{T,M,C,AA,true}) where {C<:Color,T<:Number,M,AA} =
+#     parent(A)
 _ccolorview(::Type{C}, A::AbstractArray{T}) where {C<:Colorant,T<:Number} =
     __ccolorview(C, A)  # necessary to avoid ambiguities from dispatch on eltype
 __ccolorview(::Type{C}, A::AbstractArray{T}) where {T<:Number,C<:RGB{T}} = reinterpretc(C, A)
@@ -198,7 +179,7 @@ Create a function that is equivalent to `(As...) -> colorview(C, Ax...)`.
 
 ```jldoctest; setup = :(using ImageCore)
 julia> ones(Float32, 2, 2) |> colorview(Gray)
-2×2 reinterpret($(VERSION >= v"1.6.0-DEV.1083" ? "reshape, " : "")Gray{Float32}, ::$(Array{Float32,2}))$(VERSION >= v"1.6.0-DEV.1083" ? " with eltype Gray{Float32}" : ""):
+2×2 reinterpret(reshape, Gray{Float32}, ::$(Array{Float32,2})) with eltype Gray{Float32}:
  Gray{Float32}(1.0)  Gray{Float32}(1.0)
  Gray{Float32}(1.0)  Gray{Float32}(1.0)
 ```
diff --git a/src/convert_reinterpret.jl b/src/convert_reinterpret.jl
index 6ce1cde..c87b8d1 100644
--- a/src/convert_reinterpret.jl
+++ b/src/convert_reinterpret.jl
@@ -2,61 +2,8 @@
 
 @pure samesize(::Type{T}, ::Type{S}) where {T,S} = sizeof(T) == sizeof(S)
 
-if VERSION >= v"1.6.0-DEV.1083"
-    reinterpretc(::Type{T}, a::AbstractArray) where T = reinterpret(reshape, ccolor_number(T, eltype(a)), a)
-    reinterpretc(::Type{T}, a::Base.ReinterpretArray{S,N,T,AA,true}) where {T,S,N,AA<:AbstractArray{T}} = parent(a)
-else
-    # Color->Color
-    function reinterpretc(::Type{CV1}, a::Array{CV2,1}) where {CV1<:Colorant,CV2<:Colorant}
-        CV = ccolor(CV1, CV2)
-        l = (length(a)*sizeof(CV2))÷sizeof(CV1)
-        l*sizeof(CV1) == length(a)*sizeof(CV2) || throw(ArgumentError("sizes are incommensurate"))
-        reshape(reinterpret(CV, a), (l,))
-    end
-    function reinterpretc(::Type{CV1}, a::AbstractArray{CV2}) where {CV1<:Colorant,CV2<:Colorant}
-        CV = ccolor(CV1, CV2)
-        if samesize(CV, CV2)
-            return reshape(reinterpret(CV, a), size(a))
-        end
-        throw(ArgumentError("result shape not specified"))
-    end
-
-    # Color->T
-    function reinterpretc(::Type{T}, a::AbstractArray{CV}) where {T<:Number,CV<:Colorant}
-        if samesize(T, CV)
-            return reinterpret(T, a)
-        end
-        axs = axes(a)
-        if sizeof(CV) == sizeof(T)*_len(CV)
-            return reinterpret(T, reshape(a, Base.OneTo(1), axs...))
-        end
-        throw(ArgumentError("result shape not specified"))
-    end
-    reinterpretc(::Type{T}, a::AbstractArray{CV,0}) where {T<:Number,CV<:Colorant} =
-        reinterpret(T, reshape(a, 1))
-
-    _len(::Type{C}) where {C} = _len(C, eltype(C))
-    _len(::Type{C}, ::Type{Any}) where {C} = error("indeterminate type")
-    _len(::Type{C}, ::Type{T}) where {C,T} = sizeof(C) ÷ sizeof(T)
-
-    ## T->Color
-    # We have to distinguish two forms of call:
-    #   form 1: reinterpretc(RGB{N0f8}, img)
-    #   form 2: reinterpretc(RGB, img)
-    function reinterpretc(CV::Type{<:Colorant}, a::AbstractArray{T}) where T<:Number # {CV<:Colorant,T<:Number}
-        @noinline throwdm(C::Type, ind1) =
-            throw(DimensionMismatch("indices $ind1 are not consistent with color type $C"))
-        CVT = ccolor_number(CV, T)
-        if samesize(CVT, T)
-            return reinterpret(CVT, a)
-        end
-        axs = axes(a)
-        if axs[1] == Base.OneTo(sizeof(CVT) ÷ sizeof(eltype(CVT)))
-            return reshape(reinterpret(CVT, a), tail(axs))
-        end
-        throwdm(CV, axs[1])
-    end
-end
+reinterpretc(::Type{T}, a::AbstractArray) where T = reinterpret(reshape, ccolor_number(T, eltype(a)), a)
+reinterpretc(::Type{T}, a::Base.ReinterpretArray{S,N,T,AA,true}) where {T,S,N,AA<:AbstractArray{T}} = parent(a)
 
 # ccolor_number converts form 2 calls to form 1 calls
 ccolor_number(::Type{T}, ::Any) where T<:Number = T
diff --git a/src/deprecations.jl b/src/deprecations.jl
index e59a676..a03a3b4 100644
--- a/src/deprecations.jl
+++ b/src/deprecations.jl
@@ -1,19 +1,15 @@
 const warned_once = Ref(false)
-if VERSION >= v"1.5"
-    function forced_depwarn(msg, sym)
-        opts = Base.JLOptions()
-        if !warned_once[] && !(opts.depwarn == 1)
-            @warn msg
-            @info """It is recommended that you fix this now to avoid breakage when a new version is released and this warning is removed.
-                     Tip: to see all deprecation warnings together with code locations, launch Julia with `--depwarn=yes` and rerun your code."""
-            warned_once[] = true
-        else
-            Base.depwarn(msg, sym)
-        end
-        return nothing
+function forced_depwarn(msg, sym)
+    opts = Base.JLOptions()
+    if !warned_once[] && !(opts.depwarn == 1)
+        @warn msg
+        @info """It is recommended that you fix this now to avoid breakage when a new version is released and this warning is removed.
+                    Tip: to see all deprecation warnings together with code locations, launch Julia with `--depwarn=yes` and rerun your code."""
+        warned_once[] = true
+    else
+        Base.depwarn(msg, sym)
     end
-else
-    forced_depwarn(msg, sym) = Base.depwarn(msg, sym)
+    return nothing
 end
 
 # a perhaps "permanent" deprecation
diff --git a/src/functions.jl b/src/functions.jl
deleted file mode 100644
index 8e6f553..0000000
--- a/src/functions.jl
+++ /dev/null
@@ -1,20 +0,0 @@
-import AbstractFFTs: fft, rfft, plan_fft, plan_rfft
-
-# It's better not to define fft on Colorant arrays, because keeping
-# track of the color dimension and the fft-dims is prone to omissions
-# or problems due to later operations. So we put the bookkeeping on
-# the user, but we try to give helpful suggestions.
-
-function throw_ffterror(f, x, dims=1:ndims(x))
-    newdims = plus(dims, channelview_dims_offset(x))
-    error("$f not defined for eltype $(eltype(x)). Use channelview, and likely $newdims for the dims in the fft.")
-end
-
-for f in (:fft, :rfft)
-    pf = Symbol("plan_", f)
-    @eval begin
-        $f(x::AbstractArray{C}) where {C<:Colorant} = throw_ffterror($f, x)
-        $f(x::AbstractArray{C}, dims) where {C<:Colorant} = throw_ffterror($f, x, dims)
-        $pf(x::AbstractArray{C}; kws...) where {C<:Colorant} = throw_ffterror($pf, x)
-    end
-end
diff --git a/src/stackedviews.jl b/src/stackedviews.jl
index 93baeb3..c35d3bf 100644
--- a/src/stackedviews.jl
+++ b/src/stackedviews.jl
@@ -102,7 +102,7 @@ struct ZeroArray{T,N,R<:AbstractUnitRange} <: AbstractArray{T,N}
     inds::NTuple{N,R}
 end
 
-ZeroArrayPromise{T}(inds::NTuple{N,R}) where {T,N,R<:AbstractUnitRange} = ZeroArray{T,N,R}(inds)
+ZeroArrayPromise{T}(inds::Tuple{R,Vararg{R,N}}) where {T,N,R<:AbstractUnitRange} = ZeroArray{T,N+1,R}(inds)
 ZeroArrayPromise{T}(inds::NTuple{N,AbstractUnitRange}) where {T,N} = ZeroArrayPromise{T}(promote(inds...))
 Base.eltype(::Type{ZeroArrayPromise{T}}) where {T} = T
 
diff --git a/test/colorchannels.jl b/test/colorchannels.jl
index 7e93e40..77e29fa 100644
--- a/test/colorchannels.jl
+++ b/test/colorchannels.jl
@@ -408,7 +408,7 @@ end
         @test @inferred(axes(v)) == (IdentityUnitRange(-1:1), IdentityUnitRange(-2:2))
         @test @inferred(v[0,0]) === RGB(a[1,0,0], a[2,0,0], a[3,0,0])
         a = OffsetArray(rand(3, 3, 5), 0:2, -1:1, -2:2)
-        @test_throws (VERSION >= v"1.6.0-DEV.1083" ? ArgumentError : DimensionMismatch) colorview(RGB, a)
+        @test_throws ArgumentError colorview(RGB, a)
     end
 
     @testset "Custom/divergent axis types" begin
diff --git a/test/runtests.jl b/test/runtests.jl
index f3a541e..4ab417d 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -11,11 +11,11 @@ using Aqua, Documenter # for meta quality checks
                   ambiguities=false,
                   project_extras=true,
                   deps_compat=true,
-                  stale_deps= v"1.4" <= Base.VERSION < v"1.5", # we don't use AbstractFFTs on 1.5+, SnoopPrecompile on <1.4
+                  stale_deps=true,
                   # FIXME? re-enable the `piracy` test
-                  piracy=false, # Base.VERSION >= v"1.5",    # need the register_error_hint for AbstractFFTs
+                  piracy=false, # currently just `float` and `paddedviews`
                   project_toml_formatting=true,
-                  unbound_args=false, # FIXME: it fails when this is true
+                  unbound_args=true,
     )
     DocMeta.setdocmeta!(ImageCore, :DocTestSetup, :(using ImageCore); recursive=true)
 end
diff --git a/test/show.jl b/test/show.jl
index c521b16..ad8db2d 100644
--- a/test/show.jl
+++ b/test/show.jl
@@ -1,13 +1,9 @@
 using ImageCore, Colors, FixedPointNumbers, OffsetArrays, Test
 
-if VERSION >= v"1.2.0-DEV.229"
-    sumsz(img) = Base.dims2string(size(img)) * ' '
-else
-    sumsz(img) = ""
-end
+sumsz(img) = Base.dims2string(size(img)) * ' '
 
-const rrstr = VERSION >= v"1.6.0-DEV.1083" ? "reshape, " : ""
-rrdim(n) = VERSION >= v"1.6.0-DEV.1083" ? n-1 : n
+const rrstr = "reshape, "
+rrdim(n) = n-1
 
 # N0f8 is shown as either N0f8 or Normed{UInt8, 8}
 # RGB is shown as ColorTypes.RGB or RGB
@@ -25,8 +21,7 @@ RGB_str = typestring(RGB)
     v = view(rgb32, 2:3, :)
     @test summary(v) == "2×5 view(::Array{RGB{Float32},2}, 2:3, :) with eltype $(RGB_str){Float32}"
     a = channelview(rgb32)
-    @test summary(a) == (VERSION >= v"1.6.0-DEV.1083" ? "3×3×5 reinterpret(reshape, Float32, ::Array{RGB{Float32},2}) with eltype Float32" :
-                                                        "3×3×5 reinterpret(Float32, ::Array{RGB{Float32},3})")
+    @test summary(a) == "3×3×5 reinterpret(reshape, Float32, ::Array{RGB{Float32},2}) with eltype Float32"
     num64 = rand(3,5)
     b = colorview(RGB, num64)
     str = summary(b)
@@ -51,11 +46,10 @@ RGB_str = typestring(RGB)
     @test occursin("5×3 PermutedDimsArray(reinterpret", str) && occursin("N0f16", str) &&
           occursin("::$(typeof(rand16))), (2, 1)", str) && occursin("with eltype $(N0f16_str)", str)
     g = channelview(rgb8)
-    etstr = VERSION >= v"1.6.0-DEV.1083" ? " with eltype" : ""
     str = summary(g)
     @test occursin("3×3×5 reinterpret($(rrstr)", str) && occursin("N0f8", str) &&
           occursin("::Array{RGB{N0f8},$(rrdim(3))}", str)
-    VERSION >= v"1.6.0-DEV.1083" && @test occursin("with eltype", str)
+    @test occursin("with eltype", str)
     h = OffsetArray(rgb8, -1:1, -2:2)
     @test summary(h) == "$(sumsz(h))OffsetArray(::Array{RGB{N0f8},2}, -1:1, -2:2) with eltype $(RGB_str){$(N0f8_str)} with indices -1:1×-2:2"
     i = channelview(h)

From 5ebad6c9e1be47d2a4d3f616c5b0b539665ef818 Mon Sep 17 00:00:00 2001
From: Tim Holy <tim.holy@gmail.com>
Date: Sat, 22 Jul 2023 12:52:53 -0500
Subject: [PATCH 12/13] Add NEWS for 0.10

---
 NEWS.md | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/NEWS.md b/NEWS.md
index 0859137..df95579 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,16 @@
+# 0.10.0
+
+## Breaking changes
+
+- `clamp01` has been restricted to `AbstractGray` and `AbstractRGB`, as it did not make sense for colors like `HSV` (#181)
+- Step 3 of [ColorVectorSpace's `abs2` transition has been completed](https://github.com/JuliaGraphics/ColorVectorSpace.jl#abs-and-abs2); users and developers should now replace any `ColorVectorSpace.Future.abs2` calls with `abs2` to prevent breakage when the final step completes.
+
+## Other changes
+
+- AbstractFFTs.jl is no longer a dependency; error hints are now used for `fft` operations on deliberately-unsupported `Colorant` types
+- Graphics.jl is no longer a dependency
+- PrecompileTools.jl is now used for precompilation
+
 # 0.7.0
 
 ## Breaking changes

From 0d7ea6c78a445c2dd749090c8510c62cf3b26fc7 Mon Sep 17 00:00:00 2001
From: Pietro Monticone <38562595+pitmonticone@users.noreply.github.com>
Date: Fri, 4 Aug 2023 04:06:13 -0500
Subject: [PATCH 13/13] Fix typos in docs and docstrings (#197)

---
 docs/src/views.md | 2 +-
 src/ImageCore.jl  | 2 +-
 src/map.jl        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/src/views.md b/docs/src/views.md
index 7bb2f63..2dc793a 100644
--- a/docs/src/views.md
+++ b/docs/src/views.md
@@ -139,7 +139,7 @@ julia> img
  RGB{N0f8}(0.0,0.0,1.0)    RGB{N0f8}(0.0,0.0,0.0)
 ```
 
-The hexidecimal representation of 128 is 0x80; this is approximately
+The hexadecimal representation of 128 is 0x80; this is approximately
 halfway to 255, and as a consequence the `N0f8` representation is
 very near 0.5.  You can see the same change is reflected in `r`, `v`,
 and `img`: there is only one underlying array, `img`, and the two
diff --git a/src/ImageCore.jl b/src/ImageCore.jl
index 76bb1b6..b7f7d02 100644
--- a/src/ImageCore.jl
+++ b/src/ImageCore.jl
@@ -33,7 +33,7 @@ const Color1Array{C<:Color1,N} = AbstractArray{C,N}
 const RRArray{To,From,M,P} = Base.ReinterpretArray{To,M,From,P,true}
 const RGArray = Union{Base.ReinterpretArray{<:AbstractGray,M,<:Number,P}, Base.ReinterpretArray{<:Number,M,<:AbstractGray,P}} where {M,P}
 
-# delibrately not export these constants to enable extensibility for downstream packages
+# Deliberately not export these constants to enable extensibility for downstream packages
 const NumberLike = Union{Number,AbstractGray}
 const Pixel = Union{Number,Colorant}
 const GenericGrayImage{T<:NumberLike,N} = AbstractArray{T,N}
diff --git a/src/map.jl b/src/map.jl
index 7c13253..7c2e798 100644
--- a/src/map.jl
+++ b/src/map.jl
@@ -20,7 +20,7 @@ clamp01(c::Union{TransparentGray,AbstractRGB,TransparentRGB}) = mapc(clamp01, c)
 Restrict values in array to [0, 1], in-place. See also [`clamp01`](@ref).
 """
 function clamp01!(img::AbstractArray)
-    # slgihtly faster than map!(clamp01, img, img)
+    # Slightly faster than map!(clamp01, img, img)
     @inbounds for i in eachindex(img)
         img[i] = clamp01(img[i])
     end