1.25.11

Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>

.github/workflows/SnoopCompile.yml

@@ -25,7 +25,7 @@ jobs:
         version:   # NOTE: the versions below should match those in your botconfig
           - '1.6'       # ⎤
           - '1.7'       # |
-          - 'nightly'   # ⎦ <<< keep these versions in sync with deps/SnoopCompile/snoop_bot_config.jl
+          # - 'nightly'   # ⎦ <<< keep these versions in sync with deps/SnoopCompile/snoop_bot_config.jl
           # ^^^^^^^^^ for 'nightly', see github.com/JuliaPlots/Plots.jl/issues/4079
         os:        # NOTE: should match the os setting of your botconfig
           - ubuntu-latest

.github/workflows/format_check.yml

@@ -32,7 +32,6 @@ jobs:
           if out == ""
               exit(0)
           else
-              @error "Some files have not been formatted !!!"
-              write(stdout, out)
+              @error "These files have not been formatted:\n$out"
               exit(1)
           end'

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.25.8"
+version = "1.25.11"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -39,12 +39,12 @@ Unzip = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d"
 Contour = "0.5"
 FFMPEG = "0.2 - 0.4"
 FixedPointNumbers = "0.6 - 0.8"
-GR = "0.63"
+GR = "0.64"
 GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
 Measures = "0.3"
-NaNMath = "0.3"
+NaNMath = "0.3, 1"
 PlotThemes = "2"
 PlotUtils = "1"
 RecipesBase = "1.2"

deps/SnoopCompile/precompile/1.6/precompile_Plots.jl

@@ -66,14 +66,11 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
@@ -85,6 +82,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
@@ -121,7 +119,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
@@ -178,6 +175,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
@@ -217,6 +215,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.is_subplot_attribute),Plot{GRBackend},Symbol})
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
@@ -232,6 +231,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -255,10 +255,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
+    Base.precompile(Tuple{typeof(fakedata),MersenneTwister,Int64,Vararg{Int64, N} where N})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
     Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
@@ -292,16 +292,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
+    Base.precompile(Tuple{typeof(iter_segments),Vector{Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Int64},Symbol,Bool})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -320,6 +316,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
@@ -341,7 +338,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#297#333")) && Base.precompile(Tuple{getfield(Plots, Symbol("#297#333"))})
+    isdefined(Plots, Symbol("#170#171")) && Base.precompile(Tuple{getfield(Plots, Symbol("#170#171")),Any})
+    isdefined(Plots, Symbol("#320#356")) && Base.precompile(Tuple{getfield(Plots, Symbol("#320#356"))})
     isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
@@ -374,5 +372,10 @@ end
     if !ismissing(fbody)
         precompile(fbody, (Any,typeof(title!),AbstractString,))
     end
+end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
+    end
 end
 end

deps/SnoopCompile/precompile/1.7/precompile_Plots.jl

@@ -74,12 +74,14 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -87,7 +89,11 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
@@ -99,12 +105,17 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(lens!)),Any,typeof(lens!),Any,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Vector{Int64},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
@@ -119,6 +130,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
@@ -147,6 +159,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :legend, :seriestype), Tuple{String, Symbol, Symbol}},typeof(plot),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{Matrix{Any}, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
@@ -215,6 +228,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hspan}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
@@ -222,6 +236,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
@@ -229,6 +244,10 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{GRBackend},Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
@@ -242,6 +261,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
     Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -268,6 +288,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
+    Base.precompile(Tuple{typeof(fakedata),TaskLocalRNG,Int64,Vararg{Int64}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
@@ -286,22 +307,25 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
     Base.precompile(Tuple{typeof(gr_get_3d_axis_angle),Vector{Float64},Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
@@ -311,14 +335,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64, Int64}})
@@ -337,6 +359,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
@@ -349,57 +372,72 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Tuple{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
     Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
+    Base.precompile(Tuple{typeof(quiver_using_hack),DefaultsDict})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any}})
     Base.precompile(Tuple{typeof(title!),AbstractString})
