diff --git a/src/Dimensions/dimension.jl b/src/Dimensions/dimension.jl
index 321403980..88ad98283 100644
--- a/src/Dimensions/dimension.jl
+++ b/src/Dimensions/dimension.jl
@@ -32,9 +32,9 @@ A = DimArray(zeros(3, 5, 12), (y, x, ti))
 
 # output
 
-╭────────────────────────────╮
-│ 3×5×12 DimArray{Float64,3} │
-├────────────────────────────┴─────────────────────────────────────────── dims ┐
+╭─────────────────────────────╮
+│ 3×5×12 DimArray{Float64, 3} │
+├─────────────────────────────┴────────────────────────────────────────── dims ┐
   ↓ Y  Categorical{Char} ['a', 'b', 'c'] ForwardOrdered,
   → X  Sampled{Int64} 2:2:10 ForwardOrdered Regular Points,
   ↗ Ti Sampled{Dates.DateTime} Dates.DateTime("2021-01-01T00:00:00"):Dates.Month(1):Dates.DateTime("2021-12-01T00:00:00") ForwardOrdered Regular Points
@@ -54,9 +54,9 @@ x = A[X(2), Y(3)]
 
 # output
 
-╭────────────────────────────────╮
-│ 12-element DimArray{Float64,1} │
-├────────────────────────────────┴─────────────────────────────────────── dims ┐
+╭─────────────────────────────────╮
+│ 12-element DimArray{Float64, 1} │
+├─────────────────────────────────┴────────────────────────────────────── dims ┐
   ↓ Ti Sampled{Dates.DateTime} Dates.DateTime("2021-01-01T00:00:00"):Dates.Month(1):Dates.DateTime("2021-12-01T00:00:00") ForwardOrdered Regular Points
 └──────────────────────────────────────────────────────────────────────────────┘
  2021-01-01T00:00:00  0.0
@@ -80,9 +80,9 @@ x = A[X(Between(3, 4)), Y(At('b'))]
 
 # output
 
-╭──────────────────────────╮
-│ 1×12 DimArray{Float64,2} │
-├──────────────────────────┴───────────────────────────────────────────── dims ┐
+╭───────────────────────────╮
+│ 1×12 DimArray{Float64, 2} │
+├───────────────────────────┴──────────────────────────────────────────── dims ┐
   ↓ X  Sampled{Int64} 4:2:4 ForwardOrdered Regular Points,
   → Ti Sampled{Dates.DateTime} Dates.DateTime("2021-01-01T00:00:00"):Dates.Month(1):Dates.DateTime("2021-12-01T00:00:00") ForwardOrdered Regular Points
 └──────────────────────────────────────────────────────────────────────────────┘
diff --git a/src/Dimensions/primitives.jl b/src/Dimensions/primitives.jl
index bb936f9d2..32159ecdf 100644
--- a/src/Dimensions/primitives.jl
+++ b/src/Dimensions/primitives.jl
@@ -131,11 +131,11 @@ any combination of either.
 julia> using DimensionalData
 
 julia> A = DimArray(ones(2, 3, 2), (X, Y, Z))
-╭───────────────────────────╮
-│ 2×3×2 DimArray{Float64,3} │
-├───────────────────── dims ┤
+╭────────────────────────────╮
+│ 2×3×2 DimArray{Float64, 3} │
+├────────────────────── dims ┤
   ↓ X, → Y, ↗ Z
-└───────────────────────────┘
+└────────────────────────────┘
 [:, :, 1]
  1.0  1.0  1.0
  1.0  1.0  1.0
@@ -364,11 +364,11 @@ A = ones(X(2), Y(4), Z(2))
 Dimensions.swapdims(A, (Dim{:a}, Dim{:b}, Dim{:c}))
 
 # output
-╭───────────────────────────╮
-│ 2×4×2 DimArray{Float64,3} │
-├───────────────────── dims ┤
+╭────────────────────────────╮
+│ 2×4×2 DimArray{Float64, 3} │
+├────────────────────── dims ┤
   ↓ a, → b, ↗ c
