Merge pull request #2556 from daschw/gr-box

Gr box
bump version
2020-04-10 08:49:07 +02:00 · 2020-04-10 08:31:03 +02:00 · 2020-04-10 08:05:36 +02:00 · 2020-04-09 21:37:52 +02:00 · 2020-04-09 18:13:28 +02:00 · 2020-04-09 17:56:54 +02:00
26 changed files with 878 additions and 422 deletions
@@ -9,3 +9,4 @@ deps/build.log
 deps/deps.jl
 Manifest.toml
 dev/
+test/tmpplotsave.hdf5
@@ -4,8 +4,8 @@ os:
  - linux
  # - osx
 julia:
+  - 1.0
  - 1
-  - 1.3
  - nightly

 matrix:
@@ -20,6 +20,9 @@ addons:
      - xauth
      - xvfb

+env:
+  - GKS_ENCODING="utf8"
+
 cache:
  directories:
  - $HOME/.julia/artifacts
@@ -32,7 +35,10 @@ before_install:
 notifications:
  email: true

+after_success:
+  - julia -e 'using Pkg; Pkg.add("Coverage"); using Coverage; Codecov.submit(process_folder())'
+
 script:
  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
  - if [[ `uname` = "Linux" ]]; then TESTCMD="xvfb-run julia"; else TESTCMD="julia"; fi
-  - $TESTCMD -e 'using Pkg; Pkg.pin(PackageSpec(name="FixedPointNumbers", version="0.7")); Pkg.build(); Pkg.test(coverage=true)'
+  - $TESTCMD -e 'using Pkg; Pkg.build(); Pkg.test(coverage=true)'
@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "0.29.9"
+version = "1.0.6"

 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -41,8 +41,8 @@ Measures = "0.3"
 NaNMath = "0.3"
 PGFPlotsX = "1.2.0"
 PlotThemes = "1"
-PlotUtils = "0.6.1"
-RecipesBase = "0.8"
+PlotUtils = "0.6.5"
+RecipesBase = "1"
 Reexport = "0.2"
 Requires = "0.5, 1.0"
 Showoff = "0.3.1"
@@ -56,7 +56,6 @@ Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
-LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
@@ -69,4 +68,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"

 [targets]
