diff --git a/Project.toml b/Project.toml
index 1e977d8..afdd172 100644
--- a/Project.toml
+++ b/Project.toml
@@ -1,6 +1,6 @@
 name = "DiagonalArrays"
 uuid = "74fd4be6-21e2-4f6f-823a-4360d37c7a77"
-version = "0.3.32"
+version = "0.3.33"
 authors = ["ITensor developers <support@itensor.org> and contributors"]
 
 [workspace]
diff --git a/README.md b/README.md
index 6867869..58bce58 100644
--- a/README.md
+++ b/README.md
@@ -45,7 +45,7 @@ julia> Pkg.add("DiagonalArrays")
 
 ````julia
 using DiagonalArrays:
-    DiagonalArray, DiagonalMatrix, DiagIndex, DiagIndices, diaglength, isdiagindex
+    DiagIndex, DiagIndices, DiagonalArray, DiagonalMatrix, diaglength, isdiagindex
 using Test: @test
 
 function main()
diff --git a/benchmark/benchmarks.jl b/benchmark/benchmarks.jl
index 310c132..b0b75c7 100644
--- a/benchmark/benchmarks.jl
+++ b/benchmark/benchmarks.jl
@@ -1,5 +1,5 @@
-using DiagonalArrays
 using BenchmarkTools
+using DiagonalArrays
 
 SUITE = BenchmarkGroup()
 SUITE["rand"] = @benchmarkable rand(10)
diff --git a/docs/make.jl b/docs/make.jl
index da641ab..56df60a 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -1,7 +1,12 @@
 using DiagonalArrays: DiagonalArrays
 using Documenter: Documenter, DocMeta, deploydocs, makedocs
 
-DocMeta.setdocmeta!(DiagonalArrays, :DocTestSetup, :(using DiagonalArrays); recursive = true)
+DocMeta.setdocmeta!(
+    DiagonalArrays,
+    :DocTestSetup,
+    :(using DiagonalArrays);
+    recursive = true
+)
 
 include("make_index.jl")
 