+    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
+    isdefined(Plots, Symbol("#172#173")) && Base.precompile(Tuple{getfield(Plots, Symbol("#172#173")),Any})
+    isdefined(Plots, Symbol("#174#175")) && Base.precompile(Tuple{getfield(Plots, Symbol("#174#175")),Any})
+    isdefined(Plots, Symbol("#326#362")) && Base.precompile(Tuple{getfield(Plots, Symbol("#326#362"))})
     isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#104")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#104")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#105")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#105")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
     let fbody = try __lookup_kwbody__(which(annotate!, (AbstractVector{<:Tuple},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(annotate!),AbstractVector{<:Tuple},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Any,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(title!),AbstractString,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(yaxis!),Any,Vararg{Any},))
-        end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(annotate!),AbstractVector{<:Tuple},))
     end
+end
+    let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Any,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(title!),AbstractString,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(yaxis!),Any,Vararg{Any},))
+    end
+end
 end

deps/SnoopCompile/precompile/1.8/precompile_Plots.jl

@@ -15,7 +15,10 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
@@ -28,16 +31,21 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(lens!)),Any,typeof(lens!),Any,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
@@ -65,7 +73,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
@@ -73,6 +81,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, String, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@@ -156,16 +165,19 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.slice_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}},String})
+    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
+    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
     Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
     Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
     Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
     Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
@@ -176,6 +188,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(annotate!),AbstractVector{<:Tuple}})
     Base.precompile(Tuple{typeof(axis_limits),Subplot{GRBackend},Symbol,Bool,Bool})
     Base.precompile(Tuple{typeof(axis_limits),Subplot{PlotlyBackend},Symbol,Bool,Bool})
+    Base.precompile(Tuple{typeof(backend),PlotlyBackend})
     Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
@@ -202,11 +215,11 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64},Int64,Int64})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
@@ -222,15 +235,16 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
     Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
     Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
     Base.precompile(Tuple{typeof(is_marker_supported),GRBackend,Vector{Symbol}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
     Base.precompile(Tuple{typeof(link_axes!),GridLayout,Symbol})
+    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -241,12 +255,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot}})
     Base.precompile(Tuple{typeof(plot),Any,Any})
     Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
     Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Int64})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText,Font})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol},Font})
@@ -260,10 +274,17 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String},Font})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},String,Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64}},Tuple{Int64, Int64},Tuple{Float64, Int64}})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(title!),AbstractString})

src/args.jl

@@ -1059,13 +1059,13 @@ end
 
 """
 `default(key)` returns the current default value for that key.
-    
+
 `default(key, value)` sets the current default value for that key.
-    
+
 `default(; kw...)` will set the current default value for each key/value pair.
-    
+
 `default(plotattributes, key)` returns the key from plotattributes if it exists, otherwise `default(key)`.
-    
+
 """
 function default(k::Symbol)
     k = get(_keyAliases, k, k)
@@ -1748,15 +1748,17 @@ function slice_arg!(
     remove_pair::Bool,
 )
     v = get(plotattributes_in, k, plotattributes_out[k])
-    plotattributes_out[k] =
-        if haskey(plotattributes_in, k) &&
-           typeof(v) <: AMat &&
-           !isempty(v) &&
-           !(k in _plot_args)
+    plotattributes_out[k] = if haskey(plotattributes_in, k) && !(k in _plot_args)
+        if typeof(v) <: AMat && !isempty(v)
             slice_arg(v, idx)
+        elseif typeof(v) <: NTuple{2,AMat}
+            (slice_arg(v[1], idx), slice_arg(v[2], idx))
         else
             v
         end
+    else
+        v
+    end
     if remove_pair
         RecipesPipeline.reset_kw!(plotattributes_in, k)
     end
@@ -1961,6 +1963,7 @@ function _update_subplot_legend(sp::Subplot, plotattributes_in)
         k in (:family, :pointsize, :valign, :halign, :rotation, :color) if
         haskey(plotattributes_in, Symbol(:legend_font_, k))
     )