-test = ["FileIO", "GeometryTypes", "Gtk", "ImageMagick", "Images", "LaTeXStrings", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "Random", "RDatasets", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
+test = ["FileIO", "GeometryTypes", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "Random", "RDatasets", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
@@ -20,6 +20,7 @@
 [![][pkgeval-img]][pkgeval-url]
 [![][gitter-img]][gitter-url]
 [![][docs-img]][docs-url]
+[![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)

 #### Created by Tom Breloff (@tbreloff)

@@ -1,8 +1,7 @@
 environment:
  matrix:
-  # - julia_version: 0.7
+  - julia_version: 1.0
  - julia_version: 1
-  - julia_version: 1.3
  - julia_version: nightly

 platform:
@@ -33,10 +32,9 @@ install:
  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))

 build_script:
-  - C:\julia\bin\julia --project=C:\projects\plots-jl -e "using Pkg; Pkg.pin(PackageSpec(name="""FixedPointNumbers""", version="""0.7"""))"
-  - echo "%JL_BUILD_SCRIPT%"
+  - echo "%JL_TEST_SCRIPT%"
  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
- 
+
 test_script:
  - echo "%JL_TEST_SCRIPT%"
  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
@@ -0,0 +1,10 @@
+ignore:
+  - "src/backends/inspectdr.jl"
+  - "src/backends/orca.jl"
+  - "src/backends/pgfplots.jl"
+  - "src/backends/plotly.jl"
+  - "src/backends/plotlyjs.jl"
+  - "src/backends/pyplot.jl"
+  - "src/backends/web.jl"
+  - "src/fileio.jl"
+  - "src/ijulia.jl"
@@ -1,5 +1,9 @@
 module Plots

+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@optlevel"))
+    @eval Base.Experimental.@optlevel 1
+end
+
 const _current_plots_version = VersionNumber(split(first(filter(line -> occursin("version", line), readlines(normpath(@__DIR__, "..", "Project.toml")))), "\"")[2])

 using Reexport
@@ -71,6 +71,7 @@ function buildanimation(anim::Animation, fn::AbstractString,
                        is_animated_gif::Bool=true;
                        fps::Real = 20, loop::Integer = 0,
                        variable_palette::Bool=false,
+                        verbose=false,
                        show_msg::Bool=true)
    if length(anim.frames) == 0
        throw(ArgumentError("Cannot build empty animations"))
@@ -79,20 +80,23 @@ function buildanimation(anim::Animation, fn::AbstractString,
    fn = abspath(expanduser(fn))
    animdir = anim.dir
    framerate = ffmpeg_framerate(fps)
+    verbose_level = (verbose isa Int ? verbose :
+                        verbose ? 32  # "info"
+                                : 16) # "error"

    if is_animated_gif
        if variable_palette
            # generate a colorpalette for each frame for highest quality, but larger filesize
            palette="palettegen=stats_mode=single[pal],[0:v][pal]paletteuse=new=1"
-            ffmpeg_exe(`-v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
+            ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -lavfi "$palette" -y $fn`)
        else
            # generate a colorpalette first so ffmpeg does not have to guess it
-            ffmpeg_exe(`-v 0 -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
+            ffmpeg_exe(`-v $verbose_level -i $(animdir)/%06d.png -vf "palettegen=stats_mode=diff" -y "$(animdir)/palette.bmp"`)
            # then apply the palette to get better results
-            ffmpeg_exe(` -v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
+            ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -i "$(animdir)/palette.bmp" -lavfi "paletteuse=dither=sierra2_4a" -y $fn`)
        end
    else
-        ffmpeg_exe(`-v 0 -framerate $framerate -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
+        ffmpeg_exe(`-v $verbose_level -framerate $framerate -loop $loop -i $(animdir)/%06d.png -pix_fmt yuv420p -y $fn`)
    end

    show_msg && @info("Saved animation to ", fn)
@@ -89,7 +89,7 @@ const _arg_desc = KW(
 :foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
 :foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
 :color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
-:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
+:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` , `:inline` (note: only some may be supported in each backend)",
 :legendfontfamily         => "String or Symbol. Font family of legend entries.",
 :legendfontsize           => "Integer. Font pointsize of legend entries.",
 :legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
@@ -267,6 +267,7 @@ const _series_defaults = KW(
    :bar_edges         => false,
    :xerror            => nothing,
    :yerror            => nothing,
+    :zerror            => nothing,
    :ribbon            => nothing,
    :quiver            => nothing,
    :arrow             => nothing,   # allows for adding arrows to line/path... call `arrow(args...)`
@@ -450,15 +451,33 @@ const _initial_fontsizes = Dict(:titlefontsize  => _subplot_defaults[:titlefonts
                                :tickfontsize   => _axis_defaults[:tickfontsize],
                                :guidefontsize  => _axis_defaults[:guidefontsize])

-const _all_args = sort(collect(union(map(keys, _all_defaults)...)))
+const _internal_args =
+    [:plot_object, :series_plotindex, :markershape_to_add, :letter, :idxfilter]

-is_subplot_attr(k) = haskey(_subplot_defaults, k)
-is_series_attr(k) = haskey(_series_defaults, k)
-#is_axis_attr(k) = haskey(_axis_defaults_byletter, k)
-is_axis_attr(k) = haskey(_axis_defaults, Symbol(chop(string(k); head=1, tail=0)))
-is_axis_attr_noletter(k) = haskey(_axis_defaults, k)
+const _axis_args = sort(union(collect(keys(_axis_defaults))))
+const _series_args = sort(union(collect(keys(_series_defaults))))
+const _subplot_args = sort(union(collect(keys(_subplot_defaults))))
+const _plot_args = sort(union(collect(keys(_plot_defaults))))
+
+const _magic_axis_args = [:axis, :tickfont, :guidefont, :grid, :minorgrid]
+const _magic_subplot_args = [:titlefont, :legendfont, :legendtitlefont, ]
+const _magic_series_args = [:line, :marker, :fill]
+
+const _all_axis_args = sort(union([_axis_args; _magic_axis_args]))
+const _all_subplot_args = sort(union([_subplot_args; _magic_subplot_args]))
+const _all_series_args = sort(union([_series_args; _magic_series_args]))
+const _all_plot_args = _plot_args
+
+const _all_args =
+    sort([_all_axis_args; _all_subplot_args; _all_series_args; _all_plot_args])
+
+is_subplot_attr(k) = k in _all_subplot_args
+is_series_attr(k) = k in _all_series_args
+is_axis_attr(k) = Symbol(chop(string(k); head=1, tail=0)) in _all_axis_args
+is_axis_attr_noletter(k) = k in _all_axis_args

 RecipesBase.is_key_supported(k::Symbol) = is_attr_supported(k)
+is_default_attribute(k) = k in _internal_args || k in _all_args || is_axis_attr_noletter(k)

 # -----------------------------------------------------------------------------

@@ -550,17 +569,18 @@ add_aliases(:bins, :bin, :nbin, :nbins, :nb)
 add_aliases(:ribbon, :rib)
 add_aliases(:annotations, :ann, :anns, :annotate, :annotation)
 add_aliases(:xguide, :xlabel, :xlab, :xl)
-add_aliases(:xlims, :xlim, :xlimit, :xlimits)
+add_aliases(:xlims, :xlim, :xlimit, :xlimits, :xrange)
 add_aliases(:xticks, :xtick)
 add_aliases(:xrotation, :xrot, :xr)
 add_aliases(:yguide, :ylabel, :ylab, :yl)
-add_aliases(:ylims, :ylim, :ylimit, :ylimits)
+add_aliases(:ylims, :ylim, :ylimit, :ylimits, :yrange)
 add_aliases(:yticks, :ytick)
 add_aliases(:yrotation, :yrot, :yr)
 add_aliases(:zguide, :zlabel, :zlab, :zl)
 add_aliases(:zlims, :zlim, :zlimit, :zlimits)
 add_aliases(:zticks, :ztick)
 add_aliases(:zrotation, :zrot, :zr)
+add_aliases(:guidefontsize, :labelfontsize)
 add_aliases(:fill_z, :fillz, :fz, :surfacecolor, :surfacecolour, :sc, :surfcolor, :surfcolour)
 add_aliases(:legend, :leg, :key)
 add_aliases(:legendtitle, :legend_title, :labeltitle, :label_title, :leg_title, :key_title)
@@ -575,6 +595,7 @@ add_aliases(:color_palette, :palette)
 add_aliases(:overwrite_figure, :clf, :clearfig, :overwrite, :reuse)
 add_aliases(:xerror, :xerr, :xerrorbar)
 add_aliases(:yerror, :yerr, :yerrorbar, :err, :errorbar)
+add_aliases(:zerror, :zerr, :zerrorbar)
 add_aliases(:quiver, :velocity, :quiver2d, :gradient, :vectorfield)
 add_aliases(:normalize, :norm, :normed, :normalized)
 add_aliases(:show_empty_bins, :showemptybins, :showempty, :show_empty)
@@ -638,6 +659,7 @@ function default(k::Symbol)
        letter, key = axis_k
        return _axis_defaults_byletter[letter][key]
    end
+    k == :letter && return k # for type recipe processing
    k in _suppress_warnings || error("Unknown key: ", k)
 end

@@ -919,22 +941,6 @@ end
 function preprocessArgs!(plotattributes::AKW)
    replaceAliases!(plotattributes, _keyAliases)

-    # clear all axis stuff
-    # if haskey(plotattributes, :axis) && plotattributes[:axis] in (:none, nothing, false)
-    #     plotattributes[:ticks] = nothing
-    #     plotattributes[:foreground_color_border] = RGBA(0,0,0,0)
-    #     plotattributes[:foreground_color_axis] = RGBA(0,0,0,0)
-    #     plotattributes[:grid] = false
-    #     delete!(plotattributes, :axis)
-    # end
-    # for letter in (:x, :y, :z)
-    #     asym = Symbol(letter, :axis)
-    #     if haskey(plotattributes, asym) || plotattributes[asym] in (:none, nothing, false)
-    #         plotattributes[Symbol(letter, :ticks)] = nothing
-    #         plotattributes[Symbol(letter, :foreground_color_border)] = RGBA(0,0,0,0)
-    #     end
-    # end
-
    # handle axis args common to all axis
    args = pop_kw!(plotattributes, :axis, ())
    for arg in wraptuple(args)
@@ -992,13 +998,6 @@ function preprocessArgs!(plotattributes::AKW)
            processMinorGridArg!(plotattributes, arg, letter)
        end
    end
-    # fonts
-    for fontname in (:titlefont, :legendfont, :legendtitlefont)
-        args = pop_kw!(plotattributes, fontname, ())
-        for arg in wraptuple(args)
-            processFontArg!(plotattributes, fontname, arg)
-        end
-    end
    # handle font args common to all axes
    for fontname in (:tickfont, :guidefont)
        args = pop_kw!(plotattributes, fontname, ())
@@ -1017,6 +1016,26 @@ function preprocessArgs!(plotattributes::AKW)
            end
        end
    end
+    # handle axes args
+    for k in _axis_args
+        if haskey(plotattributes, k) && k !== :link
+            v = plotattributes[k]
+            for letter in (:x, :y, :z)
+                lk = Symbol(letter, k)
+                if !is_explicit(plotattributes, lk)
+                    plotattributes[lk] = v
+                end
+            end
+        end
+    end
+
+    # fonts
+    for fontname in (:titlefont, :legendfont, :legendtitlefont)
+        args = pop_kw!(plotattributes, fontname, ())
+        for arg in wraptuple(args)
+            processFontArg!(plotattributes, fontname, arg)
+        end
+    end

    # handle line args
    for arg in wraptuple(pop_kw!(plotattributes, :line, ()))
@@ -1219,7 +1238,7 @@ function convertLegendValue(val::Symbol)
        :best
    elseif val in (:no, :none)
        :none
-    elseif val in (:right, :left, :top, :bottom, :inside, :best, :legend, :topright, :topleft, :bottomleft, :bottomright, :outertopright, :outertopleft, :outertop, :outerright, :outerleft, :outerbottomright, :outerbottomleft, :outerbottom)
+    elseif val in (:right, :left, :top, :bottom, :inside, :best, :legend, :topright, :topleft, :bottomleft, :bottomright, :outertopright, :outertopleft, :outertop, :outerright, :outerleft, :outerbottomright, :outerbottomleft, :outerbottom, :inline)
        val
    else
        error("Invalid symbol for legend: $val")
@@ -1471,12 +1490,9 @@ function _update_axis(plt::Plot, sp::Subplot, plotattributes_in::AKW, letter::Sy
 end

 function _update_axis(axis::Axis, plotattributes_in::AKW, letter::Symbol, subplot_index::Int)
-    # grab magic args (for example `xaxis = (:flip, :log)`)
-    args = wraptuple(get(plotattributes_in, Symbol(letter, :axis), ()))
-
    # build the KW of arguments from the letter version (i.e. xticks --> ticks)
    kw = KW()
-    for k in keys(_axis_defaults)
+    for k in _all_axis_args
        # first get the args without the letter: `tickfont = font(10)`
        # note: we don't pop because we want this to apply to all axes! (delete after all have finished)
        if haskey(plotattributes_in, k)
@@ -1491,7 +1507,7 @@ function _update_axis(axis::Axis, plotattributes_in::AKW, letter::Symbol, subplo
    end

    # update the axis
-    attr!(axis, args...; kw...)
+    attr!(axis; kw...)
    return
 end

@@ -84,6 +84,9 @@ function attr!(axis::Axis, args...; kw...)
        process_axis_arg!(plotattributes, arg)
    end

+    # then preprocess keyword arguments
+    preprocessArgs!(KW(kw))
+
    # then override for any keywords... only those keywords that already exists in plotattributes
    for (k,v) in kw
        if haskey(plotattributes, k)
@@ -211,7 +211,7 @@ const _base_supported_args = [
    :seriestype,
    :seriescolor, :seriesalpha,
    :smooth,
-    :xerror, :yerror,
+    :xerror, :yerror, :zerror,
    :subplot,
    :x, :y, :z,
    :show, :size,
@@ -1043,6 +1043,13 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
            viewport_plotarea[3] += legendh + 0.04
        end
    end
+    if sp[:legend] == :inline
+        if sp[:yaxis][:mirror]
+            viewport_plotarea[1] += legendw
+        else
+            viewport_plotarea[2] -= legendw
+        end
+    end

    # fill in the plot area background
    bg = plot_color(sp[:background_color_inside])
@@ -1417,8 +1424,9 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
        end

        # border
-        intensity = sp[:framestyle] == :semi ? 0.5 : 1.0
+        intensity = sp[:framestyle] == :semi ? 0.5 : 1
        if sp[:framestyle] in (:box, :semi)
+            GR.setclip(0)
            gr_set_line(intensity, :solid, xaxis[:foreground_color_border])
            gr_set_transparency(xaxis[:foreground_color_border], intensity)
            gr_polyline(coords(xborder_segs)...)
@@ -1798,6 +1806,21 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
            gr_text(GR.wctondc(xi, yi)..., str)
        end

+        if sp[:legend] == :inline && should_add_to_legend(series)
+            gr_set_font(legendfont(sp))
+            gr_set_textcolor(plot_color(sp[:legendfontcolor]))
+            if sp[:yaxis][:mirror]
+                (_,i) = sp[:xaxis][:flip] ? findmax(x) : findmin(x)
+                GR.settextalign(GR.TEXT_HALIGN_RIGHT, GR.TEXT_VALIGN_HALF)
+                offset = -0.01
+            else
+                (_,i) = sp[:xaxis][:flip] ? findmin(x) : findmax(x)
+                GR.settextalign(GR.TEXT_HALIGN_LEFT, GR.TEXT_VALIGN_HALF)
+                offset = 0.01
+            end
+            (x_l,y_l) = GR.wctondc(x[i],y[i])
+            gr_text(x_l+offset,y_l,series[:label])
+        end
        GR.restorestate()
    end

@@ -1805,7 +1828,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
    hascolorbar(sp) && gr_draw_colorbar(cbar, sp, get_clims(sp))

    # add the legend
-    if sp[:legend] != :none
+    if !(sp[:legend] in(:none, :inline))
        GR.savestate()
        GR.selntran(0)
        GR.setscale(0)
@@ -104,14 +104,20 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
        end

        for sp in plt.subplots
-            bb = bbox(sp)
-            sp_width = width(bb)
-            sp_height = height(bb)
-            dx, dy = bb.x0
-            # TODO: does this hold at every scale?
-            if sp[:legend] in (:outertopright, nothing)
-                dx *= 1.2
-            end
+            bb1 = sp.plotarea
+            bb2 = bbox(sp)
+            sp_width = width(bb2)
+            sp_height = height(bb2)
+            dx, dy = bb2.x0
+            lpad = leftpad(sp) + sp[:left_margin]
+            rpad = rightpad(sp) + sp[:right_margin]
+            tpad = toppad(sp) + sp[:top_margin]
+            bpad = bottompad(sp) + sp[:bottom_margin]
+            dx += lpad
+            dy += tpad
+            axis_height = sp_height - (tpad + bpad)
+            axis_width = sp_width - (rpad + lpad)
+
            cstr = plot_color(sp[:background_color_legend])
            a = alpha(cstr)
            fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
@@ -164,9 +170,9 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                "xshift" => string(dx),
                "yshift" => string(-dy),
            )
-            sp_width > 0 * mm ? push!(axis_opt, "width" => string(sp_width)) :
+            sp_width > 0 * mm ? push!(axis_opt, "width" => string(axis_width)) :
            nothing
-            sp_height > 0 * mm ? push!(axis_opt, "height" => string(sp_height)) :
+            sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) :
            nothing
            # legend position
            if sp[:legend] isa Tuple
@@ -174,9 +180,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                push!(axis_opt["legend style"], "at={($x, $y)}")
            else
                push!(
-                    axis_opt,
-                    "legend pos" =>
-                        get(_pgfplotsx_legend_pos, sp[:legend], "outer north east"),
+                    axis_opt["legend style"],
+                        get(_pgfplotsx_legend_pos, sp[:legend], ("at" => string((1.02, 1)), "anchor" => "north west"))...
                )
            end
            for letter in (:x, :y, :z)
@@ -352,17 +357,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                            series_index,
                        )
                    end
-                    # add series annotations
-                    anns = series[:series_annotations]
-                    for (xi, yi, str, fnt) in EachAnn(anns, series[:x], series[:y])
-                        pgfx_add_annotation!(
-                            axis,
-                            xi,
-                            yi,
-                            PlotText(str, fnt),
-                            pgfx_thickness_scaling(series),
-                        )
-                    end
                    # add to legend?
                    if sp[:legend] != :none
                        leg_entry = if opt[:label] isa AVec
@@ -388,15 +382,26 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                        end
                    end
                end # for segments
-                # add subplot annotations
-                for ann in sp[:annotations]
+                # add series annotations
+                anns = series[:series_annotations]
+                for (xi, yi, str, fnt) in EachAnn(anns, series[:x], series[:y])
                    pgfx_add_annotation!(
                        axis,
-                        locate_annotation(sp, ann...)...,
-                        pgfx_thickness_scaling(sp),
+                        xi,
+                        yi,
+                        PlotText(str, fnt),
+                        pgfx_thickness_scaling(series),
                    )
                end
            end # for series
+            # add subplot annotations
+            for ann in sp[:annotations]
+                pgfx_add_annotation!(
+                    axis,
+                    locate_annotation(sp, ann...)...,
+                    pgfx_thickness_scaling(sp),
+                )
+            end
            push!(the_plot, axis)
            if length(plt.o.the_plot.elements) > 0
                plt.o.the_plot.elements[1] = the_plot
@@ -405,6 +410,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
            end
        end # for subplots
        pgfx_plot.is_created = true
+        pgfx_plot.was_shown = false
    end # if
    return pgfx_plot
 end
@@ -604,22 +610,22 @@ const _pgfplotsx_markers = KW(
 )

 const _pgfplotsx_legend_pos = KW(
-    :top => "north",
-    :bottom => "south",
-    :left => "west",
-    :right => "east",
-    :bottomleft => "south west",
-    :bottomright => "south east",
-    :topright => "north east",
-    :topleft => "north west",
-    :outertop => "north",
-    :outerbottom => "outer south",
-    :outerleft => "outer west",
-    :outerright => "outer east",
-    :outerbottomleft => "outer south west",
-    :outerbottomright => "outer south east",
-    :outertopright => "outer north east",
-    :outertopleft => "outer north west",
+    :top => ("at" => string((0.5, 0.98)), "anchor" => "north"),
+    :bottom => ("at" => string((0.5, 0.02)), "anchor" => "south"),
+    :left => ("at" => string((0.02, 0.5)), "anchor" => "west"),
+    :right => ("at" => string((0.98, 0.5)), "anchor" => "east"),
+    :bottomleft => ("at" => string((0.02, 0.02)), "anchor" => "south west"),
+    :bottomright => ("at" => string((0.98, 0.02)), "anchor" => "south east"),
+    :topright => ("at" => string((0.98, 0.98)), "anchor" => "north east"),
+    :topleft => ("at" => string((-0.02, 0.98)), "anchor" => "north west"),
+    :outertop => ("at" => string((0.5, 1.02)), "anchor" => "south"),
+    :outerbottom => ("at" => string((0.5, -0.02)), "anchor" => "north"),
+    :outerleft => ("at" => string((-0.02, 0.5)), "anchor" => "east"),
+    :outerright => ("at" => string((1.02, 0.5)), "anchor" => "west"),
+    :outerbottomleft => ("at" => string((-0.02, -0.02)), "anchor" => "north east"),
+    :outerbottomright => ("at" => string((1.02, -0.02)), "anchor" => "north west"),
+    :outertopright => ("at" => string((1.02, 1)), "anchor" => "north west"),
+    :outertopleft => ("at" => string((-0.02, 1)), "anchor" => "north east"),
 )

 const _pgfx_framestyles = [:box, :axes, :origin, :zerolines, :grid, :none]
@@ -900,6 +906,15 @@ function pgfx_sanitize_string(s::AbstractString)
    s = replace(s, r"\\?\%" => "\\%")
    s = replace(s, r"\\?\_" => "\\_")
    s = replace(s, r"\\?\&" => "\\&")
+    s = replace(s, r"\\?\{" => "\\{")
+    s = replace(s, r"\\?\}" => "\\}")
+end
+@require LaTeXStrings = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" begin
+    using .LaTeXStrings
+    function pgfx_sanitize_string(s::LaTeXString)
+        s = replace(s, r"\\?\#" => "\\#")
+        s = replace(s, r"\\?\%" => "\\%")
+    end
 end
 function pgfx_sanitize_plot!(plt)
        for (key, value) in plt.attr
@@ -998,6 +1013,8 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
    # ticks on or off
    if axis[:ticks] in (nothing, false, :none) || framestyle == :none
        push!(opt, "$(letter)majorticks" => "false")
+    elseif framestyle in (:grid, :zerolines)
+        push!(opt, "$letter tick style" => PGFPlotsX.Options("draw" => "none"))
    end

    # grid on or off
@@ -1013,6 +1030,7 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
    push!(opt, string(letter, :min) => lims[1], string(letter, :max) => lims[2])

    if !(axis[:ticks] in (nothing, false, :none, :native)) && framestyle != :none
+        # ticks
        ticks = get_ticks(sp, axis)
        #pgf plot ignores ticks with angle below 90 when xmin = 90 so shift values
        tick_values =
@@ -1078,6 +1096,37 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
                axis[:gridstyle],
            ),
        )
+
+        # minor ticks
+        # NOTE: PGFPlots would provide "minor x ticks num", but this only places minor ticks
+        #       between major ticks and not outside first and last tick to the axis limits.
+        #       Hence, we hack around with extra ticks. Unfortunately this conflicts with
+        #       `:zerolines` framestyle hack. So minor ticks are not working with
+        #       `:zerolines`.
+        minor_ticks = get_minor_ticks(sp, axis, ticks)
+        if minor_ticks !== nothing
+            minor_ticks =
+                ispolar(sp) && letter == :x ? [rad2deg.(minor_ticks)[3:end]..., 360, 405] :
+                minor_ticks
+            push!(
+                opt,
+                string("extra ", letter, " ticks") => string("{", join(minor_ticks, ","), "}"),
+            )
+            push!(opt, string("extra ", letter, " tick labels") => "")
+            push!(
+                opt,
+                string("extra ", letter, " tick style") => PGFPlotsX.Options(
+                    "grid" => axis[:minorgrid] ? "major" : "none",
+                    string(letter, " grid style") => pgfx_linestyle(
+                        pgfx_thickness_scaling(sp) * axis[:minorgridlinewidth],
+                        axis[:foreground_color_minor_grid],
+                        axis[:minorgridalpha],
+                        axis[:minorgridstyle],
+                    ),
+                    "major tick length" => axis[:minorticks] ? "0.1cm" : "0"
+                ),
+            )
+        end
    end

    # framestyle
@@ -1099,7 +1148,7 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
            opt,
            string("extra ", letter, " tick style") => PGFPlotsX.Options(
                "grid" => "major",
-                "major grid style" => pgfx_linestyle(
+                string(letter, " grid style") => pgfx_linestyle(
                    pgfx_thickness_scaling(sp),
                    axis[:foreground_color_border],
                    1.0,
@@ -1129,12 +1178,12 @@ end
 # Set the (left, top, right, bottom) minimum padding around the plot area
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot{PGFPlotsXBackend})
-    # TODO: make padding more intelligent
-    # TODO: how to include margins properly?
-    # sp.minpad = (50mm + sp[:left_margin],
-    #              0mm + sp[:top_margin],
-    #              50mm + sp[:right_margin],
-    #              0mm + sp[:bottom_margin])
+    leg = sp[:legend]
+    if leg in (:best, :outertopright, :outerright, :outerbottomright) || (leg isa Tuple && leg[1] >= 1)
+        sp.minpad = (0mm, 0mm, 5mm, 0mm)
+    else
+        sp.minpad = (0mm, 0mm, 0mm, 0mm)
+    end
 end

 function _create_backend_figure(plt::Plot{PGFPlotsXBackend})
@@ -42,8 +42,8 @@ _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))

@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
    function WebIO.render(plt::Plot{PlotlyJSBackend})
-        prepare_output(plt)
-        WebIO.render(plt.o)
+        plt_html = sprint(show, MIME("text/html"), plt)
+        return WebIO.render(WebIO.dom"div"(innerHTML=plt_html))
    end
 end

@@ -594,7 +594,9 @@ function process_annotation(sp::Subplot, xs, ys, labs, font = font())
    xlength = length(methods(length, (typeof(xs),))) == 0 ? 1 : length(xs)
    ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys)
    for i in 1:max(xlength, ylength, length(labs))
-        x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+      x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+        x = typeof(x) <: TimeType ? Dates.value(x) : x  
+        y = typeof(y) <: TimeType ? Dates.value(y) : y  
        if lab == :auto
            alphabet = "abcdefghijklmnopqrstuvwxyz"
            push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
@@ -661,8 +663,8 @@ Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])

 Base.Array(surf::Surface) = surf.surf

-for f in (:length, :size)
-  @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
+for f in (:length, :size, :axes)
+    @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
 end
 Base.copy(surf::Surface) = Surface(copy(surf.surf))
 Base.eltype(surf::Surface{T}) where {T} = eltype(T)
@@ -889,6 +889,100 @@ const _examples = PlotExample[
            end,
        ],
    ),
+    PlotExample(
+        "Setting defaults and font arguments",
+        "",
+        [
+            quote
+                begin
+                    using Plots
+                    default(
+                        titlefont = (20, "times"),
+                        legendfontsize = 18,
+                        guidefont = (18, :darkgreen),
+                        tickfont = (12, :orange),
+                        guide = "x",
+                        framestyle = :zerolines,
+                        yminorgrid = true
+                    )
+                    plot(
+                        [sin, cos],
+                        -2π,
+                        2π,
+                        label = ["sin(θ)" "cos(θ)"],
+                        title = "Trigonometric Functions",
+                        xlabel = "θ",
+                        linewidth = 2,
+                        legend = :outertopleft,
+                    )
+                end
+            end,
+        ],
+    ),
+    PlotExample(
+        "Heatmap with DateTime axis",
+        "",
+        [
+            quote
+                begin
+                    using Dates
+                    z = rand(5, 5)
+                    x = DateTime.(2016:2020)
+                    y = 1:5
+                    heatmap(x, y, z)
+                end
+            end,
+        ],
+    ),
+    PlotExample(
+        "Linked axes",
+        "",
+        [
+            quote
+                begin
+                    x = -5:0.1:5
+                    plot(plot(x, x->x^2), plot(x, x->sin(x)), layout = 2, link = :y)
+                end
+            end,
+        ],
+    ),
+    PlotExample(
+        "Error bars and array type recipes",
+        "",
+        [
+            quote
+                begin
+                    struct Measurement <: Number
+                        val::Float64
+                        err::Float64
+                    end
+                    value(m::Measurement) = m.val
+                    uncertainty(m::Measurement) = m.err
+
+                    @recipe function f(::Type{T}, m::T) where T <: AbstractArray{<:Measurement}
+                        if !(get(plotattributes, :seriestype, :path) in [:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image])
+                            error_sym = Symbol(plotattributes[:letter], :error)
+                            plotattributes[error_sym] = uncertainty.(m)
+                        end
+                        value.(m)
+                    end
+
+                    x = Measurement.(10sort(rand(10)), rand(10))
+                    y = Measurement.(10sort(rand(10)), rand(10))
+                    z = Measurement.(10sort(rand(10)), rand(10))
+                    surf = Measurement.((1:10) .* (1:10)', rand(10,10))
+
+                    plot(
+                        scatter(x, [x y], msw = 0),
+                        scatter(x, y, z, msw = 0),
+                        heatmap(x, y, surf),
+                        wireframe(x, y, surf),
+                        legend = :topleft
+                    )
+                end
+            end,
+        ],
+    ),
 ]

 # Some constants for PlotDocs and PlotReferenceImages
@@ -901,6 +995,7 @@ _backend_skips = Dict(
    :pgfplots => [2, 5, 6, 10, 16, 20, 22, 23, 25, 28, 30, 31, 34, 37, 38, 39],
    :pgfplotsx => [ 6, # images
                    10, # histogram2d
+                    16, # pgfplots thinks the upper panel is too small
                    22, # contourf
                    23, # pie
                    32, # spy
@@ -1,4 +1,28 @@
+# Error for aliases used in recipes
+function warn_on_recipe_aliases!(plotattributes, recipe_type, args...)
+    for k in keys(plotattributes)
+        if !is_default_attribute(k)
+            dk = get(_keyAliases, k, k)
+            if k !== dk
+                @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`."
+            end
+            plotattributes[dk] = pop_kw!(plotattributes, k)
+        end
+    end
+end
+function warn_on_recipe_aliases!(v::AbstractVector, recipe_type, args...)
+    foreach(x -> warn_on_recipe_aliases!(x, recipe_type, args...), v)
+end
+function warn_on_recipe_aliases!(rd::RecipeData, recipe_type, args...)
+    warn_on_recipe_aliases!(rd.plotattributes, recipe_type, args...)
+end

+function signature_string(::Type{Val{:user}}, args...)
+    return string("(::", join(string.(typeof.(args)), ", ::"), ")")
+end
+signature_string(::Type{Val{:type}}, T) = "(::Type{$T}, ::$T)"
+signature_string(::Type{Val{:plot}}, st) = "(::Type{Val{:$st}}, ::AbstractPlot)"
+signature_string(::Type{Val{:series}}, st) = "(::Type{Val{:$st}}, x, y, z)"

 # ------------------------------------------------------------------
 # preprocessing
@@ -40,14 +64,8 @@ function _preprocess_args(plotattributes::AKW, args, still_to_process::Vector{Re
    # remove subplot and axis args from plotattributes... they will be passed through in the kw_list
    if !isempty(args)
        for (k,v) in plotattributes
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter[:x],
-                            _axis_defaults_byletter[:y],
-                            _axis_defaults_byletter[:z])
-                if haskey(defdict, k)
-                    reset_kw!(plotattributes, k)
-                end
+            if k in _all_subplot_args || k in _all_axis_args
+                reset_kw!(plotattributes, k)
            end
        end
    end
@@ -82,7 +100,11 @@ function _process_userrecipes(plt::Plot, plotattributes::AKW, args)
        if isempty(next_series.args)
            _process_userrecipe(plt, kw_list, next_series)
        else
-            rd_list = RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...)
+            rd_list = RecipesBase.apply_recipe(
+                next_series.plotattributes,
+                next_series.args...
+            )
+            warn_on_recipe_aliases!(rd_list, :user, next_series.args...)
            prepend!(still_to_process,rd_list)
        end
    end
@@ -137,7 +159,7 @@ end
 function _add_errorbar_kw(kw_list::Vector{KW}, kw::AKW)
    # handle error bars by creating new recipedata data... these will have
    # the same recipedata index as the recipedata they are copied from
-    for esym in (:xerror, :yerror)
+    for esym in (:xerror, :yerror, :zerror)
        if get(kw, esym, nothing) !== nothing
            # we make a copy of the KW and apply an errorbar recipe
            errkw = copy(kw)
@@ -184,6 +206,7 @@ function _process_plotrecipe(plt::Plot, kw::AKW, kw_list::Vector{KW}, still_to_p
        st = kw[:seriestype]
        st = kw[:seriestype] = get(_typeAliases, st, st)
        datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
+        warn_on_recipe_aliases!(datalist, :plot, st)
        for data in datalist
            preprocessArgs!(data.plotattributes)
            if data.plotattributes[:seriestype] == st
@@ -408,7 +431,9 @@ function _process_seriesrecipe(plt::Plot, plotattributes::AKW)

    else
        # get a sub list of series for this seriestype
-        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, plotattributes[:x], plotattributes[:y], plotattributes[:z])
+        x, y, z = plotattributes[:x], plotattributes[:y], plotattributes[:z]
+        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, x, y, z)
+        warn_on_recipe_aliases!(datalist, :series, st)

        # assuming there was no error, recursively apply the series recipes
        for data in datalist
@@ -1,66 +1,67 @@
 function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
    isdefined(Plots, Symbol("#@layout")) && precompile(Tuple{getfield(Plots, Symbol("#@layout")), LineNumberNode, Module, Expr})
-    isdefined(Plots, Symbol("#kw##_make_hist")) && precompile(Tuple{getfield(Plots, Symbol("#kw##_make_hist")), NamedTuple{(:normed, :weights), Tuple{Bool, Array{Int64, 1}}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
-    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{(: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{(: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{(: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})
-    isdefined(Plots, Symbol("#kw##attr!")) && precompile(Tuple{getfield(Plots, Symbol("#kw##attr!")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
-    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##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})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Array{Int64, 1}}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :ticks), Tuple{Bool, Nothing}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, ColorTypes.RGBA{Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:rotation,), Tuple{Int64}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:scale, :guide), Tuple{Symbol, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#contour##kw")) && precompile(Tuple{getfield(Plots, Symbol("#contour##kw")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#default##kw")) && precompile(Tuple{getfield(Plots, Symbol("#default##kw")), NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}}, typeof(Plots.default)})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), 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("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    isdefined(Plots, Symbol("#gr_set_font##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_set_font##kw")), NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}}, typeof(Plots.gr_set_font), Plots.Font})
+    isdefined(Plots, Symbol("#heatmap##kw")) && precompile(Tuple{getfield(Plots, Symbol("#heatmap##kw")), NamedTuple{(:aspect_ratio,), Tuple{Int64}}, typeof(Plots.heatmap), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#histogram##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram##kw")), NamedTuple{(:bins, :weights), Tuple{Symbol, Array{Int64, 1}}}, typeof(Plots.histogram), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), 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("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), NamedTuple{(:nbins,), Tuple{Int64}}, typeof(Plots.histogram2d), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#hline!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#hline!##kw")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}})
+    isdefined(Plots, Symbol("#lens!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#lens!##kw")), 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("#pie##kw")) && precompile(Tuple{getfield(Plots, Symbol("#pie##kw")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String})
+    isdefined(Plots, Symbol("#portfoliocomposition##kw")) && precompile(Tuple{getfield(Plots, Symbol("#portfoliocomposition##kw")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), 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("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), 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("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), 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("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), 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("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
+    isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), 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_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_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._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Any, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{Float64, 1}, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Array{T, 1} where T, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Array{Function, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, Plots.Surface{Array{Float64, 2}}, Symbol})
+    precompile(Tuple{typeof(Plots._apply_type_recipe), Base.Dict{Symbol, Any}, typeof(identity), 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})
@@ -106,6 +107,7 @@ function _precompile_()
    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{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
    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}}})
@@ -128,6 +130,7 @@ function _precompile_()
    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{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._expand_seriestype_array), Base.Dict{Symbol, Any}, Tuple{Plots.GroupBy, Array{Function, 1}, Float64, Float64}})
    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}}})
@@ -169,6 +172,7 @@ function _precompile_()
    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{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
    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}}})
@@ -193,6 +197,7 @@ function _precompile_()
    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{Function, 1}, Float64, Float64}})
    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}}})
@@ -212,6 +217,7 @@ function _precompile_()
    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._postprocess_axis_args!), Base.Dict{Symbol, Any}, Symbol})
    precompile(Tuple{typeof(Plots._prepare_annotations), Plots.Subplot{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})
@@ -225,6 +231,7 @@ function _precompile_()
    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{Function, 1}, Array{Float64, 1}}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}, 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}})
@@ -242,6 +249,7 @@ function _precompile_()
    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{Plots.Spy}, Array{RecipesBase.RecipeData, 1}})
    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}, Array{RecipesBase.RecipeData, 1}})
    precompile(Tuple{typeof(Plots._preprocess_args), Base.Dict{Symbol, Any}, Tuple{}, Array{RecipesBase.RecipeData, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_axis_args!), Base.Dict{Symbol, Any}})
    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Float64, 1}, Array{Float64, 1}})
    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Array{Int64, 1}, Array{Float64, 1}})
    precompile(Tuple{typeof(Plots._preprocess_barlike), Plots.Attr, Base.OneTo{Int64}, Array{Float64, 1}})
@@ -262,6 +270,7 @@ function _precompile_()
    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{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._process_userrecipes), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
    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}}})
@@ -286,6 +295,7 @@ function _precompile_()
    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{Function, 1}, Float64, Float64}})
    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}}})
@@ -305,6 +315,7 @@ function _precompile_()
    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._scaled_adapted_grid), typeof(identity), Symbol, Symbol, Float64, Float64})
    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}})
@@ -357,7 +368,6 @@ function _precompile_()
    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.EmptyLayout, Symbol, Symbol})
    precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol})
    precompile(Tuple{typeof(Plots.autopick), Array{ColorTypes.RGBA{Float64}, 1}, Int64})
@@ -392,6 +402,7 @@ function _precompile_()
    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_x), Nothing, Plots.Surface{Array{Float64, 2}}, Nothing})
    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}, typeof(identity), Nothing})
@@ -399,21 +410,19 @@ function _precompile_()
    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.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Plots.Surface{Array{Float64, 2}}, Nothing})
    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing})
+    precompile(Tuple{typeof(Plots.compute_xyz), Base.StepRange{Int64, Int64}, Plots.Surface{Array{Float64, 2}}, 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.compute_xyz), Nothing, Plots.Surface{Array{Float64, 2}}, 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})
    precompile(Tuple{typeof(Plots.convertLegendValue), Symbol})
-    precompile(Tuple{typeof(Plots.convertToAnyVector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}})
-    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), Int64, Base.Dict{Symbol, Any}})
    precompile(Tuple{typeof(Plots.convert_sci_unicode), String})
    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})
@@ -421,6 +430,10 @@ function _precompile_()
    precompile(Tuple{typeof(Plots.create_grid), Symbol})
    precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
    precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
+    precompile(Tuple{typeof(Plots.default), Symbol, Bool})
+    precompile(Tuple{typeof(Plots.default), Symbol, Int64})
+    precompile(Tuple{typeof(Plots.default), Symbol, String})
+    precompile(Tuple{typeof(Plots.default), Symbol, Symbol})
    precompile(Tuple{typeof(Plots.default), Symbol})
    precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis})
    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{String, 1}})
@@ -603,6 +616,8 @@ function _precompile_()
    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_axis_attr_noletter), Symbol})
+    precompile(Tuple{typeof(Plots.is_default_attribute), 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})
@@ -610,11 +625,13 @@ function _precompile_()
    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_series_attr), Symbol})
    precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, 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_subplot_attr), Symbol})
    precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}})
    precompile(Tuple{typeof(Plots.iscontour), Plots.Series})
    precompile(Tuple{typeof(Plots.isijulia)})
@@ -673,7 +690,6 @@ 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.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})
@@ -749,6 +765,9 @@ function _precompile_()
    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool})
    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64})
    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, String})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, 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})
@@ -766,6 +785,7 @@ function _precompile_()
    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.processMinorGridArg!), Base.Dict{Symbol, Any}, Bool, 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})
@@ -796,6 +816,15 @@ function _precompile_()
    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.series_vector), Array{Any, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Array{Float64, 1}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Array{T, 1} where T, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Float64, 2}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Function, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Real, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Int64}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), Array{Union{Base.Missing, Number}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.series_vector), typeof(identity), Base.Dict{Symbol, Any}})
    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})
@@ -872,8 +901,184 @@ function _precompile_()
    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.PlotlyBackend, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, 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.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{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.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, 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.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Array{RecipesBase.RecipeData, 1}, Symbol, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, 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.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{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.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, 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.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Base.Dict{Symbol, Any}, Symbol, Type{Int}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), Plots.Attr, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Any, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}, Array{Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, 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.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{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.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Any, 1}, Array{Any, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Array{T, 1} where T, 1}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Float64, 1}, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{Int64, 1}, Array{Real, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Array{String, 1}, Array{String, 1}, Plots.Surface{Array{Float64, 2}}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, 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.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Base.StepRange{Int64, Int64}, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, Array{Function, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Int64, typeof(Base.log), Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Array{T, 1} where T, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Int64, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Array{Union{Base.Missing, Int64}, 1}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{DataType, Nothing, Base.UnitRange{Int64}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, Array{Function, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Int64, typeof(Base.log)}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Nothing, Array{Float64, 2}, Nothing}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.GroupBy, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots.warn_on_recipe_aliases!), RecipesBase.RecipeData, Symbol, Tuple{typeof(Base.log), Int64}})
    precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})
-    precompile(Tuple{typeof(Plots.wrap_surfaces), Base.Dict{Symbol, Any}})
+    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}}})
@@ -888,6 +1093,7 @@ function _precompile_()
    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}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, String}})
    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}})
    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Symbol}})
    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol}})
@@ -1012,49 +1012,62 @@ function error_zipit(ebar)
    end
 end

-function error_coords(xorig, yorig, ebar)
-    # init empty x/y, and zip errors if passed Tuple{Vector,Vector}
-    x, y = Array{float_extended_type(xorig)}(undef, 0), Array{Float64}(undef, 0)
-    # for each point, create a line segment from the bottom to the top of the errorbar
-    for i = 1:max(length(xorig), length(yorig))
-        xi = _cycle(xorig, i)
-        yi = _cycle(yorig, i)
-        ebi = _cycle(ebar, i)
-        nanappend!(x, [xi, xi])
-        e1, e2 = if istuple(ebi)
-            first(ebi), last(ebi)
-        elseif isscalar(ebi)
-            ebi, ebi
-        else
-            error("unexpected ebi type $(typeof(ebi)) for errorbar: $ebi")
+error_tuple(x) = x, x
+error_tuple(x::Tuple) = x
+
+function error_coords(errorbar, errordata, otherdata...)
+    ed = Vector{float_extended_type(errordata)}(undef, 0)
+    od = [Float64[] for _ in otherdata]
+    for (i, edi) in enumerate(errordata)
+        for (j, odj) in enumerate(otherdata)
+            odi = _cycle(odj, i)
+            nanappend!(od[j], [odi, odi])
        end
-        nanappend!(y, [yi - e1, yi + e2])
+        e1, e2 = error_tuple(_cycle(errorbar, i))
+        nanappend!(ed, [edi - e1, edi + e2])
    end
-    x, y
+    return (ed, od...)
 end

 # we will create a series of path segments, where each point represents one
 # side of an errorbar
-@recipe function f(::Type{Val{:yerror}}, x, y, z)
-    error_style!(plotattributes)
-    markershape := :hline
-    plotattributes[:x], plotattributes[:y] = error_coords(
-        plotattributes[:x],
-        plotattributes[:y],
-        error_zipit(plotattributes[:yerror]),
-    )
-    ()
-end
-@deps yerror path

@recipe function f(::Type{Val{:xerror}}, x, y, z)
    error_style!(plotattributes)
    markershape := :vline
-    plotattributes[:y], plotattributes[:x] = error_coords(
-        plotattributes[:y],
-        plotattributes[:x],
-        error_zipit(plotattributes[:xerror]),
-    )
+    xerr = error_zipit(plotattributes[:xerror])
+    if z === nothing
+        plotattributes[:x], plotattributes[:y] = error_coords(xerr, x, y)
+    else
+        plotattributes[:x], plotattributes[:y], plotattributes[:z] =
+            error_coords(xerr, x, y, z)
+    end
+    ()
+end
+@deps xerror path
+
+@recipe function f(::Type{Val{:yerror}}, x, y, z)
+    error_style!(plotattributes)
+    markershape := :hline
+    yerr = error_zipit(plotattributes[:yerror])
+    if z === nothing
+        plotattributes[:y], plotattributes[:x] = error_coords(yerr, y, x)
+    else
+        plotattributes[:y], plotattributes[:x], plotattributes[:z] =
+            error_coords(yerr, y, x, z)
+    end
+    ()
+end
+@deps yerror path
+
+@recipe function f(::Type{Val{:zerror}}, x, y, z)
+    error_style!(plotattributes)
+    markershape := :hline
+    if z !== nothing
+        zerr = error_zipit(plotattributes[:zerror])
+        plotattributes[:z], plotattributes[:x], plotattributes[:y] =
+            error_coords(zerr, z, x, y)
+    end
    ()
 end
@deps xerror path
@@ -1261,8 +1274,8 @@ end
    yflip := true
    aspect_ratio := 1
    rs, cs, zs = findnz(z.surf)
-    xlim := ignorenan_extrema(cs)
-    ylim := ignorenan_extrema(rs)
+    xlims := ignorenan_extrema(cs)
+    ylims := ignorenan_extrema(rs)
    if plotattributes[:markershape] == :none
        markershape := :circle
    end
@@ -20,37 +20,38 @@ function prepareSeriesData(a::AbstractArray{<:MaybeNumber})
    f = isimmutable(a) ? replace : replace!
    a = f(x -> ismissing(x) || isinf(x) ? NaN : x, map(float, a))
 end
+prepareSeriesData(a::AbstractArray{<:Missing}) = fill(NaN, axes(a))
 prepareSeriesData(a::AbstractArray{<:MaybeString}) = replace(x -> ismissing(x) ? "" : x, a)
 prepareSeriesData(s::Surface{<:AMat{<:MaybeNumber}}) = Surface(prepareSeriesData(s.surf))
 prepareSeriesData(s::Surface) = s  # non-numeric Surface, such as an image
 prepareSeriesData(v::Volume) = Volume(prepareSeriesData(v.v), v.x_extents, v.y_extents, v.z_extents)

 # default: assume x represents a single series
-convertToAnyVector(x, plotattributes) = Any[prepareSeriesData(x)]
+series_vector(x, plotattributes) = [prepareSeriesData(x)]

 # fixed number of blank series
-convertToAnyVector(n::Integer, plotattributes) = Any[zeros(0) for i in 1:n]
+series_vector(n::Integer, plotattributes) = [zeros(0) for i in 1:n]

 # vector of data points is a single series
-convertToAnyVector(v::AVec{<:DataPoint}, plotattributes) = Any[prepareSeriesData(v)]
+series_vector(v::AVec{<:DataPoint}, plotattributes) = [prepareSeriesData(v)]

 # list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, plotattributes)
+function series_vector(v::AVec, plotattributes)
    if all(x -> x isa MaybeNumber, v)
-        convertToAnyVector(Vector{MaybeNumber}(v), plotattributes)
+        series_vector(Vector{MaybeNumber}(v), plotattributes)
    elseif all(x -> x isa MaybeString, v)
-        convertToAnyVector(Vector{MaybeString}(v), plotattributes)
+        series_vector(Vector{MaybeString}(v), plotattributes)
    else
-        vcat((convertToAnyVector(vi, plotattributes) for vi in v)...)
+        vcat((series_vector(vi, plotattributes) for vi in v)...)
    end
 end

 # Matrix is split into columns
-function convertToAnyVector(v::AMat{<:DataPoint}, plotattributes)
+function series_vector(v::AMat{<:DataPoint}, plotattributes)
    if all3D(plotattributes)
-        Any[prepareSeriesData(Surface(v))]
+        [prepareSeriesData(Surface(v))]
    else
-        Any[prepareSeriesData(v[:, i]) for i in axes(v, 2)]
+        [prepareSeriesData(v[:, i]) for i in axes(v, 2)]
    end
 end

@@ -59,13 +60,15 @@ end


 process_fillrange(range::Number, plotattributes) = [range]
-process_fillrange(range, plotattributes) = convertToAnyVector(range, plotattributes)
+process_fillrange(range, plotattributes) = series_vector(range, plotattributes)

 process_ribbon(ribbon::Number, plotattributes) = [ribbon]
-process_ribbon(ribbon, plotattributes) = convertToAnyVector(ribbon, plotattributes)
+process_ribbon(ribbon, plotattributes) = series_vector(ribbon, plotattributes)
 # ribbon as a tuple: (lower_ribbons, upper_ribbons)
-process_ribbon(ribbon::Tuple{Any,Any}, plotattributes) = collect(zip(convertToAnyVector(ribbon[1], plotattributes),
-                                                     convertToAnyVector(ribbon[2], plotattributes)))
+process_ribbon(ribbon::Tuple{S, T}, plotattributes) where {S, T} = collect(zip(
+    series_vector(ribbon[1], plotattributes),
+    series_vector(ribbon[2], plotattributes),
+))


 # --------------------------------------------------------------------
@@ -105,10 +108,16 @@ compute_xyz(x::Nothing, y::Nothing, z::Nothing)        = error("x/y/z are all no

 # we are going to build recipes to do the processing and splitting of the args

+# --------------------------------------------------------------------
+# The catch-all SliceIt recipe
+# --------------------------------------------------------------------
+
 # ensure we dispatch to the slicer
 struct SliceIt end

-# the catch-all recipes
+# The `SliceIt` recipe finishes user and type recipe processing.
+# It splits processed data into individual series data, stores in copied `plotattributes`
+# for each series and returns no arguments.
@recipe function f(::Type{SliceIt}, x, y, z)

    # handle data with formatting attached
@@ -125,10 +134,9 @@ struct SliceIt end
        z = z.data
    end

-    xs = convertToAnyVector(x, plotattributes)
-    ys = convertToAnyVector(y, plotattributes)
-    zs = convertToAnyVector(z, plotattributes)
-
+    xs = series_vector(x, plotattributes)
+    ys = series_vector(y, plotattributes)
+    zs = series_vector(z, plotattributes)

    fr = pop!(plotattributes, :fillrange, nothing)
    fillranges = process_fillrange(fr, plotattributes)
@@ -138,8 +146,6 @@ struct SliceIt end
    ribbons = process_ribbon(rib, plotattributes)
    mr = length(ribbons)

-    # @show zs
-
    mx = length(xs)
    my = length(ys)
    mz = length(zs)
@@ -164,16 +170,22 @@ struct SliceIt end
    nothing  # don't add a series for the main block
 end

+
+# --------------------------------------------------------------------
+# Apply type recipes
+# --------------------------------------------------------------------
+
 # this is the default "type recipe"... just pass the object through
-@recipe f(::Type{T}, v::T) where {T<:Any} = v
+@recipe f(::Type{T}, v::T) where T = v

 # this should catch unhandled "series recipes" and error with a nice message
@recipe f(::Type{V}, x, y, z) where {V<:Val} = error("The backend must not support the series type $V, and there isn't a series recipe defined.")

 function _apply_type_recipe(plotattributes, v, letter)
-    _handle_axis_args!(plotattributes)
+    _preprocess_axis_args!(plotattributes, letter)
    rdvec = RecipesBase.apply_recipe(plotattributes, typeof(v), v)
-    _handle_axis_args!(plotattributes, letter)
+    warn_on_recipe_aliases!(plotattributes, :type, typeof(v))
+    _postprocess_axis_args!(plotattributes, letter)
    return rdvec[1].args[1]
 end

@@ -181,15 +193,17 @@ end
 # This sort of recipe should return a pair of functions... one to convert to number,
 # and one to format tick values.
 function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
-    _handle_axis_args!(plotattributes)
+    _preprocess_axis_args!(plotattributes, letter)
    # First we try to apply an array type recipe.
    w = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1]
+    warn_on_recipe_aliases!(plotattributes, :type, typeof(v))
    # If the type did not change try it element-wise
    if typeof(v) == typeof(w)
        isempty(skipmissing(v)) && return Float64[]
        x = first(skipmissing(v))
        args = RecipesBase.apply_recipe(plotattributes, typeof(x), x)[1].args
-        _handle_axis_args!(plotattributes, letter)
+        warn_on_recipe_aliases!(plotattributes, :type, typeof(x))
+        _postprocess_axis_args!(plotattributes, letter)
        if length(args) == 2 && all(arg -> arg isa Function, args)
            numfunc, formatter = args
             return Formatted(map(numfunc, v), formatter)
@@ -197,35 +211,56 @@ function _apply_type_recipe(plotattributes, v::AbstractArray, letter)
             return v
        end
    end
-    _handle_axis_args!(plotattributes, letter)
+    _postprocess_axis_args!(plotattributes, letter)
    return w
 end

-# # special handling for Surface... need to properly unwrap and re-wrap
-# function _apply_type_recipe(plotattributes, v::Surface)
-#     T = eltype(v.surf)
-#     @show T
-#     if T <: Integer || T <: AbstractFloat
-#         v
-#     else
-#         ret = _apply_type_recipe(plotattributes, v.surf)
-#         if typeof(ret) <: Formatted
-#             Formatted(Surface(ret.data), ret.formatter)
-#         else
-#             v
-#         end
-#     end
-# end
+# special handling for Surface... need to properly unwrap and re-wrap
+_apply_type_recipe(
+    plotattributes,
+    v::Surface{<:AMat{<:Union{AbstractFloat, Integer, AbstractString, Missing}}},
+    letter,
+) = v
+function _apply_type_recipe(plotattributes, v::Surface, letter)
+    ret = _apply_type_recipe(plotattributes, v.surf, letter)
+    if typeof(ret) <: Formatted
+        Formatted(Surface(ret.data), ret.formatter)
+    else
+        Surface(ret)
+    end
+end

-# don't do anything for ints or floats
-_apply_type_recipe(plotattributes, v::AbstractArray{T}, letter) where {T<:Union{Integer,AbstractFloat}} = v
+# don't do anything vectors of datapoints and for nothing
+_apply_type_recipe(plotattributes, v::Nothing, letter) = v
+_apply_type_recipe(
+    plotattributes,
+    v::AbstractArray{<:Union{AbstractFloat, Integer, AbstractString, Missing}},
+    letter,
+) = v
+
+# axis args before type recipes should still be mapped to all axes
+function _preprocess_axis_args!(plotattributes)
+    for (k, v) in plotattributes
+        if is_axis_attr_noletter(k)
+            pop!(plotattributes, k)
+            for l in (:x, :y, :z)
+                lk = Symbol(l, k)
+                haskey(plotattributes, lk) || (plotattributes[lk] = v)
+            end
+        end
+    end
+end
+function _preprocess_axis_args!(plotattributes, letter)
+    plotattributes[:letter] = letter
+    _preprocess_axis_args!(plotattributes)
+end

 # axis args in type recipes should only be applied to the current axis
-function _handle_axis_args!(plotattributes, letter)
+function _postprocess_axis_args!(plotattributes, letter)
+    pop!(plotattributes, :letter)
    if letter in (:x, :y, :z)
-        replaceAliases!(plotattributes, _keyAliases)
        for (k, v) in plotattributes
-            if haskey(_axis_defaults, k)
+            if is_axis_attr_noletter(k)
                pop!(plotattributes, k)
                lk = Symbol(letter, k)
                haskey(plotattributes, lk) || (plotattributes[lk] = v)
@@ -234,22 +269,14 @@ function _handle_axis_args!(plotattributes, letter)
    end
 end

-# axis args before type recipes should still be mapped to all axes
-function _handle_axis_args!(plotattributes)
-    replaceAliases!(plotattributes, _keyAliases)
-    for (k, v) in plotattributes
-        if haskey(_axis_defaults, k)
-            pop!(plotattributes, k)
-            for letter in (:x, :y, :z)
-                lk = Symbol(letter, k)
-                haskey(plotattributes, lk) || (plotattributes[lk] = v)
-            end
-        end
-    end
-end
+
+# --------------------------------------------------------------------
+# Fallback user recipes calling type recipes
+# --------------------------------------------------------------------

 # handle "type recipes" by converting inputs, and then either re-calling or slicing
@recipe function f(x, y, z)
+    wrap_surfaces!(plotattributes, x, y, z)
    did_replace = false
    newx = _apply_type_recipe(plotattributes, x, :x)
    x === newx || (did_replace = true)
@@ -264,6 +291,7 @@ end
    end
 end
@recipe function f(x, y)
+    wrap_surfaces!(plotattributes, x, y)
    did_replace = false
    newx = _apply_type_recipe(plotattributes, x, :x)
    x === newx || (did_replace = true)
@@ -276,6 +304,7 @@ end
    end
 end
@recipe function f(y)
+    wrap_surfaces!(plotattributes, y)
    newy = _apply_type_recipe(plotattributes, y, :y)
    if y !== newy
        newy
@@ -302,12 +331,14 @@ end
 end


-# # --------------------------------------------------------------------
-# # 1 argument
-# # --------------------------------------------------------------------
-
 # helper function to ensure relevant attributes are wrapped by Surface
-function wrap_surfaces(plotattributes::AKW)
+function wrap_surfaces!(plotattributes, args...) end
+wrap_surfaces!(plotattributes, x::AMat, y::AMat, z::AMat) = wrap_surfaces!(plotattributes)
+wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::AMat) = wrap_surfaces!(plotattributes)
+function wrap_surfaces!(plotattributes, x::AVec, y::AVec, z::Surface)
+    wrap_surfaces!(plotattributes)
+end
+function wrap_surfaces!(plotattributes)
    if haskey(plotattributes, :fill_z)
        v = plotattributes[:fill_z]
        if !isa(v, Surface)
@@ -316,42 +347,57 @@ function wrap_surfaces(plotattributes::AKW)
    end
 end

+
+# --------------------------------------------------------------------
+# 1 argument
+# --------------------------------------------------------------------
+
@recipe f(n::Integer) = is3d(get(plotattributes,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)

-all3D(plotattributes) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none))
+all3D(plotattributes) = trueOrAllTrue(
+    st -> st in (
+        :contour,
+        :contourf,
+        :heatmap,
+        :surface,
+        :wireframe,
+        :contour3d,
+        :image,
+        :plots_heatmap,
+    ),
+    get(plotattributes, :seriestype, :none),
+)

 # return a surface if this is a 3d plot, otherwise let it be sliced up
-@recipe function f(mat::AMat{T}) where T<:Union{Integer,AbstractFloat,Missing}
+@recipe function f(mat::AMat)
    if all3D(plotattributes)
-        n,m = axes(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, m, n, Surface(mat)
+        n, m = axes(mat)
+        m, n, Surface(mat)
    else
-        SliceIt, nothing, mat, nothing
+        nothing, mat, nothing
    end
 end

 # if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
-@recipe function f(fmt::Formatted{T}) where T<:AbstractMatrix
+@recipe function f(fmt::Formatted{<:AMat})
    if all3D(plotattributes)
        mat = fmt.data
-        n,m = axes(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, m, n, Formatted(Surface(mat), fmt.formatter)
+        n, m = axes(mat)
+        m, n, Formatted(Surface(mat), fmt.formatter)
    else
-        SliceIt, nothing, fmt, nothing
+        nothing, fmt, nothing
    end
 end

 # assume this is a Volume, so construct one
-@recipe function f(vol::AbstractArray{T,3}, args...) where T<:Union{Number,Missing}
+@recipe function f(vol::AbstractArray{<:MaybeNumber, 3}, args...)
    seriestype := :volume
    SliceIt, nothing, Volume(vol, args...), nothing
 end


-# # images - grays
-function clamp_greys!(mat::AMat{T}) where T<:Gray
+# images - grays
+function clamp_greys!(mat::AMat{<:Gray})
    for i in eachindex(mat)
        mat[i].val < 0 && (mat[i] = Gray(0))
        mat[i].val > 1 && (mat[i] = Gray(1))
@@ -359,7 +405,7 @@ function clamp_greys!(mat::AMat{T}) where T<:Gray
    mat
 end

-@recipe function f(mat::AMat{T}) where T<:Gray
+@recipe function f(mat::AMat{<:Gray})
    n, m = axes(mat)
    if is_seriestype_supported(:image)
        seriestype := :image
@@ -374,8 +420,7 @@ end
    end
 end

-# # images - colors
-
+# images - colors
@recipe function f(mat::AMat{T}) where T<:Colorant
 	n, m = axes(mat)

@@ -393,8 +438,7 @@ end
    end
 end

-#
-# # plotting arbitrary shapes/polygons
+# plotting arbitrary shapes/polygons

@recipe function f(shape::Shape)
    seriestype --> :shape
@@ -428,40 +472,21 @@ end
            axis_limits(plt[1], :x)
        catch
            xinv = invscalefunc(get(plotattributes, :xscale, :identity))
-            xm = tryrange(f, xinv.([-5,-1,0,0.01]))
-            xm, tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
+            xm = PlotUtils.tryrange(f, xinv.([-5,-1,0,0.01]))
+            xm, PlotUtils.tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
        end
    end

    f, xmin, xmax
 end

-# try some intervals over which the function may be defined
-function tryrange(F::AbstractArray, vec)
-    rets = [tryrange(f, vec) for f in F] # get the preferred for each
-    maxind = maximum(indexin(rets, vec)) # get the last attempt that succeeded (most likely to fit all)
-    rets .= [tryrange(f, vec[maxind:maxind]) for f in F] # ensure that all functions compute there
-    rets[1]
-end

-function tryrange(F, vec)
-    for v in vec
-        try
-            tmp = F(v)
-            return v
-        catch
-        end
-    end
-    error("$F is not a Function, or is not defined at any of the values $vec")
-end
-#
-# # --------------------------------------------------------------------
-# # 2 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # if functions come first, just swap the order (not to be confused with parametric functions...
-# # as there would be more than one function passed in)
+# --------------------------------------------------------------------
+# 2 arguments
+# --------------------------------------------------------------------
+
+# if functions come first, just swap the order (not to be confused with parametric
+# functions... as there would be more than one function passed in)

@recipe function f(f::FuncOrFuncs{F}, x) where F<:Function
    F2 = typeof(x)
@@ -469,58 +494,25 @@ end
    x, f
 end

-#
-# # --------------------------------------------------------------------
-# # 3 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # 3d line or scatter

-@recipe function f(x::AVec, y::AVec, z::AVec)
-    # st = get(plotattributes, :seriestype, :none)
-    # if st == :scatter
-    #     plotattributes[:seriestype] = :scatter3d
-    # elseif !is3d(st)
-    #     plotattributes[:seriestype] = :path3d
-    # end
-    SliceIt, x, y, z
-end
-
-@recipe function f(x::AMat, y::AMat, z::AMat)
-    # st = get(plotattributes, :seriestype, :none)
-    # if size(x) == size(y) == size(z)
-    #     if !is3d(st)
-    #         seriestype := :path3d
-    #     end
-    # end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, z
-end
-
-#
-# # surface-like... function
+# --------------------------------------------------------------------
+# 3 arguments
+# --------------------------------------------------------------------

+# surface-like... function
@recipe function f(x::AVec, y::AVec, zf::Function)
-    # x = X <: Number ? sort(x) : x
-    # y = Y <: Number ? sort(y) : y
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
+    x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
 end

-#
-# # surface-like... matrix grid
-
+# surface-like... matrix grid
@recipe function f(x::AVec, y::AVec, z::AMat)
    if !like_surface(get(plotattributes, :seriestype, :none))
        plotattributes[:seriestype] = :contour
    end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(z)
+    x, y, Surface(z)
 end

-# # images - grays
-
+# images - grays
@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Gray
    if is_seriestype_supported(:image)
        seriestype := :image
@@ -535,8 +527,7 @@ end
    end
 end

-# # images - colors
-
+# images - colors
@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Colorant
    if is_seriestype_supported(:image)
        seriestype := :image
@@ -551,27 +542,19 @@ end
    end
 end

-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------

-#
-# # special handling... xmin/xmax with parametric function(s)
+# --------------------------------------------------------------------
+# Parametric functions
+# --------------------------------------------------------------------
+
+# special handling... xmin/xmax with parametric function(s)
@recipe function f(f::Function, xmin::Number, xmax::Number)
    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
    _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
 end
@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where F<:Function
    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
-    xs = Array{Any}(undef, length(fs))
-    ys = Array{Any}(undef, length(fs))
-    for (i, (x, y)) in enumerate(_scaled_adapted_grid(f, xscale, yscale, xmin, xmax) for f in fs)
-        xs[i] = x
-    	ys[i] = y
-    end
-    xs, ys
+    unzip(_scaled_adapted_grid.(fs, xscale, yscale, xmin, xmax))
 end
@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec) where {F<:Function,G<:Function}  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) where {F<:Function,G<:Function} = fx, fy, range(umin, stop = umax, length = n)
@@ -582,8 +565,7 @@ function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
    xinv.(xs), yinv.(ys)
 end

-#
-# # special handling... 3D parametric function(s)
+# special handling... 3D parametric function(s)
@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec) where {F<:Function,G<:Function,H<:Function}
    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
 end
@@ -591,12 +573,10 @@ end
    fx, fy, fz, range(umin, stop = umax, length = numPoints)
 end

-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and GeometryTypes.Points
-# # --------------------------------------------------------------------
-#
+
+# --------------------------------------------------------------------
+# Lists of tuples and GeometryTypes.Points
+# --------------------------------------------------------------------

@recipe f(v::AVec{<:Tuple})               = unzip(v)
@recipe f(v::AVec{<:GeometryTypes.Point}) = unzip(v)
@@ -606,23 +586,10 @@ end
 # Special case for 4-tuples in :ohlc series
@recipe f(xyuv::AVec{<:Tuple{R1,R2,R3,R4}}) where {R1,R2,R3,R4} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)

-#
-# # --------------------------------------------------------------------
-# # handle grouping
-# # --------------------------------------------------------------------

-# @recipe function f(groupby::GroupBy, args...)
-#     for (i,glab) in enumerate(groupby.groupLabels)
-#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
-#         # TODO: use @series instead
-#         @show i, glab, groupby.groupIds[i]
-#         di = copy(plotattributes)
-#         get!(di, :label, string(glab))
-#         get!(di, :idxfilter, groupby.groupIds[i])
-#         push!(series_list, RecipeData(di, args))
-#     end
-#     nothing
-# end
+# --------------------------------------------------------------------
+# handle grouping
+# --------------------------------------------------------------------

 splittable_kw(key, val, lengthGroup) = false
 splittable_kw(key, val::AbstractArray, lengthGroup) = !(key in (:group, :color_palette)) && length(axes(val,1)) == lengthGroup
@@ -438,7 +438,7 @@ julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
 ```
 """
-annotate!(anns...; kw...)                                        = plot!(; annotation = anns, kw...)
+annotate!(anns...; kw...)                                        = plot!(; annotation = collect(anns), kw...)
 annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)

 "Flip the current plots' x axis"