@@ -12,9 +17,9 @@ makedocs(;
     format = Documenter.HTML(;
         canonical = "https://itensor.github.io/DiagonalArrays.jl",
         edit_link = "main",
-        assets = ["assets/favicon.ico", "assets/extras.css"],
+        assets = ["assets/favicon.ico", "assets/extras.css"]
     ),
-    pages = ["Home" => "index.md", "Reference" => "reference.md"],
+    pages = ["Home" => "index.md", "Reference" => "reference.md"]
 )
 
 deploydocs(;
diff --git a/docs/make_index.jl b/docs/make_index.jl
index 2b7321b..e22cd1d 100644
--- a/docs/make_index.jl
+++ b/docs/make_index.jl
@@ -1,5 +1,5 @@
-using Literate: Literate
 using DiagonalArrays: DiagonalArrays
+using Literate: Literate
 
 function ccq_logo(content)
     include_ccq_logo = """
@@ -17,5 +17,5 @@ Literate.markdown(
     joinpath(pkgdir(DiagonalArrays), "docs", "src");
     flavor = Literate.DocumenterFlavor(),
     name = "index",
-    postprocess = ccq_logo,
+    postprocess = ccq_logo
 )
diff --git a/docs/make_readme.jl b/docs/make_readme.jl
index 8309caa..e242dc6 100644
--- a/docs/make_readme.jl
+++ b/docs/make_readme.jl
@@ -1,5 +1,5 @@
-using Literate: Literate
 using DiagonalArrays: DiagonalArrays
+using Literate: Literate
 
 function ccq_logo(content)
     include_ccq_logo = """
@@ -17,5 +17,5 @@ Literate.markdown(
     joinpath(pkgdir(DiagonalArrays));
     flavor = Literate.CommonMarkFlavor(),
     name = "README",
-    postprocess = ccq_logo,
+    postprocess = ccq_logo
 )
diff --git a/examples/README.jl b/examples/README.jl
index bb6efdc..f6481bb 100644
--- a/examples/README.jl
+++ b/examples/README.jl
@@ -46,7 +46,7 @@ julia> Pkg.add("DiagonalArrays")
 # ## Examples
 
 using DiagonalArrays:
-    DiagonalArray, DiagonalMatrix, DiagIndex, DiagIndices, diaglength, isdiagindex
+    DiagIndex, DiagIndices, DiagonalArray, DiagonalMatrix, diaglength, isdiagindex
 using Test: @test
 
 function main()
diff --git a/ext/DiagonalArraysMatrixAlgebraKitExt/DiagonalArraysMatrixAlgebraKitExt.jl b/ext/DiagonalArraysMatrixAlgebraKitExt/DiagonalArraysMatrixAlgebraKitExt.jl
index e0bbed4..3bedbcb 100644
--- a/ext/DiagonalArraysMatrixAlgebraKitExt/DiagonalArraysMatrixAlgebraKitExt.jl
+++ b/ext/DiagonalArraysMatrixAlgebraKitExt/DiagonalArraysMatrixAlgebraKitExt.jl
@@ -1,54 +1,14 @@
 module DiagonalArraysMatrixAlgebraKitExt
 
-using DiagonalArrays:
-    AbstractDiagonalMatrix,
-    DeltaMatrix,
-    DiagonalMatrix,
-    ScaledDeltaMatrix,
-    δ,
-    diagview,
-    dual,
-    issquare
+using DiagonalArrays: AbstractDiagonalMatrix, DeltaMatrix, DiagonalMatrix,
+    ScaledDeltaMatrix, diagview, dual, issquare, δ
 using LinearAlgebra: LinearAlgebra, isdiag, ishermitian
-using MatrixAlgebraKit:
-    MatrixAlgebraKit,
-    AbstractAlgorithm,
-    check_input,
-    default_qr_algorithm,
-    eig_full,
-    eig_full!,
-    eig_vals,
-    eig_vals!,
-    eigh_full,
-    eigh_full!,
-    eigh_vals,
-    eigh_vals!,
-    left_null,
-    left_null!,
-    left_orth,
-    left_orth!,
-    left_polar,
-    left_polar!,
-    lq_compact,
-    lq_compact!,
-    lq_full,
-    lq_full!,
-    qr_compact,
-    qr_compact!,
-    qr_full,
-    qr_full!,
-    right_null,
-    right_null!,
-    right_orth,
-    right_orth!,
-    right_polar,
-    right_polar!,
-    svd_compact,
-    svd_compact!,
-    svd_full,
-    svd_full!,
-    svd_vals,
-    svd_vals!
+using MatrixAlgebraKit: MatrixAlgebraKit, AbstractAlgorithm, check_input,
+    default_qr_algorithm, eig_full, eig_full!, eig_vals, eig_vals!, eigh_full, eigh_full!,
+    eigh_vals, eigh_vals!, left_null, left_null!, left_orth, left_orth!, left_polar,
+    left_polar!, lq_compact, lq_compact!, lq_full, lq_full!, qr_compact, qr_compact!,
+    qr_full, qr_full!, right_null, right_null!, right_orth, right_orth!, right_polar,
+    right_polar!, svd_compact, svd_compact!, svd_full, svd_full!, svd_vals, svd_vals!
 
 abstract type AbstractDiagonalAlgorithm <: AbstractAlgorithm end
 
diff --git a/ext/DiagonalArraysNamedDimsArraysExt/DiagonalArraysNamedDimsArraysExt.jl b/ext/DiagonalArraysNamedDimsArraysExt/DiagonalArraysNamedDimsArraysExt.jl
index bc423d9..8c73750 100644
--- a/ext/DiagonalArraysNamedDimsArraysExt/DiagonalArraysNamedDimsArraysExt.jl
+++ b/ext/DiagonalArraysNamedDimsArraysExt/DiagonalArraysNamedDimsArraysExt.jl
@@ -1,18 +1,18 @@
 module DiagonalArraysNamedDimsArraysExt
 
-using DiagonalArrays: DiagonalArrays, δ, delta
+using DiagonalArrays: DiagonalArrays, delta, δ
 using NamedDimsArrays: AbstractNamedUnitRange, denamed, name, nameddims
 
 function DiagonalArrays.delta(
         elt::Type{<:Number},
-        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}},
+        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}}
     )
     return nameddims(delta(elt, length.(denamed.(is))), name.(is))
 end
 # TODO: Make `δ` an alias for `delta` so this isn't needed.
 function DiagonalArrays.δ(
         elt::Type{<:Number},
-        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}},
+        is::Tuple{AbstractNamedUnitRange, Vararg{AbstractNamedUnitRange}}
     )
     return delta(elt, is)
 end