+    #! format: off
     match_attr = NamedTuple(
         (
             lk = Symbol(:legend_font_, k);
@@ -1968,9 +1971,12 @@ function _update_subplot_legend(sp::Subplot, plotattributes_in)
                 haskey(_match_map, lk) ? sp[lk] :
                 haskey(plotattributes_in, :legend_font) ?
                 getproperty(plotattributes_in[:legend_font], k) :
+                haskey(sp.attr, :legend_font) ?
+                getproperty(sp.attr[:legend_font], k) :
                 default(plotattributes_in, lk)
         ) for k in (:family, :pointsize, :valign, :halign, :rotation, :color)
     )
+    #! format: on
     sp.attr[:legend_font] = font(; merge(match_attr, f_attr)...)
 end
 

src/axes.jl

@@ -677,7 +677,6 @@ end
 # we return (continuous_value, discrete_index)
 function discrete_value!(axis::Axis, dv)
     cv_idx = get(axis[:discrete_map], dv, -1)
-    # @show axis[:discrete_map], axis[:discrete_values], dv
     if cv_idx == -1
         ex = axis[:extrema]
         cv = NaNMath.max(0.5, ex.emax + 1.0)

src/backends/unicodeplots.jl

@@ -18,8 +18,12 @@ const _canvas_map = (
 function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
     plt.o = UnicodePlots.Plot[]
 
+    up_width = UnicodePlots.DEFAULT_WIDTH[]
+    up_height = UnicodePlots.DEFAULT_HEIGHT[]
+
     has_layout = prod(size(plt.layout)) > 1
     for sp in plt.subplots
+        sp_kw = sp[:extra_kwargs]
         xaxis = sp[:xaxis]
         yaxis = sp[:yaxis]
         xlim = collect(axis_limits(sp, :x))
@@ -37,24 +41,24 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
 
         # create a plot window with xlim/ylim set,
         # but the X/Y vectors are outside the bounds
-        canvas = if (up_c = get(sp[:extra_kwargs], :canvas, :auto)) === :auto
+        canvas = if (up_c = get(sp_kw, :canvas, :auto)) === :auto
             isijulia() ? :ascii : :braille
         else
             up_c
         end
 
-        border = if (up_b = get(sp[:extra_kwargs], :border, :auto)) === :auto
+        border = if (up_b = get(sp_kw, :border, :auto)) === :auto
             isijulia() ? :ascii : :solid
         else
             up_b
         end
 
         # blank plots will not be shown
-        width = has_layout && isempty(series_list(sp)) ? 0 : UnicodePlots.DEFAULT_WIDTH[]
-        height = UnicodePlots.DEFAULT_HEIGHT[]
+        width = has_layout && isempty(series_list(sp)) ? 0 : get(sp_kw, :width, up_width)
+        height = get(sp_kw, :height, up_height)
 
         plot_3d = is3d(sp)
-        blend = get(sp[:extra_kwargs], :blend, true)
+        blend = get(sp_kw, :blend, true)
         grid = xaxis[:grid] && yaxis[:grid]
         quiver = contour = false
         for series in series_list(sp)
@@ -73,6 +77,8 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
         blend &= !(quiver || contour)
 
         plot_3d && (xlim = ylim = (0, 0))  # determined using projection
+        azimuth, elevation = sp[:camera]  # PyPlot: azimuth = -60 & elevation = 30
+        projection = plot_3d ? get(sp_kw, :projection, :orthographic) : nothing
 
         kw = (
             compact = true,
@@ -89,11 +95,11 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
             xlim = xlim,
             ylim = ylim,
             # 3d
-            projection = plot_3d ? :orthographic : nothing,
-            up = sp[:zaxis][:flip] ? :mz : :pz,
-            # PyPlot: azimuth = -60 & elevation = 30
-            azimuth = -45,
-            elevation = 30,
+            projection = projection,
+            elevation = elevation,
+            azimuth = azimuth,
+            zoom = get(sp_kw, :zoom, 1),
+            up = get(sp_kw, :up, :z),
         )
 
         o = UnicodePlots.Plot(x, y, plot_3d ? z : nothing, _canvas_map[canvas]; kw...)
@@ -145,6 +151,7 @@ function addUnicodeSeries!(
     plot_3d::Bool,
 )
     st = series[:seriestype]
+    se_kw = series[:extra_kwargs]
 
     # get the series data and label
     x, y = if st === :straightline
@@ -156,13 +163,13 @@ function addUnicodeSeries!(
     end
 
     # special handling (src/interface)
-    fix_ar = get(series[:extra_kwargs], :fix_ar, true)
+    fix_ar = get(se_kw, :fix_ar, true)
     if st === :histogram2d
         return UnicodePlots.densityplot(x, y; kw...)
     elseif st === :spy
         return UnicodePlots.spy(Array(series[:z]); fix_ar = fix_ar, kw...)
     elseif st in (:contour, :heatmap)  # 2D
-        colormap = get(series[:extra_kwargs], :colormap, :none)
+        colormap = get(se_kw, :colormap, :none)
         kw = (
             kw...,
             zlabel = sp[:colorbar_title],
@@ -183,14 +190,17 @@ function addUnicodeSeries!(
             return UnicodePlots.heatmap(Array(series[:z]); fix_ar = fix_ar, kw...)
         end
     elseif st in (:surface, :wireframe)  # 3D
-        colormap = get(series[:extra_kwargs], :colormap, :none)
+        colormap = get(se_kw, :colormap, :none)
+        lines = get(se_kw, :lines, st === :wireframe)
+        zscale = get(se_kw, :zscale, :identity)
         kw = (
             kw...,
             zlabel = sp[:colorbar_title],
             colormap = colormap === :none ? up_cmap(series) : colormap,
             colorbar = hascolorbar(sp),
             color = st === :wireframe ? up_color(get_linecolor(series, 1)) : nothing,
-            lines = st === :wireframe,
+            zscale = zscale,
+            lines = lines,
         )
         return UnicodePlots.surfaceplot(x, y, Array(series[:z]); kw...)
     elseif st === :mesh3d
@@ -261,7 +271,12 @@ function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
     elseif Sys.islinux()
         run(`clear`)
         gui(plt)
-        run(`import -window $(ENV["WINDOWID"]) $fn`)
+        win = if "WINDOWID" in keys(ENV)
+            ENV["WINDOWID"]
+        else
+            readchomp(`xdotool getactivewindow`)
+        end
+        run(`import -window $win $fn`)
         return
     end
 

src/examples.jl

@@ -849,7 +849,6 @@ const _examples = PlotExample[
         [
             quote
                 begin
-                    using Plots
                     default(
                         titlefont = (20, "times"),
                         legendfontsize = 18,
@@ -1071,7 +1070,6 @@ const _examples = PlotExample[
         "",
         [
             quote
-                using Plots
                 using TestImages
                 img = testimage("lighthouse")
 
@@ -1092,8 +1090,6 @@ const _examples = PlotExample[
         "3d quiver",
         "",
         [quote
-            using Plots
-
             ϕs = range(-π, π, length = 50)
             θs = range(0, π, length = 25)
             θqs = range(1, π - 1, length = 25)

src/output.jl

@@ -2,74 +2,65 @@
 defaultOutputFormat(plt::Plot) = "png"
 
 function png(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "png")
-    io = open(fn, "w")
-    show(io, MIME("image/png"), plt)
-    close(io)
+    open(addExtension(fn, "png"), "w") do io
+        show(io, MIME("image/png"), plt)
+    end
 end
 png(fn::AbstractString) = png(current(), fn)
 
 function svg(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "svg")
-    io = open(fn, "w")
-    show(io, MIME("image/svg+xml"), plt)
-    close(io)
+    open(addExtension(fn, "svg"), "w") do io
+        show(io, MIME("image/svg+xml"), plt)
+    end
 end
 svg(fn::AbstractString) = svg(current(), fn)
 
 function pdf(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "pdf")
-    io = open(fn, "w")
-    show(io, MIME("application/pdf"), plt)
-    close(io)
+    open(addExtension(fn, "pdf"), "w") do io
+        show(io, MIME("application/pdf"), plt)
+    end
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
 
 function ps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "ps")
-    io = open(fn, "w")
-    show(io, MIME("application/postscript"), plt)
-    close(io)
+    open(addExtension(fn, "ps"), "w") do io
+        show(io, MIME("application/postscript"), plt)
+    end
 end
 ps(fn::AbstractString) = ps(current(), fn)
 
 function eps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "eps")
-    io = open(fn, "w")
-    show(io, MIME("image/eps"), plt)
-    close(io)
+    open(addExtension(fn, "eps"), "w") do io
+        show(io, MIME("image/eps"), plt)
+    end
 end
 eps(fn::AbstractString) = eps(current(), fn)
 
 function tex(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "tex")
-    io = open(fn, "w")
-    show(io, MIME("application/x-tex"), plt)
-    close(io)
+    open(addExtension(fn, "tex"), "w") do io
+        show(io, MIME("application/x-tex"), plt)
+    end
 end
 tex(fn::AbstractString) = tex(current(), fn)
 
 function json(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "json")
-    io = open(fn, "w")
-    show(io, MIME("application/vnd.plotly.v1+json"), plt)
-    close(io)
+    open(addExtension(fn, "json"), "w") do io
+        show(io, MIME("application/vnd.plotly.v1+json"), plt)
+    end
 end
 json(fn::AbstractString) = json(current(), fn)
 
 function html(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "html")
-    io = open(fn, "w")
-    show(io, MIME("text/html"), plt)
-    close(io)
+    open(addExtension(fn, "html"), "w") do io
+        show(io, MIME("text/html"), plt)
+    end
 end
 html(fn::AbstractString) = html(current(), fn)
 
-function txt(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "txt")
-    io = open(fn, "w")
-    show(io, MIME("text/plain"), plt)
-    close(io)
+function txt(plt::Plot, fn::AbstractString; color::Bool = true)
+    open(addExtension(fn, "txt"), "w") do io
+        show(IOContext(io, :color => color), MIME("text/plain"), plt)
+    end
 end
 txt(fn::AbstractString) = txt(current(), fn)
 

src/precompile_includer.jl

@@ -1,5 +1,5 @@
 #! format: off
-should_precompile =   true
+should_precompile =     true
 
 
 # Don't edit the following! Instead change the script for `snoop_bot`.
@@ -24,9 +24,9 @@ elseif v"1.7.0-DEV" <= VERSION <= v"1.7.9"
         include("../deps/SnoopCompile/precompile//1.7/precompile_Plots.jl")
         _precompile_()
     end
-elseif v"1.8.0-DEV" <= VERSION <= v"1.8.9" 
-    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl"))
-        include("../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl")
+elseif v"1.9.0-DEV" <= VERSION <= v"1.9.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl")
         _precompile_()
     end
 else 

src/recipes.jl

@@ -1037,6 +1037,8 @@ export lens!
         throw(ArgumentError("Inset bounding box needs to in relative coordinates."))
     end
     sp = plt.subplots[sp_index]
+    xscale = sp[:xaxis][:scale]
+    yscale = sp[:yaxis][:scale]
     xl1, xl2 = xlims(sp)
     bbx1 = xl1 + left(inset_bbox).value * (xl2 - xl1)
     bbx2 = bbx1 + width(inset_bbox).value * (xl2 - xl1)
@@ -1046,8 +1048,8 @@ export lens!
     bbx = bbx1 + width(inset_bbox).value * (xl2 - xl1) / 2 * (sp[:xaxis][:flip] ? -1 : 1)
     bby = bby1 + height(inset_bbox).value * (yl2 - yl1) / 2 * (sp[:yaxis][:flip] ? -1 : 1)
     lens_index = last(plt.subplots)[:subplot_index] + 1
-    x1, x2 = plotattributes[:x]
-    y1, y2 = plotattributes[:y]
+    x1, x2 = RecipesPipeline.inverse_scale_func(xscale).(plotattributes[:x])
+    y1, y2 = RecipesPipeline.inverse_scale_func(yscale).(plotattributes[:y])
     backup = copy(plotattributes)
     empty!(plotattributes)
 
@@ -1072,8 +1074,8 @@ export lens!
         @series begin
             primary := false
             subplot := sp_index
-            x := [xi_mag, xi_lens]
-            y := [yi_mag, yi_lens]
+            x := RecipesPipeline.scale_func(xscale).([xi_mag, xi_lens])
+            y := RecipesPipeline.scale_func(yscale).([yi_mag, yi_lens])
             ()
         end
     end
@@ -1081,8 +1083,8 @@ export lens!
     @series begin
         primary := false
         subplot := sp_index
-        x := [x1, x1, x2, x2, x1]
-        y := [y1, y2, y2, y1, y1]
+        x := RecipesPipeline.scale_func(xscale).([x1, x1, x2, x2, x1])
+        y := RecipesPipeline.scale_func(yscale).([y1, y2, y2, y1, y1])
         ()
     end
     # add subplot
@@ -1091,8 +1093,8 @@ export lens!
             plotattributes = merge(backup, copy(series.plotattributes))
             subplot := lens_index
             primary := false
-            xlims := (x1, x2)
-            ylims := (y1, y2)
+            xlims := RecipesPipeline.scale_func(xscale).((x1, x2))
+            ylims := RecipesPipeline.scale_func(yscale).((y1, y2))
             ()
         end
     end
@@ -1380,7 +1382,8 @@ function clamp_greys!(mat::AMat{<:Gray})
 end
 
 @recipe function f(mat::AMat{<:Gray})
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))
+
     if is_seriestype_supported(:image)
         seriestype := :image
         yflip --> true
@@ -1398,7 +1401,7 @@ end
 
 # images - colors
 @recipe function f(mat::AMat{T}) where {T<:Colorant}
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))
 
     if is_seriestype_supported(:image)
         seriestype := :image

test/runtests.jl

@@ -249,15 +249,6 @@ end
         @test show(io, p) isa Nothing
     end
 
-    @testset "PlotlyJS" begin
-        @test plotlyjs() == Plots.PlotlyJSBackend()
-        @test backend() == Plots.PlotlyJSBackend()
-
-        p = plot(rand(10))
-        @test p isa Plots.Plot
-        @test_broken display(p) isa Nothing
-    end
-
     @testset "GR" begin
         ENV["PLOTS_TEST"] = "true"
         ENV["GKSwstype"] = "100"
@@ -274,4 +265,13 @@ end
             )
         end
     end
+
+    @testset "PlotlyJS" begin
+        @test plotlyjs() == Plots.PlotlyJSBackend()
+        @test backend() == Plots.PlotlyJSBackend()
+
+        p = plot(rand(10))
+        @test p isa Plots.Plot
+        @test_broken display(p) isa Nothing
+    end
 end

test/test_defaults.jl

@@ -76,6 +76,11 @@ end # testset
     @test p[1][:legend_background_color] == RGBA{Float64}(0.0, 1.0, 1.0, 1.0)
     @test p[1][:legend_foreground_color] == RGBA{Float64}(0.0, 0.5019607843137255, 0.0, 1.0)
 
+    #remember settings
+    plot(legend_font_pointsize = 20)
+    sp = plot!(label = "R")[1]
+    @test Plots.legendfont(sp).pointsize == 20
+
     #setting whole font
     sp = plot(
         1:5,

test/test_pipeline.jl

@@ -32,5 +32,7 @@ end
             @test plot(data4; NamedTuple{tuple(attribute)}(Ref(mat))...)[1][i][attribute] ==
                   [2(i - 1) + 1, 2i]
         end
+        @test plot(data4, ribbon = (mat, mat))[1][i][:ribbon] ==
+              ([2(i - 1) + 1, 2i], [2(i - 1) + 1, 2i])
     end
 end