@@ -26,8 +26,9 @@ struct Attr <: AbstractDict{Symbol,Any}
    defaults::KW
 end

-Base.getindex(attr::Attr, k) = haskey(attr.explicit,k) ?
-                                     attr.explicit[k] : attr.defaults[k]
+function Base.getindex(attr::Attr, k)
+    return haskey(attr.explicit, k) ? attr.explicit[k] : attr.defaults[k]
+end
 Base.haskey(attr::Attr, k) = haskey(attr.explicit,k) || haskey(attr.defaults,k)
 Base.get(attr::Attr, k, default) = haskey(attr, k) ? attr[k] : default
 function Base.get!(attr::Attr, k, default)
@@ -41,7 +42,7 @@ end
 function Base.delete!(attr::Attr, k)
    haskey(attr.explicit, k) && delete!(attr.explicit, k)
    haskey(attr.defaults, k) && delete!(attr.defaults, k)
-end 
+end
 Base.length(attr::Attr) = length(union(keys(attr.explicit), keys(attr.defaults)))
 function Base.iterate(attr::Attr)
    exp_keys = keys(attr.explicit)
@@ -826,7 +826,7 @@ 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)
+    vmax = isempty(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)
@@ -245,15 +245,39 @@ end
   end # testset
   @testset "Annotations" begin
      y = rand(10)
