diff --git a/deps/generateprecompiles.jl b/deps/generateprecompiles.jl
index 5bf3d6be..a30d9786 100644
--- a/deps/generateprecompiles.jl
+++ b/deps/generateprecompiles.jl
@@ -26,13 +26,15 @@
 
 using SnoopCompile
 
+project_flag = string("--project=", joinpath(homedir(), ".julia", "dev", "Plots"))
 log_path = joinpath(tempdir(), "compiles.log")
 precompiles_path = joinpath(tempdir(), "precompile")
 
 # run examples with GR backend, logging what needs to be compiled
-SnoopCompile.@snoopc log_path begin
+SnoopCompile.@snoopc project_flag log_path begin
     using Plots
-    Plots.test_examples(:gr, disp=true)
+    Plots.test_examples(:gr)
+    Plots.test_examples(:plotly, skip = Plots._backend_skips[:plotly])
 end
 
 # precompile calls containing the following strings are dropped
diff --git a/src/precompile.jl b/src/precompile.jl
index c5804950..c5ea00d8 100644
--- a/src/precompile.jl
+++ b/src/precompile.jl
@@ -5,19 +5,17 @@ function _precompile_()
     isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
     isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
     isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:flip,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{ColorTypes.RGBA{Float64}, Bool, Float64, Symbol, Int64}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:rotation,), Tuple{Int64}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:scale, :guide), Tuple{Symbol, String}}, typeof(Plots.attr!), Plots.Axis})
     isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
@@ -25,82 +23,98 @@ function _precompile_()
     isdefined(Plots, Symbol("#kw##contour")) && precompile(Tuple{getfield(Plots, Symbol("#kw##contour")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
     isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#kw##gr_polyline")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_polyline")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Base.UnitRange{Int64}})
     isdefined(Plots, Symbol("#kw##gr_set_font")) && precompile(Tuple{getfield(Plots, Symbol("#kw##gr_set_font")), NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}}, typeof(Plots.gr_set_font), Plots.Font})
     isdefined(Plots, Symbol("#kw##heatmap")) && precompile(Tuple{getfield(Plots, Symbol("#kw##heatmap")), NamedTuple{(:aspect_ratio,), Tuple{Int64}}, typeof(Plots.heatmap), Array{String, 1}, Int})
     isdefined(Plots, Symbol("#kw##histogram")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram")), NamedTuple{(:bins, :weights), Tuple{Symbol, Array{Int64, 1}}}, typeof(Plots.histogram), Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##histogram2d")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram2d")), NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64}}, typeof(Plots.histogram2d), Array{Base.Complex{Float64}, 1}})
     isdefined(Plots, Symbol("#kw##histogram2d")) && precompile(Tuple{getfield(Plots, Symbol("#kw##histogram2d")), NamedTuple{(:nbins,), Tuple{Int64}}, typeof(Plots.histogram2d), Array{Float64, 1}, Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##hline!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##hline!")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}})
+    isdefined(Plots, Symbol("#kw##lens!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##lens!")), NamedTuple{(:inset,), Tuple{Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}}, typeof(Plots.lens!), Array{Int64, 1}, Int})
     isdefined(Plots, Symbol("#kw##pie")) && precompile(Tuple{getfield(Plots, Symbol("#kw##pie")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String})
+    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#kw##plotly_annotation_dict")) && precompile(Tuple{getfield(Plots, Symbol("#kw##plotly_annotation_dict")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String})
     isdefined(Plots, Symbol("#kw##portfoliocomposition")) && precompile(Tuple{getfield(Plots, Symbol("#kw##portfoliocomposition")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int})
     isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:marker, :series_annotations), Tuple{Tuple{Int64, Float64, Symbol}, Array{Any, 1}}}, typeof(Plots.scatter!), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
     isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##scatter!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter!")), NamedTuple{(:zcolor, :m, :ms, :lab), Tuple{Array{Float64, 1}, Tuple{Symbol, Float64, Plots.Stroke}, Array{Float64, 1}, String}}, typeof(Plots.scatter!), Array{Float64, 1}})
     isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks), Tuple{Array{Symbol, 2}, Array{String, 2}, Base.ReshapedArray{Int64, 2, Base.UnitRange{Int64}, Tuple{}}, Int64, String, Int64, Base.UnitRange{Int64}}}, typeof(Plots.scatter), Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
     isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:m, :lab, :bg, :xlim, :ylim), Tuple{Tuple{Int64, Symbol}, Array{String, 2}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, typeof(Plots.scatter), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
-    isdefined(Plots, Symbol("#kw##test_examples")) && precompile(Tuple{getfield(Plots, Symbol("#kw##test_examples")), NamedTuple{(:disp,), Tuple{Bool}}, typeof(Plots.test_examples), Symbol})
+    isdefined(Plots, Symbol("#kw##scatter")) && precompile(Tuple{getfield(Plots, Symbol("#kw##scatter")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#kw##standalone_html")) && precompile(Tuple{getfield(Plots, Symbol("#kw##standalone_html")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
+    isdefined(Plots, Symbol("#kw##test_examples")) && precompile(Tuple{getfield(Plots, Symbol("#kw##test_examples")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol})
     precompile(Tuple{typeof(Plots.__init__)})
     precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr})
+    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Real, 1}})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{String, 1}})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Union{Base.Missing, Int64}, 1}})
     precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity)})
     precompile(Tuple{typeof(Plots._backend_instance), Symbol})
-    precompile(Tuple{typeof(Plots._backend_instance), Symbol})
     precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Int64, 1}, String})
     precompile(Tuple{typeof(Plots._cbar_unique), Array{Nothing, 1}, String})
     precompile(Tuple{typeof(Plots._cbar_unique), Array{PlotUtils.ColorGradient, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Symbol, 1}, String})
     precompile(Tuple{typeof(Plots._create_backend_figure), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._create_backend_figure), Plots.Plot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._cycle), Array{Any, 1}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Array{Plots.Subplot{T} where T<:RecipesBase.AbstractBackend, 1}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Array{String, 1}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Base.OneTo{Int64}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Base.StepRange{Int64, Int64}, Array{Int64, 1}})
     precompile(Tuple{typeof(Plots._cycle), Base.StepRange{Int64, Int64}, Int64})
     precompile(Tuple{typeof(Plots._cycle), ColorTypes.RGBA{Float64}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Float64, Int64})
     precompile(Tuple{typeof(Plots._cycle), Int64, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots._cycle), Int64, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Nothing, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Nothing, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots._cycle), Nothing, Int64})
     precompile(Tuple{typeof(Plots._cycle), Plots.Shape, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Plots.Subplot{Plots.PlotlyBackend}, Int64})
     precompile(Tuple{typeof(Plots._cycle), Symbol, Int64})
     precompile(Tuple{typeof(Plots._display), Plots.Plot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._display), Plots.Plot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool})
     precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
@@ -111,20 +125,18 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Base.Complex{Float64}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Plots.OHLC{T} where T<:Real, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{String, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Tuple{Int64, Real}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Union{Base.Missing, Int64}, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
@@ -138,38 +150,34 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
     precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{}})
     precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol})
-    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol})
+    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Symbol})
     precompile(Tuple{typeof(Plots._filter_input_data!), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool})
     precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol})