-└───────────────────────────┘
+└────────────────────────────┘
 [:, :, 1]
  1.0  1.0  1.0  1.0
  1.0  1.0  1.0  1.0
diff --git a/src/Lookups/lookup_arrays.jl b/src/Lookups/lookup_arrays.jl
index 2d7a0fa18..4d8210a50 100644
--- a/src/Lookups/lookup_arrays.jl
+++ b/src/Lookups/lookup_arrays.jl
@@ -293,9 +293,9 @@ y = Y(Sampled([1, 4, 7, 10]; span=Regular(3), sampling=Intervals(Start())))
 A = ones(x, y)
 
 # output
-╭─────────────────────────╮
-│ 5×4 DimArray{Float64,2} │
-├─────────────────────────┴────────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 5×4 DimArray{Float64, 2} │
+├──────────────────────────┴───────────────────────────────────────── dims ┐
   ↓ X Sampled{Int64} 100:-20:20 ReverseOrdered Regular Intervals{Start},
   → Y Sampled{Int64} [1, 4, 7, 10] ForwardOrdered Regular Intervals{Start}
 └──────────────────────────────────────────────────────────────────────────┘
diff --git a/src/Lookups/selector.jl b/src/Lookups/selector.jl
index 0a4a71088..0f8cbf901 100644
--- a/src/Lookups/selector.jl
+++ b/src/Lookups/selector.jl
@@ -589,9 +589,9 @@ A[X(Between(15, 25)), Y(Between(4, 6.5))]
 
 # output
 
-╭───────────────────────╮
-│ 1×2 DimArray{Int64,2} │
-├───────────────────────┴────────────────────────────── dims ┐
+╭────────────────────────╮
+│ 1×2 DimArray{Int64, 2} │
+├────────────────────────┴───────────────────────────── dims ┐
   ↓ X Sampled{Int64} 20:10:20 ForwardOrdered Regular Points,
   → Y Sampled{Int64} 5:6 ForwardOrdered Regular Points
 └────────────────────────────────────────────────────────────┘
@@ -853,9 +853,9 @@ A = DimArray([1 2 3; 4 5 6], (X(10:10:20), Y(5:7)))
 A[X(Touches(15, 25)), Y(Touches(4, 6.5))]
 
 # output
-╭───────────────────────╮
-│ 1×2 DimArray{Int64,2} │
-├───────────────────────┴────────────────────────────── dims ┐
+╭────────────────────────╮
+│ 1×2 DimArray{Int64, 2} │
+├────────────────────────┴───────────────────────────── dims ┐
   ↓ X Sampled{Int64} 20:10:20 ForwardOrdered Regular Points,
   → Y Sampled{Int64} 5:6 ForwardOrdered Regular Points
 └────────────────────────────────────────────────────────────┘
@@ -1029,9 +1029,9 @@ A[X(Where(x -> x > 15)), Y(Where(x -> x in (19, 21)))]
 
 # output
 
-╭───────────────────────╮
-│ 1×2 DimArray{Int64,2} │
-├───────────────────────┴─────────────────────────────── dims ┐
+╭────────────────────────╮
+│ 1×2 DimArray{Int64, 2} │
+├────────────────────────┴────────────────────────────── dims ┐
   ↓ X Sampled{Int64} [20] ForwardOrdered Irregular Points,
   → Y Sampled{Int64} [19, 21] ForwardOrdered Irregular Points
 └─────────────────────────────────────────────────────────────┘
@@ -1071,9 +1071,9 @@ A[X=All(At(10.0), At(50.0)), Ti=All(1u"s"..10u"s", 90u"s"..100u"s")]
 
 # output
 
-╭───────────────────────╮
-│ 2×4 DimArray{Int64,2} │
-├───────────────────────┴──────────────────────────────────────────────── dims ┐
+╭────────────────────────╮
+│ 2×4 DimArray{Int64, 2} │
+├────────────────────────┴─────────────────────────────────────────────── dims ┐
   ↓ X  Sampled{Float64} [10.0, 50.0] ForwardOrdered Irregular Points,
   → Ti Sampled{Unitful.Quantity{Int64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}} [1 s, 6 s, 91 s, 96 s] ForwardOrdered Irregular Points
 └──────────────────────────────────────────────────────────────────────────────┘