-      plot(
+      pgfx_plot = plot(
         y,
         annotations = (3, y[3], Plots.text("this is \\#3", :left)),
         leg = false,
      )
+      Plots._update_plot_object(pgfx_plot)
+      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 1
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(pgfx_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 1
+         end
+      end
      annotate!([
         (5, y[5], Plots.text("this is \\#5", 16, :red, :center)),
         (10, y[10], Plots.text("this is \\#10", :right, 20, "courier")),
      ])
+      Plots._update_plot_object(pgfx_plot)
+      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 3
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(pgfx_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 3
+         end
+      end
      annotation_plot = scatter!(
         range(2, stop = 8, length = 6),
         rand(6),
@@ -267,9 +291,18 @@ end
            Plots.text("data", :green),
         ],
      )
-      # mktempdir() do path
-      #    @test_nowarn savefig(annotation_plot, path*"annotation.pdf")
-      # end
+      Plots._update_plot_object(annotation_plot)
+      axis_content = Plots.pgfx_axes(annotation_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 9
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(annotation_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 9
+         end
+      end
   end # testset
   @testset "Ribbon" begin
      aa = rand(10)
Author	SHA1	Message	Date
Daniel SchwabenederandGitHub	824d502c37	Merge pull request #2556 from daschw/gr-box Gr box	2020-04-10 08:49:07 +02:00
Daniel Schwabeneder	36ff017c4f	bump version	2020-04-10 08:31:03 +02:00
Daniel Schwabeneder	3ef9fe142c	fix box and semi framestyle for GR	2020-04-10 08:05:36 +02:00
Daniel SchwabenederandGitHub	4bf0c496d8	Merge pull request #2553 from daschw/pgfplotsx minorgrid, minorticks and framestyle zerolines fix for pgfplotsx	2020-04-09 21:37:52 +02:00
Daniel Schwabeneder	9bf4bda852	fix zerolines framestyle and don't draw tick marks for zerolines and grid framestyle	2020-04-09 18:13:28 +02:00
Daniel Schwabeneder	fa7f10a6e9	implement minorgrid for pgfplotsx	2020-04-09 17:56:54 +02:00
Simon ChristandGitHub	483e45db8a	fix topleft	2020-04-09 16:11:02 +02:00
Simon ChristandGitHub	e6097f4534	all the legend positions (#2550 ) * all the legend positions * fix default	2020-04-09 14:18:15 +02:00
Daniel SchwabenederandGitHub	749f56084a	Merge pull request #2551 from daschw/webio fix webio error for plotlyjs	2020-04-09 10:57:32 +02:00
Daniel Schwabeneder	2fa4a63f02	fix webio error for plotlyjs	2020-04-09 10:55:33 +02:00
Michael Krabbe BorregaardandGitHub	9b1249abce	Merge pull request #2512 from JuliaPlots/compathelper/new_version/2020-03-28-15-04-44-941-2889142658 CompatHelper: bump compat for "StatsBase" to "0.33"	2020-04-08 14:24:28 +02:00
Simon ChristandGitHub	bbfc0bc77a	Update Project.toml	2020-04-08 10:09:36 +02:00
Simon ChristandGitHub	5a416e51d2	fix warning	2020-04-08 10:09:06 +02:00
Daniel SchwabenederandGitHub	67ba06cd77	Merge pull request #2548 from daschw/surface Implement zerror and surface type recipe fixes	2020-04-07 17:50:32 +02:00
Daniel Schwabeneder	aa61d681d9	bump version	2020-04-07 16:27:33 +02:00
Daniel Schwabeneder	c8e6b967e5	add errorbar test example	2020-04-07 16:27:02 +02:00
Daniel Schwabeneder	819e91aa37	add zerror recipe	2020-04-07 16:06:12 +02:00
Daniel SchwabenederandGitHub	7f835cf7cb	Merge pull request #2546 from isentropic/isen-dev new aliases	2020-04-07 13:51:10 +02:00
Daniel SchwabenederandGitHub	43571e6d40	Merge pull request #2547 from Libbum/empty-fix Fix 'isempy' check	2020-04-07 13:50:55 +02:00
Tim DuBois	dd3666b6d3	Fix 'isempy' check	2020-04-07 13:33:16 +02:00
Simon ChristandGitHub	f98b191616	Layouting (#2486 ) * distances very big * better default * respect margins * remove failing example	2020-04-07 10:44:22 +02:00
Zhanibek	9fdcf0db74	new aliases	2020-04-07 17:23:05 +09:00
Daniel Schwabeneder	7abab41f2b	add letter in surface type recipe	2020-04-07 09:52:32 +02:00
Daniel SchwabenederandGitHub	45569c0d4d	Merge pull request #2544 from JeffBezanson/jb/optlevel1 use -O1 for code in Plots.jl	2020-04-06 22:59:32 +02:00
Simon ChristandGitHub	ca653c5bec	Merge pull request #2541 from JuliaPlots/bbs/sani special case LaTeXStrings in sanitation	2020-04-06 22:33:13 +02:00
Simon ChristandGitHub	6c0539bac6	Merge pull request #2545 from JuliaPlots/bbs/annotations fix annotations	2020-04-06 22:28:06 +02:00
Simon Christ	65c9a46c8d	rely on require	2020-04-06 22:00:51 +02:00
Simon Christ	7bd97558dc	fix annotations	2020-04-06 21:41:11 +02:00
Jeff Bezanson	6807f53a7e	use -O1 for code in Plots.jl	2020-04-06 15:01:33 -04:00
Daniel SchwabenederandGitHub	ae396ef576	Merge pull request #2543 from daschw/typesurface allow type recipes for numbers in surfaces	2020-04-06 18:06:56 +02:00
Daniel Schwabeneder	3dd1c500cf	fix ambiguity	2020-04-06 17:40:31 +02:00
Daniel Schwabeneder	59e4129194	skip maybestrings	2020-04-06 17:25:18 +02:00
Daniel Schwabeneder	54d441b62a	bump versio	2020-04-06 17:10:27 +02:00
Daniel Schwabeneder	f8d36363b4	allow type recipes for numbers in surfaces	2020-04-06 17:09:00 +02:00
Daniel SchwabenederandGitHub	c32c7fda58	Merge pull request #2542 from harryscholes/splatted_annotations Fix #2487	2020-04-06 16:32:44 +02:00
harryscholes	87b220e747	Fix #2487	2020-04-06 15:15:55 +01:00
Simon Christ	57a6f4303b	special case LaTeXStrings	2020-04-06 15:44:06 +02:00
Daniel SchwabenederandGitHub	407456eac5	Merge pull request #2540 from daschw/link Fix link	2020-04-06 14:44:31 +02:00
Daniel Schwabeneder	f118d0cd35	bump version	2020-04-06 14:27:03 +02:00
Daniel Schwabeneder	1b0fb95583	add axes linking test	2020-04-06 14:26:22 +02:00
Daniel Schwabeneder	0daed24020	fix link	2020-04-06 14:12:46 +02:00
Daniel SchwabenederandGitHub	92eaa95127	Merge pull request #2539 from daschw/numbers Allow type recipes for `Number`s, not for `Real`s	2020-04-06 10:35:55 +02:00
Daniel Schwabeneder	a9d22cfb60	update comment	2020-04-06 10:11:00 +02:00
Daniel Schwabeneder	b433b76a84	allow type recipes for numbers but not for reals	2020-04-06 09:56:47 +02:00
Daniel Schwabeneder	5ff0a419dd	bump version	2020-04-06 09:23:14 +02:00
Daniel Schwabeneder	6b7be5ae12	apply type recipe for AbstractVector{<:Number}	2020-04-06 09:22:52 +02:00
Daniel SchwabenederandGitHub	8d1f44a0c5	Merge pull request #2533 from daschw/release release 1.0 🎉	2020-04-05 15:39:21 +02:00
Daniel Schwabeneder	0c101e7d88	release 1.0 🎉	2020-04-05 13:10:36 +02:00
Daniel SchwabenederandGitHub	6e3c218d89	Merge pull request #2456 from JuliaPlots/as/remove-tryrange move tryrange to PlotUtils	2020-04-01 23:08:28 +02:00
Daniel SchwabenederandGitHub	fe436cf54f	Merge branch 'master' into as/remove-tryrange	2020-04-01 22:38:12 +02:00
Daniel SchwabenederandGitHub	efdfec13ed	Merge pull request #2524 from daschw/surface-type-recipe Apply type recipes also for plots with surfaces	2020-04-01 19:45:10 +02:00
Daniel Schwabeneder	52522fde48	splat `args` in `warn_on_recipe_alias`	2020-04-01 19:27:41 +02:00
Daniel SchwabenederandGitHub	2a4882d92e	Merge pull request #2525 from daschw/letter fix type recipes for other backends	2020-04-01 18:16:55 +02:00
Daniel Schwabeneder	bf98db67a3	fix type recipes for other backends	2020-04-01 17:32:31 +02:00
Daniel Schwabeneder	9f375aef09	fix single argument recipe	2020-04-01 14:24:34 +02:00
Daniel Schwabeneder	1faa858690	fix typo	2020-04-01 13:28:32 +02:00
Daniel Schwabeneder	5e7d2fb8ba	add test example	2020-04-01 13:26:01 +02:00
Daniel Schwabeneder	974c6e5950	update precompile.jl	2020-04-01 13:13:06 +02:00
Daniel Schwabeneder	e53f27c224	add axes function for surfaces	2020-04-01 12:54:40 +02:00
Daniel Schwabeneder	d98262bc08	apply type recipes also for series	2020-04-01 12:08:32 +02:00
Daniel Schwabeneder	945874ca7d	clean up series.jl	2020-03-31 22:13:27 +02:00
Daniel SchwabenederandGitHub	4c839837d3	Merge pull request #2522 from wfrgra/time_annotation Fix for #2349. Converts TimeTypes in annotations to numbers to allow their placement	2020-03-31 12:06:41 +02:00
Michael Krabbe BorregaardandGitHub	f230dee72c	Merge pull request #2521 from wfrgra/inline_legend Add ability to place series legend labels next to final series datapoint in GR	2020-03-31 12:01:06 +02:00
wfrgra	11a859e83e	have legend appear away from other data for any xflip and ymirror combination	2020-03-31 20:54:07 +11:00
wfrgra	9029e37671	Turn TimeType annotation locations to float fix errors	2020-03-31 20:05:21 +11:00
wfrgra	2a4b74d0ff	renamed new legend setting from :label to :inline	2020-03-31 19:38:47 +11:00
Daniel SchwabenederandGitHub	0af25a2684	Merge pull request #2520 from daschw/any remove some more `Any` in `series.jl`	2020-03-31 00:14:21 +02:00
Daniel Schwabeneder	f62f4806c3	remove some more `Any` in `series.jl`	2020-03-30 23:49:29 +02:00
Daniel SchwabenederandGitHub	22496535d1	Merge pull request #2518 from JuliaPlots/pr-2273/travigd/patch-1 Patch PR 2273	2020-03-30 12:45:35 +02:00
Daniel Schwabeneder	cb8df169c7	fix typo	2020-03-30 12:37:26 +02:00
Daniel SchwabenederandGitHub	ac25972873	Merge pull request #2517 from daschw/unpin Try not to pin FixedPointNumbers in tests.	2020-03-30 12:03:07 +02:00
Daniel Schwabeneder	f1f9d807e6	don't pin FixedPointNumbers in tests	2020-03-30 11:39:50 +02:00
Daniel Schwabeneder	7d34b9bb46	fix julia versions in tests	2020-03-30 11:39:01 +02:00
wfrgra	ae009cd53f	Add ability to place legend label next to final datapoint in GR via legend=:label	2020-03-30 20:02:06 +11:00
Daniel SchwabenederandGitHub	dd36d17fa6	Merge pull request #2516 from yha/animation-verbose Show errors from ffmpeg by default, verbose flag	2020-03-29 23:42:20 +02:00
Daniel SchwabenederandGitHub	9843921503	Merge pull request #2515 from daschw/axis-args fix `default` with axis args	2020-03-29 23:41:56 +02:00
Daniel SchwabenederandGitHub	f6feb4b9eb	Merge pull request #2511 from daschw/convert Don't convert to any vector.	2020-03-29 23:41:31 +02:00
Daniel Schwabeneder	246632abca	ok, don't use latex in tests	2020-03-29 17:39:56 +02:00
yha	5da33d7de8	Verbose flag for animations	2020-03-29 18:17:31 +03:00
Daniel Schwabeneder	9243de6ce9	add texlive-base	2020-03-29 17:00:57 +02:00
Daniel Schwabeneder	a5b6c27bec	add new test	2020-03-29 16:25:23 +02:00
Daniel Schwabeneder	076de033fd	fix `default` with axis args	2020-03-29 15:39:44 +02:00
Daniel SchwabenederandGitHub	a1116f8e3b	Merge pull request #2514 from daschw/coverage Add CodeCov coverage	2020-03-28 23:16:16 +01:00
Daniel Schwabeneder	d8c4c53567	ignore some files in coverage	2020-03-28 22:54:49 +01:00
Daniel Schwabeneder	df9217e3b9	move `/src/backends/template.jl` to `/templates/backends.jl` for coverage	2020-03-28 21:52:03 +01:00
Daniel Schwabeneder	c5aebf1309	add Codecov coverage	2020-03-28 21:00:06 +01:00
github-actions[bot]	dc5ae4ef96	CompatHelper: bump compat for "StatsBase" to "0.33"	2020-03-28 15:04:45 +00:00
Daniel SchwabenederandGitHub	d4ecf468b1	Merge pull request #2509 from JuliaPlots/revert-2506-compathelper/new_version/2020-03-26-20-05-28-345-1947541166 Revert "CompatHelper: bump compat for "StatsBase" to "0.33""	2020-03-28 15:17:38 +01:00
Daniel SchwabenederandGitHub	aa2cee405a	Revert "CompatHelper: bump compat for "StatsBase" to "0.33""	2020-03-27 19:52:46 +01:00
Daniel SchwabenederandGitHub	5fc02f7f58	Merge pull request #2507 from daschw/no-aliases Warn on aliases in recipes	2020-03-27 19:39:16 +01:00
Daniel Schwabeneder	3d5ae2fc3b	update precompile.jl	2020-03-27 18:46:34 +01:00
Daniel Schwabeneder	eecfdab590	don't convertToAnyVector	2020-03-27 18:39:18 +01:00
Daniel Schwabeneder	e9ef5c852b	fix magic axis args for recipes	2020-03-27 17:09:07 +01:00
Daniel Schwabeneder	8594926b67	move `replaceAliases!` back to `preprocessArgs!`	2020-03-27 16:31:06 +01:00
Daniel SchwabenederandGitHub	74a37b7817	Merge pull request #2503 from daschw/typerecipes Make type recipes aware of current axes.	2020-03-27 16:18:30 +01:00
Daniel SchwabenederandGitHub	13b47a4ee6	Merge pull request #2499 from daschw/tests test on 1.4 and update version	2020-03-27 16:18:06 +01:00
Daniel Schwabeneder	0c2d80841c	warn on recipe aliases	2020-03-27 13:44:39 +01:00
Daniel Schwabeneder	932d0da73d	move `replaceAliases!` out of recipe processing	2020-03-26 15:09:31 +01:00
Simon ChristandGitHub	c37829eafb	Update appveyor.yml	2020-03-25 16:55:53 +01:00
Simon ChristandGitHub	d9a48ac7de	Update .travis.yml	2020-03-25 16:36:04 +01:00
Daniel Schwabeneder	c684213106	fix `AbstractArray{<:Missing}`	2020-03-25 15:04:39 +01:00
Simon ChristandGitHub	5318352929	Update appveyor.yml	2020-03-25 14:50:42 +01:00
Simon ChristandGitHub	dd3216489b	resolve conditionally	2020-03-25 14:48:57 +01:00
Daniel Schwabeneder	17db6c01b4	keep no-letter version of `_preprocess_axis_args!`	2020-03-25 12:51:49 +01:00
Simon ChristandGitHub	8efd0f00c4	fix pin	2020-03-25 10:45:46 +01:00
Daniel Schwabeneder	b0548ffc14	make type recipe aware of current axis	2020-03-23 23:12:13 +01:00
Daniel Schwabeneder	5194e49b4c	test on 1.4 and update version	2020-03-22 18:31:08 +01:00
Anshul SinghviandGitHub	edcaab3c56	bump the PlotUtils compat this will only work after a release	2020-03-14 11:03:23 +05:30
Anshul SinghviandGitHub	503d741ea6	move tryrange to PlotUtils	2020-03-13 19:26:45 +05:30
Travis DePratoandGitHub	fa6f0a6b00	Fix PlotlyJS integration with WebIO Fixes #2272.	2019-11-26 12:55:27 -05:00