+    precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend})
     precompile(Tuple{typeof(Plots._override_seriestype_check), Plots.Attr, Symbol})
     precompile(Tuple{typeof(Plots._pick_default_backend)})
-    precompile(Tuple{typeof(Plots._pick_default_backend)})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
@@ -178,34 +186,54 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
     precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
-    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
-    precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
     precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol})
     precompile(Tuple{typeof(Plots._plots_defaults)})
     precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.Attr})
+    precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, Plots.Attr})
+    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
-    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
     precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}, Array{RecipesBase.RecipeData, 1}})
@@ -219,34 +247,30 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Base.OneTo{Int64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._preprocess_binlike), Plots.Attr, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._process_plotrecipe), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._process_plotrecipe), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._process_userrecipe), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData})
+    precompile(Tuple{typeof(Plots._process_seriesrecipe), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._process_userrecipe), Plots.Plot{Plots.GRBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData})
+    precompile(Tuple{typeof(Plots._process_userrecipe), Plots.Plot{Plots.PlotlyBackend}, Array{Base.Dict{Symbol, Any}, 1}, RecipesBase.RecipeData})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
-    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
@@ -255,69 +279,85 @@ function _precompile_()
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
     precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
-    precompile(Tuple{typeof(Plots._replace_linewidth), Plots.Attr})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
     precompile(Tuple{typeof(Plots._replace_linewidth), Plots.Attr})
     precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape})
     precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol})
     precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._series_index), Plots.Attr, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
-    precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
-    precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Plots.Attr, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
     precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
     precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots._transform_ticks), Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots._transform_ticks), Nothing})
     precompile(Tuple{typeof(Plots._transform_ticks), Symbol})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.Attr, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Plots.Attr, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Symbol, Int64})
-    precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Symbol, Int64})
     precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis})
     precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol})
-    precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol})
+    precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol})
     precompile(Tuple{typeof(Plots._update_clims), Float64, Float64, Float64, Float64})
     precompile(Tuple{typeof(Plots._update_clims), Float64, Float64, Int64, Int64})
     precompile(Tuple{typeof(Plots._update_min_padding!), Plots.GridLayout})
     precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Plots.Attr})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Attr})
     precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_series_attributes!), Plots.Attr, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
     precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Int64, Bool})
-    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Plots.Attr, Int64, Bool})
-    precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr, Int64, Bool})
     precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}})
-    precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}})
+    precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}})
     precompile(Tuple{typeof(Plots.addExtension), String, String})
     precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64})
-    precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64})
-    precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.Attr, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64})
     precompile(Tuple{typeof(Plots.aliasesAndAutopick), Plots.Attr, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64})
     precompile(Tuple{typeof(Plots.all3D), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.all3D), Plots.Attr})
     precompile(Tuple{typeof(Plots.allAlphas), Int64})
-    precompile(Tuple{typeof(Plots.allReals), Int64})
     precompile(Tuple{typeof(Plots.allStyles), Int64})
     precompile(Tuple{typeof(Plots.allStyles), Symbol})
     precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}})
     precompile(Tuple{typeof(Plots.annotations), Array{Any, 1}})
     precompile(Tuple{typeof(Plots.arrow), Int64})
     precompile(Tuple{typeof(Plots.attr!), Plots.Axis})
-    precompile(Tuple{typeof(Plots.attr!), Plots.Axis})
     precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol})
     precompile(Tuple{typeof(Plots.autopick), Array{ColorTypes.RGBA{Float64}, 1}, Int64})
@@ -326,38 +366,45 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.axis_drawing_info_3d), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.GRBackend}, Symbol, Bool, Bool})
     precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.PlotlyBackend}, Symbol, Bool, Bool})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
     precompile(Tuple{typeof(Plots.backend), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.backend), Plots.PlotlyBackend})
     precompile(Tuple{typeof(Plots.backend), Symbol})
-    precompile(Tuple{typeof(Plots.backend), Symbol})
-    precompile(Tuple{typeof(Plots.backend)})
     precompile(Tuple{typeof(Plots.backend)})
     precompile(Tuple{typeof(Plots.bar), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.bbox!), Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.bbox!), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bbox!), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bbox), Float64, Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots.bbox), Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
+    precompile(Tuple{typeof(Plots.bbox_to_pcts), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Bool})
+    precompile(Tuple{typeof(Plots.bbox_to_pcts), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
     precompile(Tuple{typeof(Plots.bottom), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bottom), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}})
     precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.build_layout), Plots.Attr})
+    precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.build_layout), Plots.Attr})
     precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}})
-    precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}})
-    precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64})
     precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64})
     precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout})
     precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout})
     precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.Attr, Symbol})
-    precompile(Tuple{typeof(Plots.color_or_nothing!), Plots.Attr, Symbol})
     precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series})
     precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64})
-    precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Nothing})
-    precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, Array{Float64, 1}, Plots.Surface{Array{Float64, 2}}})
-    precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, typeof(identity), Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{Float64, 1}, typeof(identity), Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{String, 1}, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Float64, 1}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Array{Union{Base.Missing, Float64}, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Base.UnitRange{Int64}, Nothing})
     precompile(Tuple{typeof(Plots.compute_xyz), Nothing, Nothing, Nothing})
+    precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
     precompile(Tuple{typeof(Plots.contour_levels), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.convertLegendValue), Bool})
@@ -366,16 +413,13 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Float64, 2}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Function, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Function, 1}, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.convertToAnyVector), Int64, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.convert_sci_unicode), String})
-    precompile(Tuple{typeof(Plots.convert_to_polar), Array{Float64, 1}, Array{Float64, 1}, Tuple{Int64, Float64}})
-    precompile(Tuple{typeof(Plots.create_grid), Expr})
+    precompile(Tuple{typeof(Plots.convert_to_polar), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Int64, Float64}})
+    precompile(Tuple{typeof(Plots.copy_series!), Plots.Series, Symbol})
     precompile(Tuple{typeof(Plots.create_grid), Expr})
     precompile(Tuple{typeof(Plots.create_grid), Symbol})
     precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
-    precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
-    precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
     precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
     precompile(Tuple{typeof(Plots.default), Symbol})
     precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis})
@@ -385,31 +429,22 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char})
     precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String})
     precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.Attr, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.Attr, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.ensure_gradient!), Plots.Attr, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Plots.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, Plots.Attr})
-    precompile(Tuple{typeof(Plots.extendSeriesData), Array{Float64, 1}, Float64})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, Plots.Attr})
+    precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64})
+    precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol})
     precompile(Tuple{typeof(Plots.extractGroupArgs), Array{String, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.fakedata), Int64, Int64})
-    precompile(Tuple{typeof(Plots.fakedata), Int64, Int64})
-    precompile(Tuple{typeof(Plots.fg_color), Plots.Attr})
     precompile(Tuple{typeof(Plots.fg_color), Plots.Attr})
     precompile(Tuple{typeof(Plots.filter_data!), Base.Dict{Symbol, Any}, Array{Int64, 1}})
     precompile(Tuple{typeof(Plots.filter_data), Array{Float64, 1}, Array{Int64, 1}})