diff --git a/src/array/array.jl b/src/array/array.jl
index 64cf0c20f..df5872902 100644
--- a/src/array/array.jl
+++ b/src/array/array.jl
@@ -396,18 +396,18 @@ julia> x = X(10:10:100);
 julia> A = DimArray(rand(12,10), (ti, x), name="example");
 
 julia> A[X(Near([12, 35])), Ti(At(DateTime(2001,5)))]
-╭───────────────────────────────────────╮
-│ 2-element DimArray{Float64,1} example │
-├───────────────────────────────────────┴─────────────── dims ┐
+╭────────────────────────────────────────╮
+│ 2-element DimArray{Float64, 1} example │
+├────────────────────────────────────────┴────────────── dims ┐
   ↓ X Sampled{Int64} [10, 40] ForwardOrdered Irregular Points
 └─────────────────────────────────────────────────────────────┘
  10  0.253849
  40  0.637077
 
 julia> A[Near(DateTime(2001, 5, 4)), Between(20, 50)]
-╭───────────────────────────────────────╮
-│ 4-element DimArray{Float64,1} example │
-├───────────────────────────────────────┴───────────── dims ┐
+╭────────────────────────────────────────╮
+│ 4-element DimArray{Float64, 1} example │
+├────────────────────────────────────────┴──────────── dims ┐
   ↓ X Sampled{Int64} 20:10:50 ForwardOrdered Regular Points
 └───────────────────────────────────────────────────────────┘
  20  0.774092
@@ -522,11 +522,11 @@ Keywords are the same as for [`DimArray`](@ref).
 julia> using DimensionalData, Random; Random.seed!(123);
 
 julia> fill(true, X(2), Y(4))
-╭──────────────────────╮
-│ 2×4 DimArray{Bool,2} │
-├──────────────── dims ┤
+╭───────────────────────╮
+│ 2×4 DimArray{Bool, 2} │
+├───────────────── dims ┤
   ↓ X, → Y