diff --git a/src/abstractdiagonalarray/diagonalarraydiaginterface.jl b/src/abstractdiagonalarray/diagonalarraydiaginterface.jl
index f35404b..af2b090 100644
--- a/src/abstractdiagonalarray/diagonalarraydiaginterface.jl
+++ b/src/abstractdiagonalarray/diagonalarraydiaginterface.jl
@@ -5,7 +5,8 @@ diagview(a::AbstractDiagonalArray) = throw(MethodError(diagview, Tuple{typeof(a)
 using FunctionImplementations: FunctionImplementations
 using SparseArraysBase: SparseArraysBase as SA, AbstractSparseArrayImplementationStyle
 
-abstract type AbstractDiagonalArrayImplementationStyle <: AbstractSparseArrayImplementationStyle end
+abstract type AbstractDiagonalArrayImplementationStyle <:
+AbstractSparseArrayImplementationStyle end
 
 struct DiagonalArrayImplementationStyle <: AbstractDiagonalArrayImplementationStyle end
 const diag_style = DiagonalArrayImplementationStyle()
@@ -119,7 +120,7 @@ using MapBroadcast: Mapped
 function broadcasted_diagview(bc::Broadcasted)
     m = Mapped(bc)
     iszero(m.f(map(zero ∘ eltype, m.args)...)) || error(
-        "Broadcasting DiagonalArrays with function that doesn't preserve zeros isn't supported yet.",
+        "Broadcasting DiagonalArrays with function that doesn't preserve zeros isn't supported yet."
     )
     return broadcasted(m.f, map(diagview, m.args)...)
 end
diff --git a/src/diagonalarray/delta.jl b/src/diagonalarray/delta.jl
index 77093b6..5f9161e 100644
--- a/src/diagonalarray/delta.jl
+++ b/src/diagonalarray/delta.jl
@@ -1,12 +1,15 @@
 using FillArrays: AbstractFillVector, Ones, OnesVector
 
-const ScaledDelta{T, N, Diag <: AbstractFillVector{T}, Unstored <: AbstractArray{T, N}} = DiagonalArray{
+const ScaledDelta{T, N, Diag <: AbstractFillVector{T}, Unstored <: AbstractArray{T, N}} =
+    DiagonalArray{
     T, N, Diag, Unstored,
 }
-const ScaledDeltaVector{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractVector{T}} = DiagonalVector{
+const ScaledDeltaVector{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractVector{T}} =
+    DiagonalVector{
     T, Diag, Unstored,
 }
-const ScaledDeltaMatrix{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractMatrix{T}} = DiagonalMatrix{
+const ScaledDeltaMatrix{T, Diag <: AbstractFillVector{T}, Unstored <: AbstractMatrix{T}} =
+    DiagonalMatrix{
     T, Diag, Unstored,
 }
 
@@ -45,16 +48,24 @@ function Delta{T}(ax::Tuple{}) where {T}
 end
 
 function delta(
-        elt::Type, ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+        elt::Type, ax::Tuple{
+            AbstractUnitRange{<:Integer},
+            Vararg{AbstractUnitRange{<:Integer}},
+        }
     )
     return Delta{elt}(ax)
 end
 function δ(
-        elt::Type, ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+        elt::Type, ax::Tuple{
+            AbstractUnitRange{<:Integer},
+            Vararg{AbstractUnitRange{<:Integer}},
+        }
     )
     return delta(elt, ax)
 end
-function delta(ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}})
+function delta(
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
+    )
     return delta(Float64, ax)
 end
 function δ(ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}})
diff --git a/src/diagonalarray/diagonalarray.jl b/src/diagonalarray/diagonalarray.jl
index 1764b8b..b8fba68 100644
--- a/src/diagonalarray/diagonalarray.jl
+++ b/src/diagonalarray/diagonalarray.jl
@@ -128,7 +128,7 @@ end
 # Constructor from diagonal entries accepting axes.
 function DiagonalArray{T, N}(
         diag::AbstractVector,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     N == length(ax) || throw(ArgumentError("Wrong number of axes"))
     return DiagonalArray(convert(AbstractVector{T}, diag), Unstored(Zeros{T}(ax)))
@@ -136,33 +136,33 @@ end
 function DiagonalArray{T, N}(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T, N}
     return DiagonalArray{T, N}(diag, (ax1, axs...))
 end
 function DiagonalArray{T}(
         diag::AbstractVector,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(diag, ax)
 end
 function DiagonalArray{T}(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T}
     return DiagonalArray{T}(diag, (ax1, axs...))
 end
 function DiagonalArray(
         diag::AbstractVector{T},
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(diag, ax)
 end
 function DiagonalArray(
         diag::AbstractVector,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     )
     return DiagonalArray(diag, (ax1, axs...))
 end
@@ -170,27 +170,27 @@ end
 # undef constructors accepting axes.
 function DiagonalArray{T, N}(
         ::UndefInitializer,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     return DiagonalArray{T, N}(Vector{T}(undef, minimum(length, ax)), ax)
 end
 function DiagonalArray{T, N}(
         ::UndefInitializer,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T, N}
     return DiagonalArray{T, N}(undef, (ax1, axs...))
 end
 function DiagonalArray{T}(
         ::UndefInitializer,
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T}
     return DiagonalArray{T, length(ax)}(undef, ax)
 end
 function DiagonalArray{T}(
         ::UndefInitializer,
         ax1::AbstractUnitRange{<:Integer},
-        axs::AbstractUnitRange{<:Integer}...,
+        axs::AbstractUnitRange{<:Integer}...
     ) where {T}
     return DiagonalArray{T}(undef, (ax1, axs...))
 end
@@ -221,7 +221,7 @@ end
 
 function DiagonalArray{<:Any, N}(
         diag::AbstractVector{T},
-        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}},
+        ax::Tuple{AbstractUnitRange{<:Integer}, Vararg{AbstractUnitRange{<:Integer}}}
     ) where {T, N}
     return DiagonalArray{T, N}(diag, ax)
 end
diff --git a/src/diagonalarray/diagonalmatrix.jl b/src/diagonalarray/diagonalmatrix.jl
index dddb1fa..8cda0bc 100644
--- a/src/diagonalarray/diagonalmatrix.jl
+++ b/src/diagonalarray/diagonalmatrix.jl
@@ -1,4 +1,5 @@
-const DiagonalMatrix{T, Diag <: AbstractVector{T}, Unstored <: AbstractMatrix{T}} = DiagonalArray{
+const DiagonalMatrix{T, Diag <: AbstractVector{T}, Unstored <: AbstractMatrix{T}} =
+    DiagonalArray{
     T, 2, Diag, Unstored,
 }
 
@@ -11,7 +12,7 @@ function mul_diagviews(a1, a2)
     dual(axes(a1, 2)) == axes(a2, 1) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a1)) and $(axes(a2))"
-        ),
+        )
     )
     d1 = diagview(a1)
     d2 = diagview(a2)