@@ -420,61 +455,77 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.font), Symbol, Int})
     precompile(Tuple{typeof(Plots.frame), Plots.Animation, Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.frame), Plots.Animation})
+    precompile(Tuple{typeof(Plots.get_aspect_ratio), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_aspect_ratio), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.get_axis), Plots.Subplot{Plots.GRBackend}, Symbol})
-    precompile(Tuple{typeof(Plots.get_axis), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.get_axis), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
     precompile(Tuple{typeof(Plots.get_clims), Plots.Series})
     precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.GRBackend}, Plots.Series})
     precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.PlotlyBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.get_fillalpha), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.get_fillalpha), Plots.Series})
     precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Float64, Float64, Int64})
     precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.get_linealpha), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linealpha), Plots.Series})
     precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Float64, Float64, Int64})
     precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.get_linestyle), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linestyle), Plots.Series})
     precompile(Tuple{typeof(Plots.get_linewidth), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linewidth), Plots.Series})
     precompile(Tuple{typeof(Plots.get_markeralpha), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.get_markercolor), Plots.Series, Float64, Float64, Int64})
     precompile(Tuple{typeof(Plots.get_markerstrokealpha), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.get_markerstrokecolor), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_markerstrokewidth), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{Any, 1}}})
     precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{String, 1}}})
     precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.get_series_color), Int64, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Int64, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.get_series_color), PlotUtils.ColorGradient, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), PlotUtils.ColorGradient, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.get_series_color), Symbol, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
-    precompile(Tuple{typeof(Plots.get_series_color), Symbol, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Symbol, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.get_subplot), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.get_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
-    precompile(Tuple{typeof(Plots.get_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.get_ticks), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
     precompile(Tuple{typeof(Plots.get_xy), Array{Plots.OHLC{T} where T<:Real, 1}, Base.OneTo{Int64}})
     precompile(Tuple{typeof(Plots.get_xy), Plots.OHLC{Float64}, Int64, Float64})
-    precompile(Tuple{typeof(Plots.getxy), Plots.Plot{Plots.GRBackend}, Int64})
     precompile(Tuple{typeof(Plots.gr_axis_height), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
     precompile(Tuple{typeof(Plots.gr_axis_width), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
     precompile(Tuple{typeof(Plots.gr_color), ColorTypes.RGBA{Float64}, Type{ColorTypes.RGB{Float64}}})
     precompile(Tuple{typeof(Plots.gr_colorbar_colors), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.gr_contour_levels), Plots.Series, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.gr_display), Plots.Plot{Plots.GRBackend}, String})
-    precompile(Tuple{typeof(Plots.gr_display), Plots.Plot{Plots.GRBackend}, String})
     precompile(Tuple{typeof(Plots.gr_display), Plots.Subplot{Plots.GRBackend}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.gr_draw_colorbar), Plots.GRColorbar, Plots.Subplot{Plots.GRBackend}, Tuple{Float64, Float64}})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Float64, Float64, Int64, Plots.Shape})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Float64, Float64, Int64, Symbol})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Int64, Float64, Float64, Plots.Shape})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Int64, Float64, Float64, Symbol})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Int64, Float64, Int64, Plots.Shape})
-    precompile(Tuple{typeof(Plots.gr_draw_marker), Int64, Float64, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Int64, Int64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Int64, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Float64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Int64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Int64, Tuple{Float64, Float64}, Int64, Int64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Int64, Tuple{Float64, Float64}, Int64, Int64, Symbol})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Int64, 1}, Tuple{Float64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Int64, 1}, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Float64, Float64}})
     precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.gr_fill_viewport), Array{Float64, 1}, ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_get_color), Plots.Series})
@@ -485,10 +536,10 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.gr_polaraxes), Int64, Float64, Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}, typeof(identity)})
     precompile(Tuple{typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.gr_set_bordercolor), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_fill), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_fillcolor), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_font), Plots.Font})
-    precompile(Tuple{typeof(Plots.gr_set_font), Plots.Font})
     precompile(Tuple{typeof(Plots.gr_set_gradient), PlotUtils.ColorGradient})
     precompile(Tuple{typeof(Plots.gr_set_gradient), Plots.Series})
     precompile(Tuple{typeof(Plots.gr_set_line), Float64, Symbol, ColorTypes.RGBA{Float64}})
@@ -499,101 +550,119 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.gr_set_textcolor), ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Float64})
     precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Nothing})
+    precompile(Tuple{typeof(Plots.gr_set_transparency), Float64})
     precompile(Tuple{typeof(Plots.gr_set_viewport_cmap), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.gr_set_viewport_polar)})
     precompile(Tuple{typeof(Plots.gr_set_xticks_font), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.gr_set_xticks_font), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.gr_set_yticks_font), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.gr_set_yticks_font), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.gr_text), Float64, Float64, String})
     precompile(Tuple{typeof(Plots.gr_text_size), String, Int64})
     precompile(Tuple{typeof(Plots.gr_text_size), String})
+    precompile(Tuple{typeof(Plots.gr_tick_label), Plots.Axis, String})
     precompile(Tuple{typeof(Plots.gr_update_colorbar!), Plots.GRColorbar, Plots.Series})
     precompile(Tuple{typeof(Plots.gr_viewport_from_bbox), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.gr_w3tondc), Float64, Float64, Float64})
     precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.guide_padding), Plots.Axis})
     precompile(Tuple{typeof(Plots.guidefont), Plots.Axis})
-    precompile(Tuple{typeof(Plots.guidefont), Plots.Axis})
-    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol})
-    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol})
     precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol})
     precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}, Symbol})
     precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Plots.Shape, Symbol})
     precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.has_attribute_segments), Plots.Series})
     precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.hasgrid), Symbol, Symbol})
     precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Array{Float64, 1}, Symbol, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Bool})
     precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol})
     precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Bool})
-    precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Bool})
-    precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol})
     precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol})
     precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     precompile(Tuple{typeof(Plots.ignorenan_extrema), Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.ignorenan_extrema), Plots.Axis})
     precompile(Tuple{typeof(Plots.ignorenan_maximum), Base.OneTo{Int64}})
     precompile(Tuple{typeof(Plots.ignorenan_minimum), Array{Int64, 1}})
     precompile(Tuple{typeof(Plots.ignorenan_minimum), Base.OneTo{Int64}})
     precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.intersection_point), Float64, Float64, Float64, Float64, Float64, Float64})
     precompile(Tuple{typeof(Plots.is3d), Plots.Attr})
     precompile(Tuple{typeof(Plots.is3d), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.is3d), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.is3d), Symbol})
     precompile(Tuple{typeof(Plots.is_2tuple), Int64})
     precompile(Tuple{typeof(Plots.is_2tuple), Symbol})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Float64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}})
     precompile(Tuple{typeof(Plots.is_axis_attr), Symbol})
     precompile(Tuple{typeof(Plots.is_marker_supported), Plots.GRBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Shape})