-└──────────────────────┘
+└───────────────────────┘
  1  1  1  1
  1  1  1  1
 ```
@@ -555,18 +555,18 @@ Keywords are the same as for [`DimArray`](@ref).
 julia> using DimensionalData
 
 julia> rand(Bool, X(2), Y(4))
-╭──────────────────────╮
-│ 2×4 DimArray{Bool,2} │
-├──────────────── dims ┤
+╭───────────────────────╮
+│ 2×4 DimArray{Bool, 2} │
+├───────────────── dims ┤
   ↓ X, → Y
-└──────────────────────┘
+└───────────────────────┘
  0  0  0  0
  1  0  0  1
 
 julia> rand(X([:a, :b, :c]), Y(100.0:50:200.0))
-╭─────────────────────────╮
-│ 3×3 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×3 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────── dims ┐
   ↓ X Categorical{Symbol} [:a, :b, :c] ForwardOrdered,
   → Y Sampled{Float64} 100.0:50.0:200.0 ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────┘
@@ -598,18 +598,18 @@ Keywords are the same as for [`DimArray`](@ref).
 julia> using DimensionalData
 
 julia> zeros(Bool, X(2), Y(4))
-╭──────────────────────╮
-│ 2×4 DimArray{Bool,2} │
-├──────────────── dims ┤
+╭───────────────────────╮
+│ 2×4 DimArray{Bool, 2} │
+├───────────────── dims ┤
   ↓ X, → Y
-└──────────────────────┘
+└───────────────────────┘
  0  0  0  0
  0  0  0  0
 
 julia> zeros(X([:a, :b, :c]), Y(100.0:50:200.0))
-╭─────────────────────────╮
-│ 3×3 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×3 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────── dims ┐
   ↓ X Categorical{Symbol} [:a, :b, :c] ForwardOrdered,
   → Y Sampled{Float64} 100.0:50.0:200.0 ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────┘
@@ -642,18 +642,18 @@ Keywords are the same as for [`DimArray`](@ref).
 julia> using DimensionalData
 
 julia> ones(Bool, X(2), Y(4))
-╭──────────────────────╮
-│ 2×4 DimArray{Bool,2} │
-├──────────────── dims ┤
+╭───────────────────────╮
+│ 2×4 DimArray{Bool, 2} │
+├───────────────── dims ┤
   ↓ X, → Y
-└──────────────────────┘
+└───────────────────────┘
  1  1  1  1
  1  1  1  1
 
 julia> ones(X([:a, :b, :c]), Y(100.0:50:200.0))
-╭─────────────────────────╮
-│ 3×3 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×3 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────── dims ┐
   ↓ X Categorical{Symbol} [:a, :b, :c] ForwardOrdered,
   → Y Sampled{Float64} 100.0:50.0:200.0 ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────┘
diff --git a/src/array/show.jl b/src/array/show.jl
index 373b443c5..b5f099543 100644
--- a/src/array/show.jl
+++ b/src/array/show.jl
@@ -19,7 +19,7 @@ function Base.show(io::IO, mime::MIME"text/plain", A::AbstractBasicDimArray{T,N}
 end
 # Defer simple 2-arg show to the parent array
 Base.show(io::IO, A::AbstractDimArray) = show(io, parent(A))
-    
+
 Base.print_matrix(io::IO, A::AbstractBasicDimArray) =
     Base.print_matrix(io, LazyLabelledPrintMatrix(A))
 
@@ -80,7 +80,7 @@ function show_after(io::IO, mime, A::AbstractBasicDimArray)
     print_array(io, mime, A)
 end
 
-function print_ndims(io, size::Tuple; 
+function print_ndims(io, size::Tuple;
     colors=map(dimcolors, ntuple(identity, length(size)))
 )
     if length(size) > 1
@@ -93,7 +93,7 @@ function print_ndims(io, size::Tuple;
     end
 end
 
-print_type(io, x::AbstractArray{T,N}) where {T,N} = print(io, string(nameof(typeof(x)), "{$T,$N}"))
+print_type(io, x::AbstractArray{T,N}) where {T,N} = print(io, string(nameof(typeof(x)), "{$T, $N}"))
 print_type(io, x) = print(io, string(nameof(typeof(x))))
 
 function print_top(io, mime, A)
@@ -165,8 +165,8 @@ function print_block_top(io, label, prev_width, new_width)
     corner = (new_width > prev_width) ? '┐' : '┤'
     top_line = if new_width > prev_width
         string(
-            '├', '─'^(prev_width), '┴', 
-            '─'^max(0, (new_width - textwidth(label) - 3 - prev_width)), 
+            '├', '─'^(prev_width), '┴',
+            '─'^max(0, (new_width - textwidth(label) - 3 - prev_width)),
             ' ', label, ' ', corner
         )
     else
@@ -179,7 +179,7 @@ function print_block_top(io, label, prev_width, new_width)
 end
 
 function print_block_separator(io, label, prev_width, new_width=prev_width)
-    if new_width > prev_width 
+    if new_width > prev_width
         line = string('├', '─'^max(0, prev_width), '┴', '─'^max(0, new_width - prev_width - textwidth(label) - 3) )
         corner = '┐'
     else
@@ -311,7 +311,7 @@ end
 @propagate_inbounds function Base.getindex(A::LazyLabelledPrintMatrix, i::Integer, j::Integer)
     @boundscheck checkbounds(A, i, j)
     oi = i + firstindex(A.data, 1) - 1
-    if ndims(A.data) == 1 
+    if ndims(A.data) == 1
         if A.rowlabels isa NoLookup
             A.data[oi]
         else
diff --git a/src/dimindices.jl b/src/dimindices.jl
index 45095ed1e..0a80344d6 100644
--- a/src/dimindices.jl
+++ b/src/dimindices.jl
@@ -76,9 +76,9 @@ are not in the same order. Or even if they are not all contained in each.
 
 ```jldoctest; setup = :(using DimensionalData, Random; Random.seed!(123))
 julia> A = rand(Y(0.0:0.3:1.0), X('a':'f'))