@@ -25,12 +26,12 @@ function mul!_diagviews(a_dest, a1, a2)
     axes(a_dest, 1) == axes(a1, 1) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a_dest)) and $(axes(a1))"
-        ),
+        )
     )
     axes(a_dest, 2) == axes(a2, 2) || throw(
         DimensionMismatch(
             lazy"Incompatible dimensions for multiplication: $(axes(a_dest)) and $(axes(a2))"
-        ),
+        )
     )
     d_dest = diagview(a_dest)
     d1, d2 = mul_diagviews(a1, a2)
diff --git a/src/diagonalarray/diagonalvector.jl b/src/diagonalarray/diagonalvector.jl
index e1d51ab..1b8dcd0 100644
--- a/src/diagonalarray/diagonalvector.jl
+++ b/src/diagonalarray/diagonalvector.jl
@@ -1,4 +1,5 @@
-const DiagonalVector{T, Diag <: AbstractVector{T}, Unstored <: AbstractVector{T}} = DiagonalArray{
+const DiagonalVector{T, Diag <: AbstractVector{T}, Unstored <: AbstractVector{T}} =
+    DiagonalArray{
     T, 1, Diag, Unstored,
 }
 
diff --git a/test/runtests.jl b/test/runtests.jl
index 39c332d..9786268 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -10,14 +10,19 @@ const GROUP = uppercase(
         get(ENV, "GROUP", "ALL")
     else
         only(match(pat, ARGS[arg_id]).captures)
-    end,
+    end
 )
 
-"match files of the form `test_*.jl`, but exclude `*setup*.jl`"
+"""
+match files of the form `test_*.jl`, but exclude `*setup*.jl`
+"""
 function istestfile(fn)
-    return endswith(fn, ".jl") && startswith(basename(fn), "test_") && !contains(fn, "setup")
+    return endswith(fn, ".jl") && startswith(basename(fn), "test_") &&
+        !contains(fn, "setup")
 end
-"match files of the form `*.jl`, but exclude `*_notest.jl` and `*setup*.jl`"
+"""
+match files of the form `*.jl`, but exclude `*_notest.jl` and `*setup*.jl`
+"""
 function isexamplefile(fn)
     return endswith(fn, ".jl") && !endswith(fn, "_notest.jl") && !contains(fn, "setup")
 end
@@ -26,7 +31,8 @@ end
     # tests in groups based on folder structure
     for testgroup in filter(isdir, readdir(@__DIR__))
         if GROUP == "ALL" || GROUP == uppercase(testgroup)
-            for file in filter(istestfile, readdir(joinpath(@__DIR__, testgroup); join = true))
+            for file in
+                filter(istestfile, readdir(joinpath(@__DIR__, testgroup); join = true))
                 @eval @safetestset $file begin
                     include($file)
                 end
@@ -55,7 +61,7 @@ end
                             :macrocall,
                             GlobalRef(Suppressor, Symbol("@suppress")),
                             LineNumberNode(@__LINE__, @__FILE__),
-                            :(include($filename)),
+                            :(include($filename))
                         )
                     )
                 end