-    precompile(Tuple{typeof(Plots.is_marker_supported), Symbol})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Stroke})
     precompile(Tuple{typeof(Plots.is_marker_supported), Symbol})
     precompile(Tuple{typeof(Plots.is_scale_supported), Plots.GRBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_scale_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, Symbol})
-    precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol})
+    precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol})
     precompile(Tuple{typeof(Plots.is_style_supported), Plots.GRBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_style_supported), Plots.PlotlyBackend, Symbol})
     precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iscontour), Plots.Series})
     precompile(Tuple{typeof(Plots.isijulia)})
     precompile(Tuple{typeof(Plots.ispolar), Plots.Series})
     precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.isvertical), Plots.Attr})
-    precompile(Tuple{typeof(Plots.isvertical), Plots.Attr})
-    precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int})
+    precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iter_segments), Base.OneTo{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.OneTo{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iter_segments), Base.UnitRange{Int64}, Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.iter_segments), Plots.Series})
     precompile(Tuple{typeof(Plots.labelfunc), Symbol, Plots.GRBackend})
-    precompile(Tuple{typeof(Plots.layout_args), Base.Dict{Symbol, Any}, Int64})
+    precompile(Tuple{typeof(Plots.labelfunc), Symbol, Plots.PlotlyBackend})
     precompile(Tuple{typeof(Plots.layout_args), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.layout_args), Int64, Int64})
     precompile(Tuple{typeof(Plots.layout_args), Int64, Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}})
     precompile(Tuple{typeof(Plots.layout_args), Int64})
     precompile(Tuple{typeof(Plots.layout_args), Plots.Attr})
     precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}})
     precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.legendfont), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.legendfont), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.legendtitlefont), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.like_histogram), Symbol})
     precompile(Tuple{typeof(Plots.like_surface), Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol})
-    precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis})
-    precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis})
-    precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol})
     precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
     precompile(Tuple{typeof(Plots.link_subplots), Array{RecipesBase.AbstractLayout, 1}, Symbol})
     precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText})
     precompile(Tuple{typeof(Plots.make_fillrange_from_ribbon), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.make_fillrange_side), Array{Float64, 1}, Array{Float64, 1}})
-    precompile(Tuple{typeof(Plots.make_fillrange_side), Array{Float64, 1}, Int64})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Base.LinRange{Float64}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Int64})
     precompile(Tuple{typeof(Plots.make_steps), Array{Float64, 1}, Symbol})
     precompile(Tuple{typeof(Plots.make_steps), Array{Int64, 1}, Symbol})
     precompile(Tuple{typeof(Plots.make_steps), Base.OneTo{Int64}, Symbol})
@@ -604,58 +673,103 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}})
     precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing})
-    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Nothing})
     precompile(Tuple{typeof(Plots.parse_axis_kw), Symbol})
     precompile(Tuple{typeof(Plots.pie_labels), Plots.Subplot{Plots.GRBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.pie_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Series})
     precompile(Tuple{typeof(Plots.plotarea!), Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.plotarea!), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.plotarea!), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.plotarea), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.plotarea), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.plotly_apply_aspect_ratio), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_colorbar_hack), Plots.Series, Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.plotly_colorscale), PlotUtils.ColorGradient, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_data), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Array{String, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Array{String, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Plots.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.plotly_font), Plots.Font})
+    precompile(Tuple{typeof(Plots.plotly_hover!), Base.Dict{Symbol, Any}, Array{Nothing, 1}})
+    precompile(Tuple{typeof(Plots.plotly_hover!), Base.Dict{Symbol, Any}, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_html_body), Plots.Plot{Plots.PlotlyBackend}, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_html_head), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_layout), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_legend_pos), Symbol})
+    precompile(Tuple{typeof(Plots.plotly_link_indicies), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{String, 1}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Plots.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series})
+    precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Int64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.OneTo{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.OneTo{Int64}, Base.UnitRange{Int64}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, Plots.Surface{Array{Float64, 2}}})
     precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String})
     precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Float64, 2}})
-    precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Int32, 1}})
     precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Real, 1}})
     precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Union{Base.Missing, Int64}, 1}})
     precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Union{Base.Missing, Number}, 1}})
-    precompile(Tuple{typeof(Plots.prepareSeriesData), Array{Union{Base.Missing, Number}, 1}})
-    precompile(Tuple{typeof(Plots.prepareSeriesData), Base.LinRange{Float64}})
-    precompile(Tuple{typeof(Plots.prepareSeriesData), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
-    precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.preprocessArgs!), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.preprocessArgs!), Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.preprocessArgs!), Plots.Attr})
     precompile(Tuple{typeof(Plots.preprocessArgs!), Plots.Attr})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool})
-    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Float64})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
-    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
-    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
     precompile(Tuple{typeof(Plots.processGridArg!), Plots.Attr, Bool, Symbol})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
-    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Symbol})
-    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Symbol})
-    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Bool})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Float64})
-    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Float64})
-    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Int64})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Shape})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Stroke})
     precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol})
-    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol})
     precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
     precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText})
     precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Symbol})
     precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, String, Symbol})
     precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
@@ -673,24 +787,21 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}})
     precompile(Tuple{typeof(Plots.replaceAliases!), Plots.Attr, Base.Dict{Symbol, Symbol}})
     precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
-    precompile(Tuple{typeof(Plots.reset_extrema!), Plots.Subplot{Plots.GRBackend}})
     precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.rowsize), Expr})
     precompile(Tuple{typeof(Plots.rowsize), Symbol})
     precompile(Tuple{typeof(Plots.series_annotations), Array{Any, 1}})
     precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations})
     precompile(Tuple{typeof(Plots.series_annotations_shapes!), Plots.Series, Symbol})
     precompile(Tuple{typeof(Plots.series_idx), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.setxy!), Plots.Plot{Plots.GRBackend}, Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
     precompile(Tuple{typeof(Plots.shape_data), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.should_add_to_legend), Plots.Series})
     precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol})
-    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64})
     precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool})
     precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.Attr, Symbol, Int64, Bool})
-    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Plots.Attr, Symbol, Int64, Bool})
-    precompile(Tuple{typeof(Plots.slice_arg!), Plots.Attr, Plots.Attr, Symbol, Int64, Bool})
     precompile(Tuple{typeof(Plots.slice_arg!), Plots.Attr, Plots.Attr, Symbol, Int64, Bool})
     precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64})
@@ -706,69 +817,74 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.slice_arg), Nothing, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), String, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Symbol, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Tuple{Float64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Float64}, Int64})
     precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Int64}, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{Int64, 1}, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{String, 1}, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Array{Symbol, 2}, Int64})
-    precompile(Tuple{typeof(Plots.splittable_kw), Symbol, ColorTypes.RGB{Float64}, Int64})
-    precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Float64, Int64})
-    precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Int64, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.GridLayout, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.Plot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Plots.Plot{Plots.PlotlyBackend}, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, String, Int64})
     precompile(Tuple{typeof(Plots.splittable_kw), Symbol, Symbol, Int64})
     precompile(Tuple{typeof(Plots.straightline_data), Plots.Series, Int64})
     precompile(Tuple{typeof(Plots.straightline_data), Tuple{Int64, Int64}, Tuple{Float64, Float64}, Array{Float64, 1}, Array{Float64, 1}, Int64})