-╭─────────────────────────╮
-│ 4×6 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 4×6 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────── dims ┐
   ↓ Y Sampled{Float64} 0.0:0.3:0.9 ForwardOrdered Regular Points,
   → X Categorical{Char} 'a':1:'f' ForwardOrdered
 └─────────────────────────────────────────────────────────────────┘
@@ -89,20 +89,20 @@ julia> A = rand(Y(0.0:0.3:1.0), X('a':'f'))
  0.9  0.512083  0.867547  0.136551   0.959434   0.150155  0.941133
 
 julia> di = DimIndices((X(1:2:4), Y(1:2:4)))
-╭─────────────────────────────────────────────╮
-│ 2×2 DimIndices{Tuple{X{Int64}, Y{Int64}},2} │
-├─────────────────────────────────────── dims ┤
+╭──────────────────────────────────────────────╮
+│ 2×2 DimIndices{Tuple{X{Int64}, Y{Int64}}, 2} │
+├──────────────────────────────────────── dims ┤
   ↓ X 1:2:3,
   → Y 1:2:3
-└─────────────────────────────────────────────┘
+└──────────────────────────────────────────────┘
  ↓ →  1                3
  1     (↓ X 1, → Y 1)   (↓ X 1, → Y 3)
  3     (↓ X 3, → Y 1)   (↓ X 3, → Y 3)
 
 julia> A[di] # Index A with these indices
-╭─────────────────────────╮
-│ 2×2 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 2×2 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────── dims ┐
   ↓ Y Sampled{Float64} 0.0:0.6:0.6 ForwardOrdered Regular Points,
   → X Categorical{Char} 'a':2:'c' ForwardOrdered
 └─────────────────────────────────────────────────────────────────┘
@@ -228,9 +228,9 @@ julia> A = rand(X(1.0:3.0:30.0), Y(1.0:5.0:30.0), Ti(1:2));
 julia> target = rand(X(1.0:10.0:30.0), Y(1.0:10.0:30.0));
 
 julia> A[DimSelectors(target; selectors=Near), Ti=2]
-╭─────────────────────────╮
-│ 3×3 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×3 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────────── dims ┐
   ↓ X Sampled{Float64} [1.0, 10.0, 22.0] ForwardOrdered Irregular Points,
   → Y Sampled{Float64} [1.0, 11.0, 21.0] ForwardOrdered Irregular Points
 └─────────────────────────────────────────────────────────────────────────┘
diff --git a/src/groupby.jl b/src/groupby.jl
index f97ec6ab9..6792f6d32 100644
--- a/src/groupby.jl
+++ b/src/groupby.jl
@@ -275,9 +275,9 @@ And take the mean:
 
 ```jldoctest groupby; setup = :(using Statistics)
 julia> groupmeans = mean.(groups) # Take the monthly mean
-╭────────────────────────────────╮
-│ 12-element DimArray{Float64,1} │
-├────────────────────────────────┴──────────────────────────────── dims ┐
+╭─────────────────────────────────╮
+│ 12-element DimArray{Float64, 1} │
+├─────────────────────────────────┴─────────────────────────────── dims ┐
   ↓ Ti Sampled{Int64} [1, 2, …, 11, 12] ForwardOrdered Irregular Points
 ├───────────────────────────────────────────────────────────── metadata ┤
   Dict{Symbol, Any} with 1 entry:
@@ -305,9 +305,9 @@ Or do something else with Y:
 
 ```jldoctest groupby
 julia> groupmeans = mean.(groupby(A, Ti=>month, Y=>isodd))
-╭──────────────────────────╮
-│ 12×2 DimArray{Float64,2} │
-├──────────────────────────┴─────────────────────────────────────── dims ┐
+╭───────────────────────────╮
+│ 12×2 DimArray{Float64, 2} │
+├───────────────────────────┴────────────────────────────────────── dims ┐
   ↓ Ti Sampled{Int64} [1, 2, …, 11, 12] ForwardOrdered Irregular Points,
   → Y  Sampled{Bool} [false, true] ForwardOrdered Irregular Points
 ├────────────────────────────────────────────────────────────── metadata ┤