diff --git a/test/test_aqua.jl b/test/test_aqua.jl
index ae8789b..77bab8f 100644
--- a/test/test_aqua.jl
+++ b/test/test_aqua.jl
@@ -1,5 +1,5 @@
-using DiagonalArrays: DiagonalArrays
 using Aqua: Aqua
+using DiagonalArrays: DiagonalArrays
 using Test: @testset
 
 @testset "Code quality (Aqua.jl)" begin
diff --git a/test/test_basics.jl b/test/test_basics.jl
index 13b201d..92cf330 100644
--- a/test/test_basics.jl
+++ b/test/test_basics.jl
@@ -1,27 +1,12 @@
-using DiagonalArrays:
-    DiagonalArrays,
-    ShapeInitializer,
-    Delta,
-    DeltaMatrix,
-    DiagonalArray,
-    DiagonalMatrix,
-    ScaledDelta,
-    ScaledDeltaMatrix,
-    Unstored,
-    δ,
-    delta,
-    diagindices,
-    diaglength,
-    diagonal,
-    diagonaltype,
-    diagview,
-    getdiagindices
+using DiagonalArrays: DiagonalArrays, Delta, DeltaMatrix, DiagonalArray, DiagonalMatrix,
+    ScaledDelta, ScaledDeltaMatrix, ShapeInitializer, Unstored, delta, diagindices,
+    diaglength, diagonal, diagonaltype, diagview, getdiagindices, δ
 using FillArrays: Fill, Ones, Zeros
 using FunctionImplementations: permuteddims
 using LinearAlgebra:
     Diagonal, det, ishermitian, isposdef, issymmetric, logdet, mul!, pinv, tr
 using SparseArraysBase: SparseArrayDOK, SparseMatrixDOK, sparsezeros, storedlength