-    precompile(Tuple{typeof(Plots.stroke), Int64, Int64})
     precompile(Tuple{typeof(Plots.stroke), Int64, Int})
     precompile(Tuple{typeof(Plots.supported_markers), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.supported_markers), Plots.PlotlyBackend})
     precompile(Tuple{typeof(Plots.supported_markers)})
     precompile(Tuple{typeof(Plots.supported_styles), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.supported_styles), Plots.PlotlyBackend})
     precompile(Tuple{typeof(Plots.supported_styles)})
+    precompile(Tuple{typeof(Plots.test_examples), Symbol})
     precompile(Tuple{typeof(Plots.text), String, Int64, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.text), String, Plots.Font})
     precompile(Tuple{typeof(Plots.text), String, Symbol, Int64, Int})
     precompile(Tuple{typeof(Plots.text), String, Symbol})
+    precompile(Tuple{typeof(Plots.text_size), Int64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.tick_padding), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
     precompile(Tuple{typeof(Plots.tickfont), Plots.Axis})
-    precompile(Tuple{typeof(Plots.tickfont), Plots.Axis})
+    precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{String, 1}}})
     precompile(Tuple{typeof(Plots.title!), String})
+    precompile(Tuple{typeof(Plots.title_padding), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.top), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
     precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.tovec), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.transpose_z), Plots.Series, Array{Float64, 2}, Bool})
     precompile(Tuple{typeof(Plots.trueOrAllTrue), typeof(Plots.is3d), Symbol})
     precompile(Tuple{typeof(Plots.trueOrAllTrue), typeof(identity), Array{Symbol, 2}})
     precompile(Tuple{typeof(Plots.unzip), Array{Tuple{Float64, Float64, Float64}, 1}})
     precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1}})
-    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1}})
-    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout})
     precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout})
     precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.Subplot{Plots.GRBackend}, Array{Measures.Length{:mm, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.Subplot{Plots.PlotlyBackend}, Array{Measures.Length{:mm, Float64}, 1}})
     precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.GRBackend}})
-    precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}})
     precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}})
     precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}})
     precompile(Tuple{typeof(Plots.warnOnUnsupported), Plots.GRBackend, Plots.Attr})
-    precompile(Tuple{typeof(Plots.warnOnUnsupported), Plots.GRBackend, Plots.Attr})
-    precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.GRBackend, Plots.Attr})
+    precompile(Tuple{typeof(Plots.warnOnUnsupported), Plots.PlotlyBackend, Plots.Attr})
     precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.GRBackend, Plots.Attr})
+    precompile(Tuple{typeof(Plots.warnOnUnsupported_args), Plots.PlotlyBackend, Plots.Attr})
     precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}})
-    precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.warnOnUnsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})
     precompile(Tuple{typeof(Plots.wrap_surfaces), Base.Dict{Symbol, Any}})
     precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}})
     precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     precompile(Tuple{typeof(Plots.wraptuple), Bool})
     precompile(Tuple{typeof(Plots.wraptuple), Float64})
     precompile(Tuple{typeof(Plots.wraptuple), Int64})
     precompile(Tuple{typeof(Plots.wraptuple), Nothing})
     precompile(Tuple{typeof(Plots.wraptuple), Plots.SeriesAnnotations})
-    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Array{Float64, 1}, Array{Float64, 1}}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Array{Symbol, 2}, Int64, Float64, Plots.Stroke}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Array{Symbol, 2}, Int64}})
-    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Float64, Array{Symbol, 2}, Int64}})
-    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Float64, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Array{Symbol, 2}}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol, Plots.Stroke}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol}})
@@ -780,9 +896,18 @@ function _precompile_()
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{String, Tuple{Int64, Int64}, Base.StepRange{Int64, Int64}, Symbol}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Float64, Plots.Stroke}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Int64}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Symbol, Int64, Symbol, Float64}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Symbol, Symbol, Int64, Float64}})
     precompile(Tuple{typeof(Plots.wraptuple), Tuple{}})