diff --git a/src/set.jl b/src/set.jl
index 39eb37428..1c7a2a112 100644
--- a/src/set.jl
+++ b/src/set.jl
@@ -41,9 +41,9 @@ julia> using DimensionalData; const DD = DimensionalData;
 julia> da = DimArray(zeros(3, 4), (custom=10.0:010.0:30.0, Z=-20:010.0:10.0));
 
 julia> set(da, ones(3, 4))
-╭─────────────────────────╮
-│ 3×4 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×4 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────────── dims ┐
   ↓ custom Sampled{Float64} 10.0:10.0:30.0 ForwardOrdered Regular Points,
   → Z      Sampled{Float64} -20.0:10.0:10.0 ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────────┘
@@ -57,9 +57,9 @@ Change the `Dimension` wrapper type:
 
 ```jldoctest set
 julia> set(da, :Z => Ti, :custom => Z)
-╭─────────────────────────╮
-│ 3×4 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×4 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────── dims ┐
   ↓ Z  Sampled{Float64} 10.0:10.0:30.0 ForwardOrdered Regular Points,
   → Ti Sampled{Float64} -20.0:10.0:10.0 ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────┘
@@ -73,9 +73,9 @@ Change the lookup `Vector`:
 
 ```jldoctest set
 julia> set(da, Z => [:a, :b, :c, :d], :custom => [4, 5, 6])
-╭─────────────────────────╮
-│ 3×4 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×4 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────────── dims ┐
   ↓ custom Sampled{Int64} [4, 5, 6] ForwardOrdered Regular Points,
   → Z      Sampled{Symbol} [:a, :b, :c, :d] ForwardOrdered Regular Points
 └─────────────────────────────────────────────────────────────────────────┘
@@ -89,9 +89,9 @@ Change the `Lookup` type:
 
 ```jldoctest set
 julia> set(da, Z=DD.NoLookup(), custom=DD.Sampled())
-╭─────────────────────────╮
-│ 3×4 DimArray{Float64,2} │
-├─────────────────────────┴───────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×4 DimArray{Float64, 2} │
+├──────────────────────────┴──────────────────────────────────────── dims ┐
   ↓ custom Sampled{Float64} 10.0:10.0:30.0 ForwardOrdered Regular Points,
   → Z
 └─────────────────────────────────────────────────────────────────────────┘
@@ -104,9 +104,9 @@ Change the `Sampling` trait:
 
 ```jldoctest set
 julia> set(da, :custom => DD.Irregular(10, 12), Z => DD.Regular(9.9))
-╭─────────────────────────╮
-│ 3×4 DimArray{Float64,2} │
-├─────────────────────────┴─────────────────────────────────────────── dims ┐
+╭──────────────────────────╮
+│ 3×4 DimArray{Float64, 2} │
+├──────────────────────────┴────────────────────────────────────────── dims ┐
   ↓ custom Sampled{Float64} 10.0:10.0:30.0 ForwardOrdered Irregular Points,
   → Z      Sampled{Float64} -20.0:10.0:10.0 ForwardOrdered Regular Points
 └───────────────────────────────────────────────────────────────────────────┘
diff --git a/src/tables.jl b/src/tables.jl
index 626419161..96a127ffa 100644
--- a/src/tables.jl
+++ b/src/tables.jl
@@ -65,11 +65,11 @@ To get dimension columns, you can index with `Dimension` (`X()`) or
 julia> using DimensionalData, Tables
 
 julia> a = DimArray(ones(16, 16, 3), (X, Y, Dim{:band}))
-╭─────────────────────────────╮
-│ 16×16×3 DimArray{Float64,3} │
-├─────────────────────── dims ┤
+╭──────────────────────────────╮
+│ 16×16×3 DimArray{Float64, 3} │
+├──────────────────────── dims ┤
   ↓ X, → Y, ↗ band
-└─────────────────────────────┘
+└──────────────────────────────┘
 [:, :, 1]
  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0  …  1.0  1.0  1.0  1.0  1.0  1.0  1.0
  1.0  1.0  1.0  1.0  1.0  1.0  1.0  1.0     1.0  1.0  1.0  1.0  1.0  1.0  1.0