-using Test: @test, @test_throws, @testset, @test_broken, @inferred
+using Test: @inferred, @test, @test_broken, @test_throws, @testset
 
 @testset "Test DiagonalArrays" begin
     @testset "DiagonalArray (eltype=$elt)" for elt in (
@@ -60,12 +45,14 @@ using Test: @test, @test_throws, @testset, @test_broken, @inferred
 
             for a in (randn(elt, (3, 3)), randn(elt, (3, 4)))
                 @test diagindices(a) == diagindices(IndexLinear(), a) == 1:4:9
-                @test diagindices(IndexCartesian(), a) == CartesianIndex.(Iterators.zip(1:3, 1:3))
+                @test diagindices(IndexCartesian(), a) ==
+                    CartesianIndex.(Iterators.zip(1:3, 1:3))
             end
 
             a = randn(elt, (4, 3))
             @test diagindices(a) == diagindices(IndexLinear(), a) == 1:5:11
-            @test diagindices(IndexCartesian(), a) == CartesianIndex.(Iterators.zip(1:3, 1:3))
+            @test diagindices(IndexCartesian(), a) ==
+                CartesianIndex.(Iterators.zip(1:3, 1:3))
 
             for a in (randn(elt, (3, 3, 3)), randn(elt, (3, 3, 4)))
                 @test diagindices(a) == diagindices(IndexLinear(), a) == 1:13:27
@@ -118,16 +105,28 @@ using Test: @test, @test_throws, @testset, @test_broken, @inferred
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}}(init, Base.OneTo.((2, 2))...) ≡
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}}(init, (2, 2)) ≡
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}}(init, 2, 2) ≡
-                DiagonalMatrix{UInt32, Base.OneTo{UInt32}}(init, Unstored(Zeros{UInt32}(2, 2))) ≡
+                DiagonalMatrix{UInt32, Base.OneTo{UInt32}}(
+                    init,
+                    Unstored(Zeros{UInt32}(2, 2))
+                ) ≡
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(init, Base.OneTo.((2, 2))) ≡
-                DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(init, Base.OneTo.((2, 2))...) ≡
+                DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(
+                    init,
+                    Base.OneTo.((2, 2))...
+                ) ≡
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(init, (2, 2)) ≡
                 DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(init, 2, 2) ≡
-                DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(init, Unstored(Zeros{UInt32}(2, 2)))
+                DiagonalMatrix{UInt32, Base.OneTo{UInt32}, U}(
+                    init,
+                    Unstored(Zeros{UInt32}(2, 2))
+                )
 
             init = ShapeInitializer()
             @test DiagonalMatrix(Ones{elt}(2)) ≡
-                DiagonalMatrix{elt, Ones{elt, 1, Tuple{Base.OneTo{Int}}}}(init, Base.OneTo.((2, 2))) ≡
+                DiagonalMatrix{elt, Ones{elt, 1, Tuple{Base.OneTo{Int}}}}(
+                    init,
+                    Base.OneTo.((2, 2))
+                ) ≡
                 DiagonalMatrix{elt, Ones{elt, 1, Tuple{Base.OneTo{Int}}}}(
                     init, Base.OneTo.((2, 2))...
                 ) ≡