+    precompile(Tuple{typeof(Plots.write_temp_html), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.xgrid!), Plots.Plot{Plots.GRBackend}, Symbol, Int})
+    precompile(Tuple{typeof(Plots.xgrid!), Plots.Plot{Plots.PlotlyBackend}, Symbol, Int})
+    precompile(Tuple{typeof(Plots.xlims), Int64})
     precompile(Tuple{typeof(Plots.xlims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.xlims), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.xy_mm_to_pcts), Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
     precompile(Tuple{typeof(Plots.yaxis!), String, Symbol})
+    precompile(Tuple{typeof(Plots.ylims), Int64})
     precompile(Tuple{typeof(Plots.ylims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.ylims), Plots.Subplot{Plots.PlotlyBackend}})
 end
diff --git a/src/series.jl b/src/series.jl
index 3a79d478..2773b221 100644
--- a/src/series.jl
+++ b/src/series.jl
@@ -70,23 +70,19 @@ process_ribbon(ribbon::Tuple{Any,Any}, plotattributes) = collect(zip(convertToAn
 
 # --------------------------------------------------------------------
 
-# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
-#       result in that array being shared.  push!, etc will add too many items to that array
+compute_x(x::Nothing, y::Nothing, z)    = axes(z,1)
+compute_x(x::Nothing, y, z)             = axes(y,1)
+compute_x(x::Function, y, z)            = map(x, y)
+compute_x(x, y, z)                      = x
 
-compute_x(x::Nothing, y::Nothing, z)      = axes(z,1)
-compute_x(x::Nothing, y, z)            = axes(y,1)
-compute_x(x::Function, y, z)        = map(x, y)
-compute_x(x, y, z)                  = copy(x)
+compute_y(x::Nothing, y::Nothing, z)    = axes(z,2)
+compute_y(x, y::Function, z)            = map(y, x)
+compute_y(x, y, z)                      = y
 
-# compute_y(x::Void, y::Function, z)  = error()
-compute_y(x::Nothing, y::Nothing, z)      = axes(z,2)
-compute_y(x, y::Function, z)        = map(y, x)
-compute_y(x, y, z)                  = copy(y)
-
-compute_z(x, y, z::Function)        = map(z, x, y)
-compute_z(x, y, z::AbstractMatrix)  = Surface(z)
-compute_z(x, y, z::Nothing)            = nothing
-compute_z(x, y, z)                  = copy(z)
+compute_z(x, y, z::Function)            = map(z, x, y)
+compute_z(x, y, z::AbstractMatrix)      = Surface(z)
+compute_z(x, y, z::Nothing)             = nothing
+compute_z(x, y, z)                      = z
 
 nobigs(v::AVec{BigFloat}) = map(Float64, v)
 nobigs(v::AVec{BigInt}) = map(Int64, v)
diff --git a/src/utils.jl b/src/utils.jl
index ef15b8b5..db1128b9 100644
--- a/src/utils.jl
+++ b/src/utils.jl
@@ -1,119 +1,4 @@
 
-calcMidpoints(edges::AbstractVector) = Float64[0.5 * (edges[i] + edges[i+1]) for i in 1:length(edges)-1]
-
-"Make histogram-like bins of data"
-function binData(data, nbins)
-  lo, hi = ignorenan_extrema(data)
-  edges = collect(range(lo, stop=hi, length=nbins+1))
-  midpoints = calcMidpoints(edges)
-  buckets = Int[max(2, min(searchsortedfirst(edges, x), length(edges)))-1 for x in data]
-  counts = zeros(Int, length(midpoints))
-  for b in buckets
-    counts[b] += 1
-  end
-  edges, midpoints, buckets, counts
-end
-
-"""
-A hacky replacement for a histogram when the backend doesn't support histograms directly.
-Convert it into a bar chart with the appropriate x/y values.
-"""
-function histogramHack(; kw...)
-  plotattributes = KW(kw)
-
-  # we assume that the y kwarg is set with the data to be binned, and nbins is also defined
-  edges, midpoints, buckets, counts = binData(plotattributes[:y], plotattributes[:bins])
-  plotattributes[:x] = midpoints
-  plotattributes[:y] = float(counts)
-  plotattributes[:seriestype] = :bar
-  plotattributes[:fillrange] = plotattributes[:fillrange] === nothing ? 0.0 : plotattributes[:fillrange]
-  plotattributes
-end
-
-"""
-A hacky replacement for a bar graph when the backend doesn't support bars directly.
-Convert it into a line chart with fillrange set.
-"""
-function barHack(; kw...)
-  plotattributes = KW(kw)
-  midpoints = plotattributes[:x]
-  heights = plotattributes[:y]
-  fillrange = plotattributes[:fillrange] === nothing ? 0.0 : plotattributes[:fillrange]
-
-  # estimate the edges
-  dists = diff(midpoints) * 0.5
-  edges = zeros(length(midpoints)+1)
-  for i in eachindex(edges)
-    if i == 1
-      edge = midpoints[1] - dists[1]
-    elseif i == length(edges)
-      edge = midpoints[i-1] + dists[i-2]
-    else
-      edge = midpoints[i-1] + dists[i-1]
-    end
-    edges[i] = edge
-  end
-
-  x = Float64[]
-  y = Float64[]
-  for i in eachindex(heights)
-    e1, e2 = edges[i:i+1]
-    append!(x, [e1, e1, e2, e2])
-    append!(y, [fillrange, heights[i], heights[i], fillrange])
-  end
-
-  plotattributes[:x] = x
-  plotattributes[:y] = y
-  plotattributes[:seriestype] = :path
-  plotattributes[:fillrange] = fillrange
-  plotattributes
-end
-
-
-"""
-A hacky replacement for a sticks graph when the backend doesn't support sticks directly.
-Convert it into a line chart that traces the sticks, and a scatter that sets markers at the points.
-"""
-function sticksHack(; kw...)
-  plotattributesLine = KW(kw)
-  plotattributesScatter = copy(plotattributesLine)
-
-  # these are the line vertices
-  x = Float64[]
-  y = Float64[]
-  fillrange = plotattributesLine[:fillrange] === nothing ? 0.0 : plotattributesLine[:fillrange]
-
-  # calculate the vertices
-  yScatter = plotattributesScatter[:y]
-  for (i,xi) in enumerate(plotattributesScatter[:x])
-    yi = yScatter[i]
-    for j in 1:3 push!(x, xi) end
-    append!(y, [fillrange, yScatter[i], fillrange])
-  end
-
-  # change the line args
-  plotattributesLine[:x] = x
-  plotattributesLine[:y] = y
-  plotattributesLine[:seriestype] = :path
-  plotattributesLine[:markershape] = :none
-  plotattributesLine[:fillrange] = nothing
-
-  # change the scatter args
-  plotattributesScatter[:seriestype] = :none
-
-  plotattributesLine, plotattributesScatter
-end
-
-function regressionXY(x, y)
-  # regress
-  β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
-
-  # make a line segment
-  regx = [ignorenan_minimum(x), ignorenan_maximum(x)]
-  regy = β * regx + α
-  regx, regy
-end
-
 function replace_image_with_heatmap(z::Array{T}) where T<:Colorant
     n, m = size(z)
     colors = ColorGradient(vec(z))
@@ -262,10 +147,10 @@ mapFuncOrFuncs(f::Function, u::AVec)        = map(f, u)
 mapFuncOrFuncs(fs::AVec{F}, u::AVec) where {F<:Function} = [map(f, u) for f in fs]
 
 for i in 2:4
-  @eval begin
-    unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
+    @eval begin
+        unzip(v::Union{AVec{<:Tuple{Vararg{T,$i} where T}},
                    AVec{<:GeometryTypes.Point{$i}}}) = $(Expr(:tuple, (:([t[$j] for t in v]) for j=1:i)...))
-  end
+    end
 end
 
 unzip(v::Union{AVec{<:GeometryTypes.Point{N}},
@@ -275,15 +160,13 @@ unzip(v::Union{AVec{<:GeometryTypes.Point},
 
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
 function _expand_limits(lims, x)
-  try
-    e1, e2 = ignorenan_extrema(x)
-    lims[1] = NaNMath.min(lims[1], e1)
-    lims[2] = NaNMath.max(lims[2], e2)
-  # catch err
-  #   @warn(err)
-  catch
-  end
-  nothing
+    try
+        e1, e2 = ignorenan_extrema(x)
+        lims[1] = NaNMath.min(lims[1], e1)
+        lims[2] = NaNMath.max(lims[2], e2)
+    catch
+    end
+    nothing
 end
 
 expand_data(v, n::Integer) = [_cycle(v, i) for i=1:n]
@@ -301,21 +184,21 @@ function addOrReplace(v::AbstractVector, t::DataType, args...; kw...)
 end
 
 function replaceType(vec, val)
-  filter!(x -> !isa(x, typeof(val)), vec)
-  push!(vec, val)
+    filter!(x -> !isa(x, typeof(val)), vec)
+    push!(vec, val)
 end
 
 function replaceAlias!(plotattributes::AKW, k::Symbol, aliases::Dict{Symbol,Symbol})
-  if haskey(aliases, k)
-    plotattributes[aliases[k]] = pop_kw!(plotattributes, k)
-  end
+    if haskey(aliases, k)
+        plotattributes[aliases[k]] = pop_kw!(plotattributes, k)
+    end
 end
 
 function replaceAliases!(plotattributes::AKW, aliases::Dict{Symbol,Symbol})
-  ks = collect(keys(plotattributes))
-  for k in ks
-      replaceAlias!(plotattributes, k, aliases)
-  end
+    ks = collect(keys(plotattributes))
+    for k in ks
+        replaceAlias!(plotattributes, k, aliases)
+    end
 end
 
 createSegments(z) = collect(repeat(reshape(z,1,:),2,1))[2:end]
@@ -334,20 +217,20 @@ const _scale_base = Dict{Symbol, Real}(
 )
 
 function _heatmap_edges(v::AVec, isedges::Bool = false)
-  length(v) == 1 && return v[1] .+ [-0.5, 0.5]
-  if isedges return v end
-  # `isedges = true` means that v is a vector which already describes edges
-  # and does not need to be extended.
-  vmin, vmax = ignorenan_extrema(v)
-  extra_min = (v[2] - v[1]) / 2
-  extra_max = (v[end] - v[end - 1]) / 2
-  vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
+    length(v) == 1 && return v[1] .+ [-0.5, 0.5]
+    if isedges return v end
+    # `isedges = true` means that v is a vector which already describes edges
+    # and does not need to be extended.
+    vmin, vmax = ignorenan_extrema(v)
+    extra_min = (v[2] - v[1]) / 2
+    extra_max = (v[end] - v[end - 1]) / 2
+    vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end
 
 "create an (n+1) list of the outsides of heatmap rectangles"
 function heatmap_edges(v::AVec, scale::Symbol = :identity, isedges::Bool = false)
-  f, invf = scalefunc(scale), invscalefunc(scale)
-  map(invf, _heatmap_edges(map(f,v), isedges))
+    f, invf = scalefunc(scale), invscalefunc(scale)
+    map(invf, _heatmap_edges(map(f,v), isedges))
 end
 
 function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size::Tuple{Int, Int})
@@ -367,8 +250,8 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
 end
 
 function is_uniformly_spaced(v; tol=1e-6)
-  dv = diff(v)
-  maximum(dv) - minimum(dv) < tol * mean(abs.(dv))
+    dv = diff(v)
+    maximum(dv) - minimum(dv) < tol * mean(abs.(dv))
 end
 
 function convert_to_polar(theta, r, r_extrema = ignorenan_extrema(r))
@@ -380,11 +263,11 @@ function convert_to_polar(theta, r, r_extrema = ignorenan_extrema(r))
 end
 
 function fakedata(sz...)
-  y = zeros(sz...)
-  for r in 2:size(y,1)
-    y[r,:] = 0.95 * vec(y[r-1,:]) + randn(size(y,2))
-  end
-  y
+    y = zeros(sz...)
+    for r in 2:size(y,1)
+        y[r,:] = 0.95 * vec(y[r-1,:]) + randn(size(y,2))
+    end
+    y
 end
 
 isijulia() = :IJulia in nameof.(collect(values(Base.loaded_modules)))
@@ -752,119 +635,107 @@ function with(f::Function, args...; kw...)
         newdefs[:legend] = false
     end
 
-  # dict to store old and new keyword args for anything that changes
-  olddefs = KW()
-  for k in keys(newdefs)
-    olddefs[k] = default(k)
-  end
-
-  # save the backend
-  if CURRENT_BACKEND.sym == :none
-    _pick_default_backend()
-  end
-  oldbackend = CURRENT_BACKEND.sym
-
-  for arg in args
-
-    # change backend?
-    if arg in backends()
-      backend(arg)
+    # dict to store old and new keyword args for anything that changes
+    olddefs = KW()
+    for k in keys(newdefs)
+        olddefs[k] = default(k)
     end
 
-    # # TODO: generalize this strategy to allow args as much as possible
-    # #       as in:  with(:gr, :scatter, :legend, :grid) do; ...; end
-    # # TODO: can we generalize this enough to also do something similar in the plot commands??
+    # save the backend
+    if CURRENT_BACKEND.sym == :none
+        _pick_default_backend()
+    end
+    oldbackend = CURRENT_BACKEND.sym
 
-    # k = :seriestype
-    # if arg in _allTypes
-    #   olddefs[k] = default(k)
-    #   newdefs[k] = arg
-    # elseif haskey(_typeAliases, arg)
-    #   olddefs[k] = default(k)
-    #   newdefs[k] = _typeAliases[arg]
-    # end
+    for arg in args
 
-    k = :legend
-    if arg in (k, :leg)
-      olddefs[k] = default(k)
-      newdefs[k] = true
+        # change backend?
+        if arg in backends()
+            backend(arg)
+        end
+
+        # TODO: generalize this strategy to allow args as much as possible
+        #       as in:  with(:gr, :scatter, :legend, :grid) do; ...; end
+        # TODO: can we generalize this enough to also do something similar in the plot commands??
+
+        # k = :seriestype
+        # if arg in _allTypes
+        #     olddefs[k] = default(k)
+        #     newdefs[k] = arg
+        # elseif haskey(_typeAliases, arg)
+        #     olddefs[k] = default(k)
+        #     newdefs[k] = _typeAliases[arg]
+        # end
+
+        k = :legend
+        if arg in (k, :leg)
+            olddefs[k] = default(k)
+            newdefs[k] = true
+        end
+
+        k = :grid
+        if arg == k
+            olddefs[k] = default(k)
+            newdefs[k] = true
+        end
     end
 
-    k = :grid
-    if arg == k
-      olddefs[k] = default(k)
-      newdefs[k] = true
+    # display(olddefs)
+    # display(newdefs)
+
+    # now set all those defaults
+    default(; newdefs...)
+
+    # call the function
+    ret = f()
+
+    # put the defaults back
+    default(; olddefs...)
+
+    # revert the backend
+    if CURRENT_BACKEND.sym != oldbackend
+        backend(oldbackend)
     end
-  end
 
-  # display(olddefs)
-  # display(newdefs)
-
-  # now set all those defaults
-  default(; newdefs...)
-
-  # call the function
-  ret = f()
-
-  # put the defaults back
-  default(; olddefs...)
-
-  # revert the backend
-  if CURRENT_BACKEND.sym != oldbackend
-    backend(oldbackend)
-  end
-
-  # return the result of the function
-  ret
+    # return the result of the function
+    ret
 end
 
 # ---------------------------------------------------------------
 # ---------------------------------------------------------------
 
 mutable struct DebugMode
-  on::Bool
+    on::Bool
 end
 const _debugMode = DebugMode(false)
 
 function debugplots(on = true)
-  _debugMode.on = on
+    _debugMode.on = on
 end
 
 debugshow(io, x) = show(io, x)
 debugshow(io, x::AbstractArray) = print(io, summary(x))
 
 function dumpdict(io::IO, plotattributes::AKW, prefix = "", alwaysshow = false)
-  _debugMode.on || alwaysshow || return
-  println(io)
-  if prefix != ""
-    println(io, prefix, ":")
-  end
-  for k in sort(collect(keys(plotattributes)))
-    @printf("%14s: ", k)
-    debugshow(io, plotattributes[k])
+    _debugMode.on || alwaysshow || return
+    println(io)
+    if prefix != ""
+        println(io, prefix, ":")
+    end
+    for k in sort(collect(keys(plotattributes)))
+        @printf("%14s: ", k)
+        debugshow(io, plotattributes[k])
+        println(io)
+    end
     println(io)
-  end
-  println(io)
 end
 DD(io::IO, plotattributes::AKW, prefix = "") = dumpdict(io, plotattributes, prefix, true)
 DD(plotattributes::AKW, prefix = "") = DD(stdout, plotattributes, prefix)
 
 function dumpcallstack()
-  error()  # well... you wanted the stacktrace, didn't you?!?
+    error()  # well... you wanted the stacktrace, didn't you?!?
 end
 
-# ---------------------------------------------------------------
-# ---------------------------------------------------------------
-# used in updating an existing series
-
-extendSeriesByOne(v::UnitRange{Int}, n::Int = 1) = isempty(v) ? (1:n) : (minimum(v):maximum(v)+n)
-extendSeriesByOne(v::AVec, n::Integer = 1)       = isempty(v) ? (1:n) : vcat(v, (1:n) + ignorenan_maximum(v))
-extendSeriesData(v::AbstractRange{T}, z::Real) where {T}        = extendSeriesData(float(collect(v)), z)
-extendSeriesData(v::AbstractRange{T}, z::AVec) where {T}        = extendSeriesData(float(collect(v)), z)
-extendSeriesData(v::AVec{T}, z::Real) where {T}         = (push!(v, convert(T, z)); v)
-extendSeriesData(v::AVec{T}, z::AVec) where {T}         = (append!(v, convert(Vector{T}, z)); v)
-
-
 # -------------------------------------------------------
 # NOTE: backends should implement the following methods to get/set the x/y/z data objects
 
@@ -908,33 +779,60 @@ Base.setindex!(plt::Plot, xy::Tuple{X,Y}, i::Integer) where {X,Y} = (setxy!(plt,
 Base.setindex!(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) where {X,Y,Z} = (setxyz!(plt, xyz, i); plt)
 
 # -------------------------------------------------------
-
 # operate on individual series
 
-function push_x!(series::Series, xi)
-    push!(series[:x], xi)
-    expand_extrema!(series[:subplot][:xaxis], xi)
-    return
-end
-function push_y!(series::Series, yi)
-    push!(series[:y], yi)
-    expand_extrema!(series[:subplot][:yaxis], yi)
-    return
-end
-function push_z!(series::Series, zi)
-    push!(series[:z], zi)
-    expand_extrema!(series[:subplot][:zaxis], zi)
-    return
+Base.push!(series::Series, args...) = extend_series!(series, args...)
+Base.append!(series::Series, args...) = extend_series!(series, args...)
+
+function extend_series!(series::Series, yi)
+    y = extend_series_data!(series, yi, :y)
+    x = extend_to_length!(series[:x], length(y))
+    expand_extrema!(series[:subplot][:xaxis], x)
+    return x, y
 end
 
-function Base.push!(series::Series, yi)
-    x = extendSeriesByOne(series[:x])
-    expand_extrema!(series[:subplot][:xaxis], x[end])
-    series[:x] = x
-    push_y!(series, yi)
+function extend_series!(series::Series, xi, yi)
+    x = extend_series_data!(series, xi, :x)
+    y = extend_series_data!(series, yi, :y)
+    return x, y
+end
+
+function extend_series!(series::Series, xi, yi, zi)
+    x = extend_series_data!(series, xi, :x)
+    y = extend_series_data!(series, yi, :y)
+    z = extend_series_data!(series, zi, :z)
+    return x, y, z
+end
+
+function extend_series_data!(series::Series, v, letter)
+    copy_series!(series, letter)
+    d = extend_by_data!(series[letter], v)
+    expand_extrema!(series[:subplot][Symbol(letter, :axis)], d)
+    return d
+end
+
+function copy_series!(series, letter)
+    plt = series[:plot_object]
+    for s in plt.series_list
+        for l in (:x, :y, :z)
+            if s !== series || l !== letter
+                if s[l] === series[letter]
+                    series[letter] = copy(series[letter])
+                end
+            end
+        end
+    end
+end
+
+extend_to_length!(v::AbstractRange, n) = range(first(v), step = step(v), length = n)
+function extend_to_length!(v::AbstractVector, n)
+    vmax = isempy(v) ? 0 : ignorenan_maximum(v)
+    extend_by_data!(v, vmax .+ (1:(n - length(v))))
+end
+extend_by_data!(v::AbstractVector, x) = isimmutable(v) ? vcat(v, x) : push!(v, x)
+function extend_by_data!(v::AbstractVector, x::AbstractVector)
+    isimmutable(v) ? vcat(v, x) : append!(v, x)
 end
-Base.push!(series::Series, xi, yi) = (push_x!(series,xi); push_y!(series,yi))
-Base.push!(series::Series, xi, yi, zi) = (push_x!(series,xi); push_y!(series,yi); push_z!(series,zi))
 
 # -------------------------------------------------------
 
@@ -968,59 +866,16 @@ end
 # -------------------------------------------------------
 # push/append for one series
 
-# push value to first series
-Base.push!(plt::Plot, y::Real) = push!(plt, 1, y)
-Base.push!(plt::Plot, x::Real, y::Real) = push!(plt, 1, x, y)
-Base.push!(plt::Plot, x::Real, y::Real, z::Real) = push!(plt, 1, x, y, z)
-
-# y only
-function Base.push!(plt::Plot, i::Integer, y::Real)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesByOne(xdata), extendSeriesData(ydata, y)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, y::AVec)
-    xdata, ydata = plt[i]
-    if !isa(xdata, UnitRange{Int})
-        error("Expected x is a UnitRange since you're trying to push a y value only")
-    end
-    plt[i] = (extendSeriesByOne(xdata, length(y)), extendSeriesData(ydata, y))
-    plt
-end
-
-# x and y
-function Base.push!(plt::Plot, i::Integer, x::Real, y::Real)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec)
-    @assert length(x) == length(y)
-    xdata, ydata = getxy(plt, i)
-    setxy!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y)), i)
-    plt
-end
-
-# x, y, and z
-function Base.push!(plt::Plot, i::Integer, x::Real, y::Real, z::Real)
-    # @show i, x, y, z
-    xdata, ydata, zdata = getxyz(plt, i)
-    # @show xdata, ydata, zdata
-    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
-    plt
-end
-function Base.append!(plt::Plot, i::Integer, x::AVec, y::AVec, z::AVec)
-    @assert length(x) == length(y) == length(z)
-    xdata, ydata, zdata = getxyz(plt, i)
-    setxyz!(plt, (extendSeriesData(xdata, x), extendSeriesData(ydata, y), extendSeriesData(zdata, z)), i)
-    plt
-end
+Base.push!(plt::Plot, args::Real...) = push!(plt, 1, args...)
+Base.push!(plt::Plot, i::Integer, args::Real...) = push!(plt.series_list[i], args...)
+Base.append!(plt::Plot, args::AbstractVector...) = append!(plt, 1, args...)
+Base.append!(plt::Plot, i::Integer, args::Real...) = append!(plt.series_list[i], args...)
 
 # tuples
-Base.push!(plt::Plot, xy::Tuple{X,Y}) where {X,Y}                  = push!(plt, 1, xy...)
-Base.push!(plt::Plot, xyz::Tuple{X,Y,Z}) where {X,Y,Z}             = push!(plt, 1, xyz...)
-Base.push!(plt::Plot, i::Integer, xy::Tuple{X,Y}) where {X,Y}      = push!(plt, i, xy...)
-Base.push!(plt::Plot, i::Integer, xyz::Tuple{X,Y,Z}) where {X,Y,Z} = push!(plt, i, xyz...)
+Base.push!(plt::Plot, t::Tuple) = push!(plt, 1, t...)
+Base.push!(plt::Plot, i::Integer, t::Tuple) = push!(plt, i, t...)
+Base.append!(plt::Plot, t::Tuple) = append!(plt, 1, t...)
+Base.append!(plt::Plot, i::Integer, t::Tuple) = append!(plt, i, t...)
 
 # -------------------------------------------------------
 # push/append for all series