@@ -138,7 +137,10 @@ using Test: @test, @test_throws, @testset, @test_broken, @inferred
                 )
 
             init = ShapeInitializer()
-            @test_throws ErrorException DiagonalMatrix{elt, Vector{elt}}(init, Base.OneTo.((2, 2)))
+            @test_throws ErrorException DiagonalMatrix{elt, Vector{elt}}(
+                init,
+                Base.OneTo.((2, 2))
+            )
             @test_throws ErrorException DiagonalMatrix{elt, Vector{elt}}(
                 init, Base.OneTo.((2, 2))...
             )
@@ -168,7 +170,10 @@ using Test: @test, @test_throws, @testset, @test_broken, @inferred
             @test DiagonalArray{<:Any, 0}(Base.OneTo(UInt32(1))) ≡
                 DiagonalArray{UInt32, 0, Base.OneTo{UInt32}}(init, ()) ≡
                 DiagonalArray{UInt32, 0, Base.OneTo{UInt32}}(init) ≡
-                DiagonalArray{UInt32, 0, Base.OneTo{UInt32}}(init, Unstored(Zeros{UInt32}()))
+                DiagonalArray{UInt32, 0, Base.OneTo{UInt32}}(
+                    init,
+                    Unstored(Zeros{UInt32}())
+                )
         end
         @testset "0-dim operations" begin
             diag = randn(elt, 1)
diff --git a/test/test_matrixalgebrakit.jl b/test/test_matrixalgebrakit.jl
index 16241e3..3469772 100644
--- a/test/test_matrixalgebrakit.jl
+++ b/test/test_matrixalgebrakit.jl
@@ -1,24 +1,11 @@
-using Test: @test, @testset
-using LinearAlgebra: Diagonal
-using DiagonalArrays: DiagonalArrays, DeltaMatrix, ScaledDeltaMatrix, δ, dual
+using DiagonalArrays: DiagonalArrays, DeltaMatrix, ScaledDeltaMatrix, dual, δ
 using FillArrays: Ones
-using MatrixAlgebraKit:
-    eig_full,
-    eig_vals,
-    eigh_full,
-    eigh_vals,
-    left_orth,
-    left_polar,
-    lq_compact,
-    lq_full,
-    qr_compact,
-    qr_full,
-    right_orth,
-    right_polar,
-    svd_compact,
-    svd_full,
-    svd_vals
+using LinearAlgebra: Diagonal
+using MatrixAlgebraKit: eig_full, eig_vals, eigh_full, eigh_vals, left_orth, left_polar,
+    lq_compact, lq_full, qr_compact, qr_full, right_orth, right_polar, svd_compact,
+    svd_full, svd_vals
 using StableRNGs: StableRNG
+using Test: @test, @testset
 
 struct SU2 <: AbstractUnitRange{Int}
     j::Int
diff --git a/test/test_nameddimsarraysext.jl b/test/test_nameddimsarraysext.jl
index df1157c..66674d4 100644
--- a/test/test_nameddimsarraysext.jl
+++ b/test/test_nameddimsarraysext.jl
@@ -1,11 +1,12 @@
 using Adapt: adapt
-using DiagonalArrays: DiagonalArray, δ, delta, diagview
+using DiagonalArrays: DiagonalArray, delta, diagview, δ
 using JLArrays: JLArray
-using NamedDimsArrays: denamed, nameddims, namedoneto, inds
+using NamedDimsArrays: denamed, inds, nameddims, namedoneto
 using SparseArraysBase: dense
 using Test: @test, @test_broken, @testset
 
-@testset "NamedDimsArrayExt (eltype=$elt, arraytype=$arrayt)" for elt in (Float64, ComplexF64),
+@testset "NamedDimsArrayExt (eltype=$elt, arraytype=$arrayt)" for elt in
+        (Float64, ComplexF64),
         arrayt in (Array, JLArray)
 
     dev = adapt(arrayt)