1.15.0 [skip ci]

* Create .zenodo.json

* Update .zenodo.json

Co-authored-by: Daniel Schwabeneder <daschw@disroot.org>

* add members, classify contributors

* Apply suggestions from code review

Co-authored-by: Daniel Schwabeneder <daschw@disroot.org>

* add all names

Co-authored-by: Daniel Schwabeneder <daschw@disroot.org>

.github/workflows/SnoopCompile.yml

@@ -21,7 +21,7 @@ jobs:
       fail-fast: false
       matrix:
         version:   # NOTE: the versions below should match those in your botconfig
-          - '1.5'
+          - '1'
         os:        # NOTE: should match the os setting of your botconfig
           - ubuntu-latest
         arch:

.github/workflows/docs.yml

@@ -0,0 +1,50 @@
+name: docs
+
+on:
+ push:
+  branches:
+    - master
+  tags: '*'
+ 
+jobs:
+  Build_docs:
+    runs-on: ubuntu-18.04
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          repository: JuliaPlots/PlotDocs.jl
+      - uses: julia-actions/setup-julia@v1
+      - name: Cache artifacts
+        uses: actions/cache@v1
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts 
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+      - name: Install dependencies
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y qt5-default \
+            ttf-mscorefonts-installer \
+            poppler-utils \
+            pdf2svg \
+            texlive-latex-base \
+            texlive-binaries \
+            texlive-pictures \
+            texlive-latex-extra \
+            texlive-luatex \
+            ghostscript-x \
+            libgconf2-4
+          sudo fc-cache -vr
+            
+      - name: build documentation
+        env: 
+          PYTHON: ""
+          DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
+        run: |
+          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; Pkg.develop(PackageSpec(path=pwd())); Pkg.add(PackageSpec(name="Plots", rev=split(ENV["GITHUB_REF"], "/", limit=3)[3])); Pkg.instantiate()' 
+          xvfb-run julia --color=yes --project=docs/ -e 'withenv("GITHUB_REPOSITORY" => "JuliaPlots/PlotDocs.jl") do; include("docs/make.jl"); end' 

.gitignore

@@ -12,3 +12,4 @@ dev/
 test/tmpplotsave.hdf5
 /.benchmarkci
 /benchmark/*.json
+.vscode/

.zenodo.json

@@ -0,0 +1,428 @@
+{
+    "title": "Plots.jl",
+    "license": "MIT", 
+    "creators": [
+        {
+            "affiliation": "Elemental Cognition", 
+            "name": "Tom Breloff"
+        }
+    ],
+    "contributors":[
+        {
+            "affiliation": "TU Wien", 
+            "name": "Daniel Schwabeneder",
+            "orcid": "0000-0002-0412-0777",
+            "type": "ProjectLeader"
+        }, 
+        {
+            "affiliation": "GLOBE Institute", 
+            "name": "Michael Krabbe Borregaard",
+            "type": "ProjectLeader"
+        }, 
+        {
+            "affiliation": "Leibniz Universit\u00e4t Hannover", 
+            "name": "Simon Christ",
+            "orcid": "0000-0002-5866-1472",
+            "type": "ProjectLeader"
+        }, 
+        {
+            "affiliation": "Forschungszentrum J\u00fclich", 
+            "name": "Josef Heinen",
+            "orcid": "0000-0001-6509-1925",
+            "type": "ProjectMember"
+        }, 
+        {
+            "name": "Yuval",
+            "type": "Other"
+        }, 
+        {
+            "name": "Andrew Palugniok",
+            "type": "ProjectMember"
+        }, 
+        {
+            "affiliation": "@beacon-biosignals", 
+            "name": "Simon Danisch",
+            "type": "Other"
+        }, 
+        {
+            "affiliation": "Veos Digital (https://veos.digital/)", 
+            "name": "Pietro Vertechi",
+            "type": "ProjectMember"
+        }, 
+        {
+            "affiliation": "Korea Advanced Inst. of Science and Technology (KAIST)",
+            "name": "Zhanibek Omarov",
+            "type": "ProjectMember",
+            "orcid": "0000-0002-8783-8791"
+        }, 
+        {
+            "name": "Thatcher Chamberlin",
+            "type": "Other"
+        }, 
+        {
+            "name": "@ma-laforge",
+            "type": "ProjectMember"
+        }, 
+        {
+            "affiliation": "Massachusetts Institute of Technology", 
+            "name": "Christopher Rackauckas",
+            "orcid": "0000-0001-5850-0663",
+            "type": "Other"
+        }, 
+        {
+            "affiliation": "Max Planck Institute for Physics", 
+            "name": "Oliver Schulz",
+            "type": "Other"
+        }, 
+        {
+            "affiliation": "@JuliaComputing", 
+            "name": "Sebastian Pfitzner",
+            "type": "Other"
+        }, 
+        {
+            "name": "Takafumi Arakaki",
+            "type": "Other"
+        }, 
+        {
+            "affiliation": "University of Manitoba", 
+            "name": "Amin Yahyaabadi",
+            "type": "Other"
+        }, 
+        {
+            "name": "Jack Devine",
+            "type": "Other"
+        }, 
+        {
+            "name": "Sebastian Pech",
+            "type": "Other"
+        }, 
+        {
+            "affiliation": "@JuliaComputing", 
+            "name": "Patrick Kofod Mogensen",
+            "type": "Other",
+            "orcid": "0000-0002-4910-1932"
+        }, 
+        {
+            "name": "Samuel S. Watson",
+            "type": "Other"
+        },
+        {
+            "affiliation": "UC Davis",
+            "name": "Naoki Saito",
+            "orcid": "0000-0001-5234-4719",
+            "type": "Other"
+        },
+        {
+            "affiliation": "University of Southern California (USC)",
+            "name": "Benoit Pasquier",
+            "orcid": "0000-0002-3838-5976",
+            "type": "Other"
+        },
+        {
+            "affiliation": "NTNU Trondheim",
+            "name": "Ronny Bergmann",
+            "orcid": "0000-0001-8342-7218",
+            "type": "Other"
+        },
+        {
+            "name": "Andy Nowacki",
+            "affiliation": "University of Leeds",
+            "orcid": "0000-0001-7669-7383",
+            "type": "Other"
+        },
+        {
+            "name": "Ian Butterworth",
+            "type": "Other"
+        },
+        {
+            "affiliation": "Lund University",
+            "name": "David Gustavsson",
+            "type": "Other"
+        },
+        {
+            "name": "Anshul Singhvi",
+            "type": "Other"
+        },
+        {
+            "name": "david-macmahon",
+            "type": "Other"
+        },
+        {
+            "name": "Fredrik Ekre",
+            "type": "Other"
+        },
+        {
+            "name": "Maaz Bin Tahir Saeed",
+            "type": "Other"
+        },
+        {
+            "name": "Kristoffer Carlsson",
+            "type": "Other"
+        },
+        {
+            "name": "Will Kearney",
+            "type": "Other"
+        },
+        {
+            "name": "Niklas Korsbo",
+            "type": "Other"
+        },
+        {
+            "name": "Miles Lucas",
+            "type": "Other"
+        },
+        {
+            "name": "@Godisemo",
+            "type": "Other"
+        },
+        {
+            "name": "Florian Oswald",
+            "type": "Other"
+        },
+        {
+            "name": "Diego Javier Zea",
+            "type": "Other"
+        },
+        {
+            "name": "@WillRam",
+            "type": "Other"
+        },
+        {
+            "name": "Fedor Bezrukov",
+            "type": "Other"
+        },
+        {
+            "name": "Spencer Lyon",
+            "type": "Other"
+        },
+        {
+            "name": "Darwin Darakananda",
+            "type": "Other"
+        },
+        {
+            "name": "Lukas Hauertmann",
+            "type": "Other"
+        },
+        {
+            "name": "Huckleberry Febbo",
+            "type": "Other"
+        },
+        {
+            "name": "@H-M-H",
+            "type": "Other"
+        },
+        {
+            "name": "Josh Day",
+            "type": "Other"
+        },
+        {
+            "name": "@wfgra",
+            "type": "Other"
+        },
+        {
+            "name": "Sheehan Olver",
+            "type": "Other"
+        },
+        {
+            "name": "Jerry Ling",
+            "type": "Other"
+        },
+        {
+            "name": "Jks Liu",
+            "type": "Other"
+        },
+        {
+            "name": "Seth Axen",
+            "type": "Other"
+        },
+        {
+            "name": "@o01eg",
+            "type": "Other"
+        },
+        {
+            "name": "Sebastian Micluța-Câmpeanu",
+            "type": "Other"
+        },
+        {
+            "name": "Tim Holy",
+            "type": "Other"
+        },
+        {
+            "name": "Tony Kelman",
+            "type": "Other"
+        },
+        {
+            "name": "Antoine Levitt",
+            "type": "Other"
+        },
+        {
+            "name": "Iblis Lin",
+            "type": "Other"
+        },
+        {
+            "name": "Harry Scholes",
+            "type": "Other"
+        },
+        {
+            "name": "@djsegal",
+            "type": "Other"
+        },
+        {
+            "name": "Goran Nakerst",
+            "type": "Other"
+        },
+        {
+            "name": "Felix Hagemann",
+            "type": "Other"
+        },
+        {
+            "name": "Matthieu Gomez",
+            "type": "Other"
+        },
+        {
+            "name": "@biggsbiggsby",
+            "type": "Other"
+        },
+        {
+            "name": "Jonathan Anderson",
+            "type": "Other"
+        },
+        {
+            "name": "Michael Kraus",
+            "type": "Other"
+        },
+        {
+            "name": "Carlo Lucibello",
+            "type": "Other"
+        },
+        {
+            "name": "Robin Deits",
+            "type": "Other"
+        },
+        {
+            "name": "Misha Mkhasenko",
+            "type": "Other"
+        },
+        {
+            "name": "Benoît Legat",
+            "type": "Other"
+        },
+        {
+            "name": "Steven G. Johnson",
+            "type": "Other"
+        },
+        {
+            "name": "John Verzani",
+            "type": "Other"
+        },
+        {
+            "name": "Mattias Fält",
+            "type": "Other"
+        },
+        {
+            "name": "Rashika Karki",
+            "type": "Other"
+        },
+        {
+            "name": "Morten Piibeleht",
+            "type": "Other"
+        },
+        {
+            "name": "Filippo Vicentini",
+            "type": "Other"
+        },
+        {
+            "name": "David Anthoff",
+            "type": "Other"
+        },
+        {
+            "name": "Leon Wabeke",
+            "type": "Other"
+        },
+        {
+            "name": "Yusuke Kominami",
+            "type": "Other"
+        },
+        {
+            "name": "Oscar Dowson",
+            "type": "Other"
+        },
+        {
+            "name": "Max G",
+            "type": "Other"
+        },
+        {
+            "name": "Fabian Greimel",
+            "type": "Other"
+        },
+        {
+            "name": "Jérémy",
+            "type": "Other"
+        },
+        {
+            "name": "Pearl Li",
+            "type": "Other"
+        },
+        {
+            "name": "David P. Sanders",
+            "type": "Other"
+        },
+        {
+            "name": "Asbjørn Nilsen Riseth",
+            "type": "Other"
+        },
+        {
+            "name": "Jan Weidner",
+            "type": "Other"
+        },
+        {
+            "name": "@jakkor2",
+            "type": "Other"
+        },
+        {
+            "name": "Pablo Zubieta",
+            "type": "Other"
+        },
+        {
+            "name": "Hamza Yusuf Çakır",
+            "type": "Other"
+        },
+        {
+            "name": "John Rinehart",
+            "type": "Other"
+        },
+        {
+            "name": "Martin Biel",
+            "type": "Other"
+        },
+        {
+            "name": "Moritz Schauer",
+            "type": "Other"
+        },
+        {
+            "name": "Moesè Giodano",
+            "type": "Other"
+        },
+        {
+            "name": "@olegshtch",
+            "type": "Other"
+        },
+        {
+            "name": "Leon Shen",
+            "type": "Other"
+        },
+        {
+            "name": "Jeff Fessler",
+            "type": "Other"
+        },
+        {
+            "name": "@hustf",
+            "type": "Other"
+        },
+        {
+            "name": "Asim H Dar",
+            "type": "Other"
+        }
+    ],
+    "resource_type": "software"
+}

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.11.0"
+version = "1.15.0"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,10 +36,10 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.57"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
-Latexify = "0.14"
+Latexify = "0.14, 0.15"
 Measures = "0.3"
 NaNMath = "0.3"
 PlotThemes = "2"
@@ -49,7 +49,7 @@ RecipesPipeline = "0.3"
 Reexport = "0.2, 1.0"
 Requires = "1"
 Scratch = "1"
-Showoff = "0.3.1"
+Showoff = "0.3.1, 1.0"
 StatsBase = "0.32, 0.33"
 julia = "1.5"
 
@@ -63,6 +63,7 @@ Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
+PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a"
 RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
 StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
@@ -73,4 +74,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
 
 [targets]
-test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]

README.md

@@ -18,6 +18,10 @@
 [![][docs-img]][docs-url]
 [![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)
 
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4725317.svg)](https://doi.org/10.5281/zenodo.4725317)
+This is the DOI for all Versions, please follow the link to get the DOI for a specific version.
+
+
 #### Created by Tom Breloff (@tbreloff)
 
 #### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -66,279 +66,300 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank),Tuple{Symbol,Bool}},Type{EmptyLayout}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height),Tuple{Symbol,Symbol,Length{:pct,Float64}}},Type{EmptyLayout}})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{GridLayout}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,),Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Array{Int64,1}}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1},Array{Float64,1}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights),Tuple{Bool,Nothing}},typeof(_make_hist),Tuple{Array{Float64,1}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,),Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,),Tuple{Symbol}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,),Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims),Tuple{Bool,Tuple{Float64,Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip),Tuple{Bool,Tuple{Float64,Float64},Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,),Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid),Tuple{Int64,Bool,Float64,Symbol,RGBA{Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,),Tuple{String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide),Tuple{Tuple{Int64,Int64},Bool,StepRange{Int64,Int64},String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Float64,Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,),Tuple{Tuple{Int64,Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,),Tuple{Int64}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide),Tuple{Symbol,String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,),Tuple{Nothing}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,),Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid),Tuple{Tuple{Int64,String},Int64,Tuple{Int64,Symbol},Tuple{Int64,Symbol},String,Symbol,Bool}},typeof(default)})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),Array{Int64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),StepRange{Int64,Int64},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),UnitRange{Int64},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle),Tuple{Symbol,Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(heatmap)),Any,typeof(heatmap),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Length{:pct, Float64}}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:scale, :guide), Tuple{Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(lens!)),Any,typeof(lens!),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype),Tuple{Float64,Symbol}},typeof(plot!),Plot{GRBackend},Array{GeometryBasics.Point{2,Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,),Tuple{Array{Tuple{Int64,Float64,PlotText},1}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype),Tuple{Tuple{Int64,Symbol,Float64,Array{Symbol,2}},Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Function,Float64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color),Tuple{Int64,Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype),Tuple{Tuple{Int64,Float64,Symbol},Array{Any,1},Symbol}},typeof(plot!),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype),Tuple{Int64,Symbol,Symbol}},typeof(plot!),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Array{Int64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Plot{GRBackend},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset),Tuple{Symbol,Tuple{Int64,BoundingBox{Tuple{Length{:w,Float64},Length{:h,Float64}},Tuple{Length{:w,Float64},Length{:h,Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot!),Array{Int64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,),Tuple{String}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot!),Plot{GRBackend},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,),Tuple{Tuple{Symbol,Symbol,Int64,Symbol,Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,),Tuple{Tuple{String,Symbol}}},typeof(plot!)})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{GRBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype),Tuple{Array{Float64,1},Tuple{Symbol,Float64,Stroke},Array{Float64,1},String,Symbol}},typeof(plot!),Plot{PlotlyBackend},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg),Tuple{Tuple{Int64,Float64,PlotText},Bool}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,),Tuple{Int64}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{String,1},Array{String,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype),Tuple{Symbol,Array{Int64,1},Symbol}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker),Tuple{Array{Symbol,2},Tuple{Symbol,Int64},Tuple{Array{Symbol,2},Int64,Float64,Stroke}}},typeof(plot),Array{Array{T,1} where T,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype),Tuple{Tuple{Array{Int64,1},Array{Int64,1},Array{Int64,1}},Symbol}},typeof(plot),Array{Int64,1},Array{Int64,1},Vararg{Array{Int64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype),Tuple{Bool,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype),Tuple{Array{Symbol,2},Array{String,2},Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64,String,Int64,UnitRange{Int64},Symbol}},typeof(plot),Array{Array{Float64,1},1},Array{Array{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title),Tuple{Tuple{Symbol,Symbol,Symbol,Int64,Float64},String}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α),Tuple{String,Int64,PlotUtils.ContinuousColorGradient,Int64,Float64}},typeof(plot),StepRange{Int64,Int64},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend),Tuple{Array{String,2},String,String,Int64,Symbol}},typeof(plot),Array{Function,1},Float64,Vararg{Float64,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,),Tuple{Array{String,2}}},typeof(plot),Array{AbstractArray{Float64,1},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor),Tuple{GridLayout,Array{String,1},Array{Symbol,2},Symbol}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha),Tuple{Tuple{Int64,Int64},String,Int64,Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link),Tuple{Int64,Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside),Tuple{Int64,Array{PlotUtils.ContinuousColorGradient,2},Array{Symbol,2}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border),Tuple{GridLayout,Array{Symbol,2},Bool,Nothing,Symbol}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation),Tuple{GridLayout,Array{String,2},Symbol,Array{Length{:mm,Float64},2},Length{:mm,Float64},Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims),Tuple{GridLayout,Tuple{Int64,Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Array{Tuple{Int64,Real},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,),Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms),Tuple{Tuple{Array{Symbol,2},Int64},Array{String,2},Int64}},typeof(plot),Array{Array{T,1} where T,1},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle),Tuple{Tuple{Int64,Array{Symbol,2}},Array{String,2},String}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill),Tuple{Int64,Bool,Tuple{Int64,Symbol}}},typeof(plot),Function,Function,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg),Tuple{Tuple{Int64,Symbol,Symbol},Tuple{Shape,Int64,RGBA{Float64}},Symbol,Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Bool}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Int64,Bool}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype),Tuple{Tuple{Int64,Symbol},Array{String,2},Symbol,Tuple{Int64,Int64},Tuple{Int64,Int64},Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,),Tuple{Bool}},typeof(plot),Array{Union{Missing, Int64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype),Tuple{typeof(+),Symbol,Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth),Tuple{Array{Symbol,2},Array{Int64,2},Array{Int64,2},Array{Int64,2},Array{Int64,2}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype),Tuple{Int64,Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype),Tuple{Tuple{Int64,Int64},Bool,Bool,Int64,Symbol}},typeof(plot),Array{Complex{Float64},1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m),Tuple{Symbol,Int64}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype),Tuple{Symbol,Symbol}},typeof(plot),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},UnitRange{Int64},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype),Tuple{Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}},Symbol}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill),Tuple{Bool,Tuple{Int64,Symbol}}},typeof(plot),Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{Int64}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{Tuple{LinRange{Float64},LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,),Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color),Tuple{Array{Symbol,2},Array{Symbol,1},Int64,Array{Symbol,1}}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{DateTime,1},UnitRange{Int64},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,),Tuple{Symbol}},typeof(plot),Array{OHLC,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel),Tuple{Symbol,String,String,String}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Array{Float64,1},N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype),Tuple{String,Float64,Symbol}},typeof(plot),Array{String,1},Array{Float64,1}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{Array{String,2}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,),Tuple{String}},typeof(plot),Plot{PlotlyBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,),Tuple{Int64}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg),Tuple{Tuple{String,Tuple{Int64,Int64},StepRange{Int64,Int64},Symbol},RGB{Float64},Bool}},typeof(plot),Array{Float64,2}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio),Tuple{Bool,Symbol}},typeof(plot),Array{Float64,1},Array{Int64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w),Tuple{StepRange{Int64,Int64},Tuple{Int64,Float64,Symbol,Stroke},Bool,Bool,Int64}},typeof(plot),Array{Float64,1},Array{Float64,1},Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any,Vararg{Any,N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, PlotText}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{GRBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{PlotlyBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis,), Tuple{Tuple{String, Symbol}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vararg{Vector{Int64}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Vararg{Float64, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside), Tuple{Int64, Matrix{PlotUtils.ContinuousColorGradient}, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{GridLayout, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{GridLayout, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xguide, :yguide, :xguidefonthalign, :yguidefontvalign, :xguideposition, :yguideposition, :ymirror, :xmirror, :legend, :seriestype), Tuple{Int64, String, String, Matrix{Symbol}, Matrix{Symbol}, Symbol, Matrix{Symbol}, Matrix{Bool}, Matrix{Bool}, Bool, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{GridLayout, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Vector{Tuple{Int64, Real}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector{T} where T},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Tuple{Int64, Symbol}, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :seriestype, :label), Tuple{Symbol, Symbol, String}},typeof(plot),UnitRange{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64, Symbol}},typeof(plot),Vector{ComplexF64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m), Tuple{Symbol, Int64}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{OHLC}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype), Tuple{String, Float64, Symbol}},typeof(plot),Vector{String},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{String}},typeof(plot),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{String}},typeof(plot),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:yflip, :aspect_ratio), Tuple{Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp),Tuple{Array{Int64,1},Bool}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,),Tuple{Array{Int64,1}}},typeof(test_examples),Symbol})
-    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{Type{Shape},Array{Tuple{Float64,Float64},1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},AbstractArray{OHLC,1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Array{Complex{Float64},1}})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},PortfolioComposition})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:barhist}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:bar}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:histogram2d}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:hline}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:pie}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:quiver}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:spy}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:sticks}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol,Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
+    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barbins}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol,Any},Array{Dict{Symbol,Any},1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
-    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Array{Dict{Symbol,Any},1},Dict{Symbol,Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},DefaultsDict,Symbol,Any})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol,Any},Symbol,Any})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{GRBackend},Dict{Symbol, Any},Symbol,Any})
     Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},DefaultsDict,Symbol,Any})
-    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol,Any},Symbol,Any})
-    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}}})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Int64,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Nothing,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{PlotUtils.ContinuousColorGradient,1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},1},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Array{Symbol,1},String})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Array{Float64,1},UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Array{Int64,1}})
-    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64,Int64},Array{Int64,1}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol,Any})
+    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Nothing},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
+    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
     Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
-    Base.precompile(Tuple{typeof(_heatmap_edges),Array{Float64,1},Bool,Bool})
+    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
     Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
-    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Array{Symbol,1}})
+    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
     Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
-    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol,Any},Int64,Bool})
-    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol,Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
+    Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{GRBackend},Vector{Any}})
+    Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{PlotlyBackend},Vector{Any}})
     Base.precompile(Tuple{typeof(backend),PlotlyBackend})
+    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
-    Base.precompile(Tuple{typeof(bbox),Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64},Length{:mm,Float64}})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
-    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Int64,Float64}})
+    Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
     Base.precompile(Tuple{typeof(create_grid),Expr})
-    Base.precompile(Tuple{typeof(error_coords),Array{Float64,1},Array{Float64,1},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(error_zipit),Tuple{Array{Float64,1},Array{Float64,1},Array{Float64,1}}})
-    Base.precompile(Tuple{typeof(expand_extrema!),Axis,StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(fakedata),Int64,Vararg{Int64,N} where N})
-    Base.precompile(Tuple{typeof(font),String,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(get_clims),Subplot{GRBackend},Series,Function})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Array{Int64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{GRBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_series_color),Array{Symbol,1},Subplot{PlotlyBackend},Int64,Symbol})
-    Base.precompile(Tuple{typeof(get_xy),Array{OHLC,1}})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},Length{:mm,Float64},Length{:mm,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64,Float64},Array{Float64,1}})
-    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_grid),Subplot{GRBackend},Axis,Segments{Tuple{Float64,Float64}}})
-    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Array{Int64,1},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Float64,1},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Int64,1},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Array{Int64,1},Array{Int64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Array{Float64,1},Array{Float64,1}},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64,Int64},Array{Float64,1},Int64,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Array{Float64,1},Nothing,Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,1},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Array{Float64,1},Array{Float64,1},Array{Float64,2},Tuple{Float64,Float64}})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{Any,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Float64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Array{Int64,1},Array{String,1}},Int64})
-    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
-    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Array{Float64,1},Array{String,1}}})
+    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{String}})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
+    Base.precompile(Tuple{typeof(font),String,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
+    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{PlotlyBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
+    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
-    Base.precompile(Tuple{typeof(gr_polyline),Array{Float64,1},Array{Float64,1},Function})
+    Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
-    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Array{Float64,1},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),NTuple{9,Float64}}})
-    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Array{Float64,1},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor),Tuple{Int64,Float64,Float64,Float64,Int64,Float64,Float64,Float64,Float64}}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Array{Float64,1},Symbol})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
+    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}}})
+    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
     Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64,Base.TwicePrecision{Float64},Base.TwicePrecision{Float64}},Symbol})
+    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
+    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(ignorenan_minimum),Array{Int64,1}})
+    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
+    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
+    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
     Base.precompile(Tuple{typeof(layout_args),Int64})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
-    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,StepRange{Int64,Int64}})
-    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Subplot{GRBackend},Axis,UnitRange{Int64}})
-    Base.precompile(Tuple{typeof(plot!),Any})
-    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
+    Base.precompile(Tuple{typeof(plot),Any,Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(plot),Any})
     Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
-    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol,Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Int64})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol,Any},Symbol})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Array{Symbol,2}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Shape})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Stroke})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol,Any},Symbol})
+    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},StepRange{Int64,Int64},Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},Symbol,Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol,Any},Tuple{Int64,Int64},Symbol})
-    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Array{Float64,1}})
-    Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
-    Base.precompile(Tuple{typeof(quiver_using_hack),DefaultsDict})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
     Base.precompile(Tuple{typeof(reset_axis_defaults_byletter!)})
-    Base.precompile(Tuple{typeof(slice_arg),Array{Int64,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{Length{:mm,Float64},2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{PlotUtils.ContinuousColorGradient,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{RGBA{Float64},2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{String,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Array{Symbol,2},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64,2,UnitRange{Int64},Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
-    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64,Float64},Tuple{Float64,Float64},Array{Float64,1},Array{Float64,1},Int64})
-    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol,N} where N})
-    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
+    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(text),String,Int64,Symbol,Vararg{Symbol, N} where N})
+    Base.precompile(Tuple{typeof(text),String,Symbol,Int64,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(title!),AbstractString})
-    Base.precompile(Tuple{typeof(unzip),Array{GeometryBasics.Point{2,Float64},1}})
+    Base.precompile(Tuple{typeof(unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(vline!),Any})
-    Base.precompile(Tuple{typeof(wireframe),Any,Vararg{Any,N} where N})
-    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any,N} where N})
+    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
     Base.precompile(Tuple{typeof(yaxis!),Any,Any})
-    let fbody = try __lookup_kwbody__(which(gr_polyline, (Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))) catch missing end
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Array{Float64,1},Array{Float64,1},typeof(GR.fillarea),))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot!, ())) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),))
+            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
         end
     end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
@@ -346,9 +367,9 @@ function _precompile_()
             precompile(fbody, (Any,typeof(plot!),Any,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any,N} where N,))
+            precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any, N} where N,))
         end
     end
     let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
@@ -356,34 +377,24 @@ function _precompile_()
             precompile(fbody, (Any,typeof(plot),Any,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any,N} where N,))
+            precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,Vararg{Plot, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,))
+            precompile(fbody, (Any,typeof(plot),Plot,Plot,Vararg{Plot, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(text, (String,Int64,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,Plot,))
+            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(text),String,Int64,Vararg{Any, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(plot, (Plot,Plot,Vararg{Plot,N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(plot),Plot,Plot,Vararg{Plot,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(text, (String,Int64,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Int64,Vararg{Any,N} where N,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(text, (String,Symbol,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}},typeof(text),String,Symbol,Vararg{Any,N} where N,))
+            precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(text),String,Symbol,Vararg{Any, N} where N,))
         end
     end
     let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
@@ -391,14 +402,9 @@ function _precompile_()
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(vline!, (Any,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
         if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(vline!),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any,N} where N,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any,N} where N,))
+            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
         end
     end
 end

src/Plots.jl

@@ -193,6 +193,7 @@ const _plotly_min_js_filename = "plotly-1.57.1.min.js"
 
 include("types.jl")
 include("utils.jl")
+include("colorbars.jl")
 include("axes.jl")
 include("args.jl")
 include("components.jl")

src/animation.jl

@@ -137,8 +137,8 @@ end
 # -----------------------------------------------
 
 function _animate(forloop::Expr, args...; callgif = false)
-  if forloop.head != :for
-    error("@animate macro expects a for-block. got: $(forloop.head)")
+  if forloop.head ∉ (:for, :while)
+    error("@animate macro expects a for- or while-block. got: $(forloop.head)")
   end
 
   # add the call to frame to the end of each iteration

src/arg_desc.jl

@@ -2,164 +2,177 @@
 const _arg_desc = KW(
 
 # series args
-:label 			=> "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
-:seriescolor 		=> "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
-:seriesalpha 		=> "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
-:seriestype 		=> "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
-:linestyle 			=> "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
-:linewidth         	=> "Number. Width of the line (in pixels)",
-:linecolor         	=> "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
-:linealpha         	=> "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
-:fillrange         	=> "Number or AbstractVector.  Fills area between fillrange and y for line-types, sets the base for bar/stick types, and similar for other types.",
-:fillcolor         	=> "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
-:fillalpha         	=> "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
-:markershape       	=> "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
-:markercolor       	=> "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
-:markeralpha       	=> "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
-:markersize        	=> "Number or AbstractVector. Size (radius pixels) of the markers.",
-:markerstrokestyle 	=> "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
-:markerstrokewidth 	=> "Number. Width of the marker stroke (border. in pixels)",
-:markerstrokecolor 	=> "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
-:markerstrokealpha 	=> "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
-:bins              	=> "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
-:smooth            	=> "Bool.  Add a regression line?",
-:group             	=> "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
-:x                 	=> "Various. Input data. First Dimension",
-:y                 	=> "Various. Input data. Second Dimension",
-:z                 	=> "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
-:marker_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
-:line_z          	=> "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
-:fill_z                 => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
-:levels            	=> "Integer, NTuple{2,Integer}, or AbstractVector. Levels or number of levels (or x-levels/y-levels) for a contour type.",
-:orientation       	=> "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
-:bar_position      	=> "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
-:bar_width              => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
-:bar_edges              => "Bool.  Align bars to edges (true), or centers (the default)?",
-:xerror                 => "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
-:yerror            	=> "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
-:ribbon            	=> "Number or AbstractVector.  Creates a fillrange around the data points.",
-:quiver            	=> "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
-:arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
-:normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
-:weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
-:show_empty_bins    => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
-:contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
-:contour_labels         => "Bool. Show labels at the contour lines?",
-:match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
-:subplot           	=> "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
-:series_annotations     => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
-:primary                => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
-:hover 	        	=> "nothing or vector of strings. Text to display when hovering over each data point.",
-:colorbar_entry   => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
+:label                       => "String type. The label for a series, which appears in a legend.  If empty, no legend entry is added.",
+:seriescolor                 => "Color Type. The base color for this series.  `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot",
+:seriesalpha                 => "Number in [0,1]. The alpha/opacity override for the series.  `nothing` (the default) means it will take the alpha value of the color.",
+:seriestype                  => "Symbol. This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined.",
+:linestyle                   => "Symbol. Style of the line (for path and bar stroke).  Choose from $(_allStyles)",
+:linewidth                   => "Number. Width of the line (in pixels)",
+:linecolor                   => "Color Type. Color of the line (for path and bar stroke).  `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default).",
+:linealpha                   => "Number in [0,1]. The alpha/opacity override for the line.  `nothing` (the default) means it will take the alpha value of linecolor.",
+:fillrange                   => "Number or AbstractVector.  Fills area between fillrange and y for line-types, sets the base for bar/stick types, and similar for other types.",
+:fillcolor                   => "Color Type. Color of the filled area of path or bar types.  `:match` will take the value from `:seriescolor`.",
+:fillalpha                   => "Number in [0,1]. The alpha/opacity override for the fill area.  `nothing` (the default) means it will take the alpha value of fillcolor.",
+:markershape                 => "Symbol, Shape, or AbstractVector. Choose from $(_allMarkers).",
+:markercolor                 => "Color Type. Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`.",
+:markeralpha                 => "Number in [0,1]. The alpha/opacity override for the marker interior.  `nothing` (the default) means it will take the alpha value of markercolor.",
+:markersize                  => "Number or AbstractVector. Size (radius pixels) of the markers.",
+:markerstrokestyle           => "Symbol. Style of the marker stroke (border).  Choose from $(_allStyles)",
+:markerstrokewidth           => "Number. Width of the marker stroke (border. in pixels)",
+:markerstrokecolor           => "Color Type. Color of the marker stroke (border).  `:match` will take the value from `:foreground_color_subplot`.",
+:markerstrokealpha           => "Number in [0,1]. The alpha/opacity override for the marker stroke (border).  `nothing` (the default) means it will take the alpha value of markerstrokecolor.",
+:bins                        => "Integer, NTuple{2,Integer}, AbstractVector or Symbol. Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd). For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`",
+:smooth                      => "Bool.  Add a regression line?",
+:group                       => "AbstractVector. Data is split into a separate series, one for each unique value in `group`.",
+:x                           => "Various. Input data. First Dimension",
+:y                           => "Various. Input data. Second Dimension",
+:z                           => "Various. Input data. Third Dimension. May be wrapped by a `Surface` for surface and heatmap types.",
+:marker_z                    => "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series data point, which correspond to the color to be used from a markercolor gradient.",
+:line_z                      => "AbstractVector, Function `f(x,y,z) -> z_value`, or Function `f(x,y) -> z_value`, or nothing. z-values for each series line segment, which correspond to the color to be used from a linecolor gradient.  Note that for N points, only the first N-1 values are used (one per line-segment).",
+:fill_z                      => "Matrix{Float64} of the same size as z matrix, which specifies the color of the 3D surface; the default value is `nothing`.",
+:levels                      => "Integer, NTuple{2,Integer}, or AbstractVector. Levels or number of levels (or x-levels/y-levels) for a contour type.",
+:orientation                 => "Symbol.  Horizontal or vertical orientation for bar types.  Values `:h`, `:hor`, `:horizontal` correspond to horizontal (sideways, anchored to y-axis), and `:v`, `:vert`, and `:vertical` correspond to vertical (the default).",
+:bar_position                => "Symbol.  Choose from `:overlay` (default), `:stack`.  (warning: May not be implemented fully)",
+:bar_width                   => "nothing or Number. Width of bars in data coordinates. When nothing, chooses based on x (or y when `orientation = :h`).",
+:bar_edges                   => "Bool.  Align bars to edges (true), or centers (the default)?",
+:xerror                      => "AbstractVector or 2-Tuple of Vectors. x (horizontal) error relative to x-value.  If 2-tuple of vectors, the first vector corresponds to the left error (and the second to the right)",
+:yerror                      => "AbstractVector or 2-Tuple of Vectors. y (vertical) error relative to y-value.  If 2-tuple of vectors, the first vector corresponds to the bottom error (and the second to the top)",
+:ribbon                      => "Number or AbstractVector.  Creates a fillrange around the data points.",
+:quiver                      => "AbstractVector or 2-Tuple of vectors.  The directional vectors U,V which specify velocity/gradient vectors for a quiver plot.",
+:arrow                       => "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
+:normalize                   => "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
+:weights                     => "AbstractVector. Used in histogram types for weighted counts.",
+:show_empty_bins             => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
+:contours                    => "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
+:contour_labels              => "Bool. Show labels at the contour lines?",
+:match_dimensions            => "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
+:subplot                     => "Integer (subplot index) or Subplot object.  The subplot that this series belongs to.",
+:series_annotations          => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
+:primary                     => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
+:hover                       => "nothing or vector of strings. Text to display when hovering over each data point.",
+:colorbar_entry              => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",
 
 # plot args
-:plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
-:background_color         => "Color Type.  Base color for all backgrounds.",
-:background_color_outside => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
-:foreground_color         => "Color Type.  Base color for all foregrounds.",
-:size                     => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
-:pos                      => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
-:window_title             => "String. Title of the standalone gui-window.",
-:show                     => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
-:layout                   => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
-:link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
-:overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
-:html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
-:tex_output_standalone    => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
-:inset_subplots           => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
-:dpi 			  => "Number.  Dots Per Inch of output figures",
-:thickness_scaling        => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
-:display_type             => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
-:extra_kwargs 	          => "Either one of (`:plot`, `:subplot`, `:series`) to specify for which element extra keyword args are collected or a KW (Dict{Symbol,Any}) to pass a map of extra keyword args which may be specific to a backend. Default: `:series`.\n Example: `pgfplotsx(); scatter(1:5, extra_kwargs=Dict(:subplot=>Dict(\"axis line shift\" => \"10pt\"))`",
-:fontfamily               => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
-:warn_on_unsupported      => "Bool. Warn on unsupported attributes, series types and marker shapes",
+:plot_title                  => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
+:background_color            => "Color Type.  Base color for all backgrounds.",
+:background_color_outside    => "Color Type or `:match` (matches `:background_color`).  Color outside the plot area(s)",
+:foreground_color            => "Color Type.  Base color for all foregrounds.",
+:size                        => "NTuple{2,Int}. (width_px, height_px) of the whole Plot",
+:pos                         => "NTuple{2,Int}. (left_px, top_px) position of the GUI window (note: currently unimplemented)",
+:window_title                => "String. Title of the standalone gui-window.",
+:show                        => "Bool.  Should this command open/refresh a GUI/display?  This allows displaying in scripts or functions without explicitly calling `display`",
+:layout                      => "Integer (number of subplots), NTuple{2,Integer} (grid dimensions), AbstractLayout (for example `grid(2,2)`), or the return from the `@layout` macro.  This builds the layout of subplots.",
+:link                        => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
+:overwrite_figure            => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
+:html_output_format          => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:tex_output_standalone       => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
+:inset_subplots              => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
+:dpi                         => "Number.  Dots Per Inch of output figures",
+:thickness_scaling           => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
+:display_type                => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
+:extra_kwargs                => "Either one of (`:plot`, `:subplot`, `:series`) to specify for which element extra keyword args are collected or a KW (Dict{Symbol,Any}) to pass a map of extra keyword args which may be specific to a backend. Default: `:series`.\n Example: `pgfplotsx(); scatter(1:5, extra_kwargs=Dict(:subplot=>Dict(\"axis line shift\" => \"10pt\"))`",
+:fontfamily                  => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
+:warn_on_unsupported         => "Bool. Warn on unsupported attributes, series types and marker shapes",
 
 # subplot args
-:title                    => "String. Subplot title.",
-:titlelocation           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
-:titlefontfamily          => "String or Symbol. Font family of subplot title.",
-:titlefontsize            => "Integer. Font pointsize of subplot title.",
-:titlefonthalign          => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
-:titlefontvalign          => "Symbol. Font vertical alignment of subplot title: :vcenter, :top, :bottom or :center",
-:titlefontrotation        => "Real. Font rotation of subplot title",
-:titlefontcolor           => "Color Type. Font color of subplot title",
-:background_color_subplot => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
-:background_color_legend  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
-:background_color_inside  => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
-:foreground_color_subplot => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
-: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 (x,y) tuple or Symbol (legend position) or angle or (angle,inout) tuple. Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend). Legend is positioned at (angle degrees) (so (90,:outer) is roughly equivalent to :outertop), close to the inside of the axes or the outside if inout=:outer.",
-: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",
-:legendfontvalign         => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
-:legendfontrotation       => "Real. Font rotation of legend entries",
-:legendfontcolor          => "Color Type. Font color of legend entries",
-:legendtitle              => "String. Legend title.",
-:legendtitlefontfamily    => "String or Symbol. Font family of the legend title.",
-:legendtitlefontsize           => "Integer. Font pointsize the legend title.",
-:legendtitlefonthalign         => "Symbol. Font horizontal alignment of the legend title: :hcenter, :left, :right or :center",
-:legendtitlefontvalign         => "Symbol. Font vertical alignment of the legend title: :vcenter, :top, :bottom or :center",
-:legendtitlefontrotation       => "Real. Font rotation of the legend title",
-:legendtitlefontcolor          => "Color Type. Font color of the legend title",
-:colorbar                 => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
-:clims 					  => "`:auto`, NTuple{2,Number}, or a function that takes series data in and returns NTuple{2,Number}.  Fixes the limits of the colorbar.",
-:legendfont               => "Font. Font of legend items.",
-:legendtitlefont          => "Font. Font of the legend title.",
-:annotations              => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
-:projection               => "Symbol or String.  '3d' or 'polar'",
-:aspect_ratio             => "Symbol (:equal or :none) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units. With `:none`, images inherit aspect ratio of the plot area.",
-:margin                   => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",
-:left_margin              => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
-:top_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
-:right_margin             => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
-:bottom_margin            => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
-:subplot_index            => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
-:colorbar_title           => "String.  Title of colorbar.",
-:framestyle               => "Symbol.  Style of the axes frame. Choose from $(_allFramestyles)",
-:camera                   => "NTuple{2, Real}. Sets the view angle (azimuthal, elevation) for 3D plots",
+:title                       => "String. Subplot title.",
+:titlelocation               => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
+:titlefontfamily             => "String or Symbol. Font family of subplot title.",
+:titlefontsize               => "Integer. Font pointsize of subplot title.",
+:titlefonthalign             => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
+:titlefontvalign             => "Symbol. Font vertical alignment of subplot title: :vcenter, :top, :bottom or :center",
+:titlefontrotation           => "Real. Font rotation of subplot title",
+:titlefontcolor              => "Color Type. Font color of subplot title",
+:background_color_subplot    => "Color Type or `:match` (matches `:background_color`).  Base background color of the subplot.",
+:background_color_legend     => "Color Type or `:match` (matches `:background_color_subplot`).  Background color of the legend.",
+:background_color_inside     => "Color Type or `:match` (matches `:background_color_subplot`).  Background color inside the plot area (under the grid).",
+:foreground_color_subplot    => "Color Type or `:match` (matches `:foreground_color`).  Base foreground color of the subplot.",
+: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 (x,y) tuple or Symbol (legend position) or angle or (angle,inout) tuple. Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend). Legend is positioned at (angle degrees) (so (90,:outer) is roughly equivalent to :outertop), close to the inside of the axes or the outside if inout=:outer.",
+: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",
+:legendfontvalign            => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
+:legendfontrotation          => "Real. Font rotation of legend entries",
+:legendfontcolor             => "Color Type. Font color of legend entries",
+:legendtitle                 => "String. Legend title.",
+:legendtitlefontfamily       => "String or Symbol. Font family of the legend title.",
+:legendtitlefontsize         => "Integer. Font pointsize the legend title.",
+:legendtitlefonthalign       => "Symbol. Font horizontal alignment of the legend title: :hcenter, :left, :right or :center",
+:legendtitlefontvalign       => "Symbol. Font vertical alignment of the legend title: :vcenter, :top, :bottom or :center",
+:legendtitlefontrotation     => "Real. Font rotation of the legend title",
+:legendtitlefontcolor        => "Color Type. Font color of the legend title",
+:colorbar                    => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
+:clims 					 => "`:auto`, NTuple{2,Number}, or a function that takes series data in and returns NTuple{2,Number}.  Fixes the limits of the colorbar.",
+:colorbar_fontfamily         => "String or Symbol. Font family of colobar entries.",
+:colorbar_ticks              => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:colorbar_tickfontfamily     => "String or Symbol. Font family of colorbar tick labels.",
+:colorbar_tickfontsize       => "Integer. Font pointsize of colorbar tick entries.",
+:colorbar_tickfontcolor      => "Color Type. Font color of colorbar tick entries",
+:colorbar_scale              => "Symbol. Scale of the colorbar axis: `:none`, `:ln`, `:log2`, `:log10`",
+:colorbar_formatter          => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
+:legendfont                  => "Font. Font of legend items.",
+:legendtitlefont             => "Font. Font of the legend title.",
+:annotations                 => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
+:annotationfontfamily        => "String or Symbol. Font family of annotations.",
+:annotationfontsize          => "Integer. Font pointsize of annotations.",
+:annotationhalign            => "Symbol. horizontal alignment of annotations, :hcenter, :left, :right or :center.",
+:annotationvalign            => "Symbol. Vertical alignment of annotations, :vcenter, :top, :bottom or :center.",
+:annotationrotation          => "Float. Rotation of annotations in degrees.",
+:annotationcolor             => "Colorant or :match. Color of annotations.",
+:projection                  => "Symbol or String.  '3d' or 'polar'",
+:aspect_ratio                => "Symbol (:equal or :none) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units. With `:none`, images inherit aspect ratio of the plot area.",
+:margin                      => "Measure (multiply by `mm`, `px`, etc). Base for individual margins... not directly used.  Specifies the extra padding around subplots.",
+:left_margin                 => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the left of the subplot.",
+:top_margin                  => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the top of the subplot.",
+:right_margin                => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding to the right of the subplot.",
+:bottom_margin               => "Measure (multiply by `mm`, `px`, etc) or `:match` (matches `:margin`).  Specifies the extra padding on the bottom of the subplot.",
+:subplot_index               => "Integer.  Internal (not set by user).  Specifies the index of this subplot in the Plot's `plt.subplot` list.",
+:colorbar_title              => "String.  Title of colorbar.",
+:framestyle                  => "Symbol.  Style of the axes frame. Choose from $(_allFramestyles)",
+:camera                      => "NTuple{2, Real}. Sets the view angle (azimuthal, elevation) for 3D plots",
 
 # axis args
-:guide     		  => "String. Axis guide (label).",
-:guide_position		  => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
-:lims      		  => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
-:ticks     		  => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
-:scale     		  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
-:rotation  		  => "Number. Degrees rotation of tick labels.",
-:flip      		  => "Bool.  Should we flip (reverse) the axis?",
-:formatter                => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
-:tickfontfamily           => "String or Symbol. Font family of tick labels.",
-:tickfontsize             => "Integer. Font pointsize of tick labels.",
-:tickfonthalign           => "Symbol. Font horizontal alignment of tick labels: :hcenter, :left, :right or :center",
-:tickfontvalign           => "Symbol. Font vertical alignment of tick labels: :vcenter, :top, :bottom or :center",
-:tickfontrotation         => "Real. Font rotation of tick labels",
-:tickfontcolor            => "Color Type. Font color of tick labels",
-:guidefontfamily          => "String or Symbol. Font family of axes guides.",
-:guidefontsize            => "Integer. Font pointsize of axes guides.",
-:guidefonthalign          => "Symbol. Font horizontal alignment of axes guides: :hcenter, :left, :right or :center",
-:guidefontvalign          => "Symbol. Font vertical alignment of axes guides: :vcenter, :top, :bottom or :center",
-:guidefontrotation        => "Real. Font rotation of axes guides",
-:guidefontcolor           => "Color Type. Font color of axes guides",
-:foreground_color_axis    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",
-:foreground_color_border  => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of plot area border (spines).",
-:foreground_color_text    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of tick labels.",
-:foreground_color_guide   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis guides (axis labels).",
-:mirror                   => "Bool.  Switch the side of the tick labels (right or top).",
-:grid                     => "Bool, Symbol, String or `nothing`. Show the grid lines? `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:none`, `:off`",
-:foreground_color_grid    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
-:gridalpha                => "Number in [0,1]. The alpha/opacity override for the grid lines.",
-:gridstyle                => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
-:gridlinewidth            => "Number. Width of the grid lines (in pixels)",
+:guide                       => "String. Axis guide (label).",
+:guide_position              => "Symbol. Position of axis guides: :top, :bottom, :left or :right",
+:lims                        => "NTuple{2,Number} or Symbol. Force axis limits.  Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example). `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]",
+:ticks                       => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
+:scale                       => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
+:rotation                    => "Number. Degrees rotation of tick labels.",
+:flip                        => "Bool.  Should we flip (reverse) the axis?",
+:formatter                   => "Function, :scientific, :plain or :auto. A method which converts a number to a string for tick labeling.",
+:tickfontfamily              => "String or Symbol. Font family of tick labels.",
+:tickfontsize                => "Integer. Font pointsize of tick labels.",
+:tickfonthalign              => "Symbol. Font horizontal alignment of tick labels: :hcenter, :left, :right or :center",
+:tickfontvalign              => "Symbol. Font vertical alignment of tick labels: :vcenter, :top, :bottom or :center",
+:tickfontrotation            => "Real. Font rotation of tick labels",
+:tickfontcolor               => "Color Type. Font color of tick labels",
+:guidefontfamily             => "String or Symbol. Font family of axes guides.",
+:guidefontsize               => "Integer. Font pointsize of axes guides.",
+:guidefonthalign             => "Symbol. Font horizontal alignment of axes guides: :hcenter, :left, :right or :center",
+:guidefontvalign             => "Symbol. Font vertical alignment of axes guides: :vcenter, :top, :bottom or :center",
+:guidefontrotation           => "Real. Font rotation of axes guides",
+:guidefontcolor              => "Color Type. Font color of axes guides",
+:foreground_color_axis       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",
+:foreground_color_border     => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of plot area border (spines).",
+:foreground_color_text       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of tick labels.",
+:foreground_color_guide      => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis guides (axis labels).",
+:mirror                      => "Bool.  Switch the side of the tick labels (right or top).",
+:grid                        => "Bool, Symbol, String or `nothing`. Show the grid lines? `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:none`, `:off`",
+:foreground_color_grid       => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of grid lines.",
+:gridalpha                   => "Number in [0,1]. The alpha/opacity override for the grid lines.",
+:gridstyle                   => "Symbol. Style of the grid lines. Choose from $(_allStyles)",
+:gridlinewidth               => "Number. Width of the grid lines (in pixels)",
 :foreground_color_minor_grid => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of minor grid lines.",
-:minorgrid                => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
-:minorticks               => "Integer. Intervals to divide the gap between major ticks into",
-:minorgridalpha           => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
-:minorgridstyle           => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
-:minorgridlinewidth       => "Number. Width of the minor grid lines (in pixels)",
-:tick_direction           => "Symbol.  Direction of the ticks. `:in` or `:out`",
-:showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
-:widen                    => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
-:draw_arrow               => "Bool. Draw arrow at the end of the axis.",
+:minorgrid                   => "Bool. Adds minor grid lines and ticks to the plot. Set minorticks to change number of gridlines",
+:minorticks                  => "Integer. Intervals to divide the gap between major ticks into",
+:minorgridalpha              => "Number in [0,1]. The alpha/opacity override for the minorgrid lines.",
+:minorgridstyle              => "Symbol. Style of the minor grid lines. Choose from $(_allStyles)",
+:minorgridlinewidth          => "Number. Width of the minor grid lines (in pixels)",
+:tick_direction              => "Symbol.  Direction of the ticks. `:in`, `:out` or `:none`",
+:showaxis                    => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
+:widen                       => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
+:draw_arrow                  => "Bool. Draw arrow at the end of the axis.",
 )

src/args.jl

@@ -54,7 +54,7 @@ const _3dTypes = [
     :path3d, :scatter3d, :surface, :wireframe, :contour3d, :volume, :mesh3d
 ]
 const _allTypes = vcat([
-    :none, :line, :path, :steppre, :steppost, :sticks, :scatter,
+    :none, :line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter,
     :heatmap, :hexbin, :barbins, :barhist, :histogram, :scatterbins,
     :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :histogram3d,
     :density, :bar, :hline, :vline,
@@ -101,7 +101,7 @@ const _typeAliases = Dict{Symbol,Symbol}(
 add_non_underscore_aliases!(_typeAliases)
 
 const _histogram_like = [:histogram, :barhist, :barbins]
-const _line_like = [:line, :path, :steppre, :steppost]
+const _line_like = [:line, :path, :steppre, :stepmid, :steppost]
 const _surface_like = [:contour, :contourf, :contour3d, :heatmap, :surface, :wireframe, :image]
 
 like_histogram(seriestype::Symbol) = seriestype in _histogram_like
@@ -151,54 +151,54 @@ const _shape_keys = Symbol[
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
 const _markerAliases = Dict{Symbol,Symbol}(
-    :n            => :none,
-    :no           => :none,
-    :a            => :auto,
-    :ellipse      => :circle,
-    :c            => :circle,
-    :circ         => :circle,
-    :square       => :rect,
-    :sq           => :rect,
-    :r            => :rect,
-    :d            => :diamond,
-    :^            => :utriangle,
-    :ut           => :utriangle,
-    :utri         => :utriangle,
-    :uptri        => :utriangle,
-    :uptriangle   => :utriangle,
-    :v            => :dtriangle,
-    :V            => :dtriangle,
-    :dt           => :dtriangle,
-    :dtri         => :dtriangle,
-    :downtri      => :dtriangle,
-    :downtriangle => :dtriangle,
-    :>            => :rtriangle,
-    :rt           => :rtriangle,
-    :rtri         => :rtriangle,
+    :n             => :none,
+    :no            => :none,
+    :a             => :auto,
+    :ellipse       => :circle,
+    :c             => :circle,
+    :circ          => :circle,
+    :square        => :rect,
+    :sq            => :rect,
+    :r             => :rect,
+    :d             => :diamond,
+    :^             => :utriangle,
+    :ut            => :utriangle,
+    :utri          => :utriangle,
+    :uptri         => :utriangle,
+    :uptriangle    => :utriangle,
+    :v             => :dtriangle,
+    :V             => :dtriangle,
+    :dt            => :dtriangle,
+    :dtri          => :dtriangle,
+    :downtri       => :dtriangle,
+    :downtriangle  => :dtriangle,
+    :>             => :rtriangle,
+    :rt            => :rtriangle,
+    :rtri          => :rtriangle,
     :righttri      => :rtriangle,
     :righttriangle => :rtriangle,
-    :<            => :ltriangle,
-    :lt           => :ltriangle,
-    :ltri         => :ltriangle,
+    :<             => :ltriangle,
+    :lt            => :ltriangle,
+    :ltri          => :ltriangle,
     :lighttri      => :ltriangle,
     :lighttriangle => :ltriangle,
-    # :+            => :cross,
-    :plus         => :cross,
-    # :x            => :xcross,
-    :X            => :xcross,
-    :star         => :star5,
-    :s            => :star5,
-    :star1        => :star5,
-    :s2           => :star8,
-    :star2        => :star8,
-    :p            => :pentagon,
-    :pent         => :pentagon,
-    :h            => :hexagon,
-    :hex          => :hexagon,
-    :hep          => :heptagon,
-    :o            => :octagon,
-    :oct          => :octagon,
-    :spike        => :vline,
+    # :+           => :cross,
+    :plus          => :cross,
+    # :x           => :xcross,
+    :X             => :xcross,
+    :star          => :star5,
+    :s             => :star5,
+    :star1         => :star5,
+    :s2            => :star8,
+    :star2         => :star8,
+    :p             => :pentagon,
+    :pent          => :pentagon,
+    :h             => :hexagon,
+    :hex           => :hexagon,
+    :hep           => :heptagon,
+    :o             => :octagon,
+    :oct           => :octagon,
+    :spike         => :vline,
 )
 
 const _positionAliases = Dict{Symbol,Symbol}(
@@ -273,58 +273,58 @@ const _bar_width = 0.8
 # -----------------------------------------------------------------------------
 
 const _series_defaults = KW(
-    :label             => :auto,
-    :colorbar_entry    => true,
-    :seriescolor       => :auto,
-    :seriesalpha       => nothing,
-    :seriestype        => :path,
-    :linestyle         => :solid,
-    :linewidth         => :auto,
-    :linecolor         => :auto,
-    :linealpha         => nothing,
-    :fillrange         => nothing,   # ribbons, areas, etc
-    :fillcolor         => :match,
-    :fillalpha         => nothing,
-    :markershape       => :none,
-    :markercolor       => :match,
-    :markeralpha       => nothing,
-    :markersize        => 4,
-    :markerstrokestyle => :solid,
-    :markerstrokewidth => 1,
-    :markerstrokecolor => :match,
-    :markerstrokealpha => nothing,
-    :bins              => :auto,        # number of bins for hists
-    :smooth            => false,     # regression line?
-    :group             => nothing,   # groupby vector
-    :x                 => nothing,
-    :y                 => nothing,
-    :z                 => nothing,   # depth for contour, surface, etc
-    :marker_z          => nothing,   # value for color scale
-    :line_z            => nothing,
-    :fill_z            => nothing,
-    :levels            => 15,
-    :orientation       => :vertical,
-    :bar_position      => :overlay,  # for bar plots and histograms: could also be stack (stack up) or dodge (side by side)
-    :bar_width         => nothing,
-    :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...)`
-    :normalize         => false,     # do we want a normalized histogram?
-    :weights           => nothing,   # optional weights for histograms (1D and 2D)
-    :show_empty_bins   => false,     # should empty bins in 2D histogram be colored as zero (otherwise they are transparent)
-    :contours          => false,     # add contours to 3d surface and wireframe plots
-    :contour_labels    => false,
-    :subplot           => :auto,     # which subplot(s) does this series belong to?
+    :label              => :auto,
+    :colorbar_entry     => true,
+    :seriescolor        => :auto,
+    :seriesalpha        => nothing,
+    :seriestype         => :path,
+    :linestyle          => :solid,
+    :linewidth          => :auto,
+    :linecolor          => :auto,
+    :linealpha          => nothing,
+    :fillrange          => nothing,   # ribbons, areas, etc
+    :fillcolor          => :match,
+    :fillalpha          => nothing,
+    :markershape        => :none,
+    :markercolor        => :match,
+    :markeralpha        => nothing,
+    :markersize         => 4,
+    :markerstrokestyle  => :solid,
+    :markerstrokewidth  => 1,
+    :markerstrokecolor  => :match,
+    :markerstrokealpha  => nothing,
+    :bins               => :auto,        # number of bins for hists
+    :smooth             => false,     # regression line?
+    :group              => nothing,   # groupby vector
+    :x                  => nothing,
+    :y                  => nothing,
+    :z                  => nothing,   # depth for contour, surface, etc
+    :marker_z           => nothing,   # value for color scale
+    :line_z             => nothing,
+    :fill_z             => nothing,
+    :levels             => 15,
+    :orientation        => :vertical,
+    :bar_position       => :overlay,  # for bar plots and histograms: could also be stack (stack up) or dodge (side by side)
+    :bar_width          => nothing,
+    :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...)`
+    :normalize          => false,     # do we want a normalized histogram?
+    :weights            => nothing,   # optional weights for histograms (1D and 2D)
+    :show_empty_bins    => false,     # should empty bins in 2D histogram be colored as zero (otherwise they are transparent)
+    :contours           => false,     # add contours to 3d surface and wireframe plots
+    :contour_labels     => false,
+    :subplot            => :auto,     # which subplot(s) does this series belong to?
     :series_annotations => nothing,       # a list of annotations which apply to the coordinates of this series
     :primary            => true,     # when true, this "counts" as a series for color selection, etc.  the main use is to allow
                                      #     one logical series to be broken up (path and markers, for example)
     :hover              => nothing,  # text to display when hovering over the data points
     :stride             => (1,1),    # array stride for wireframe/surface, the first element is the row stride and the second is the column stride.
-    :connections	  => nothing,  # tuple of arrays to specifiy connectivity of a 3d mesh
+    :connections        => nothing,  # tuple of arrays to specifiy connectivity of a 3d mesh
     :extra_kwargs       => Dict()
 )
 
@@ -363,104 +363,121 @@ const _plot_defaults = KW(
 
 
 const _subplot_defaults = KW(
-    :title                    => "",
-    :titlelocation            => :center,           # also :left or :right
-    :fontfamily_subplot       => :match,
-    :titlefontfamily          => :match,
-    :titlefontsize            => 14,
-    :titlefonthalign          => :hcenter,
-    :titlefontvalign          => :vcenter,
-    :titlefontrotation        => 0.0,
-    :titlefontcolor           => :match,
-    :background_color_subplot => :match,            # default for other bg colors... match takes plot default
-    :background_color_legend  => :match,            # background of legend
-    :background_color_inside  => :match,            # background inside grid
-    :foreground_color_subplot => :match,            # default for other fg colors... match takes plot default
-    :foreground_color_legend  => :match,            # foreground of legend
-    :foreground_color_title   => :match,            # title color
-    :color_palette            => :auto,
-    :legend                   => :best,
-    :legendtitle              => nothing,
-    :colorbar                 => :legend,
-    :clims                    => :auto,
-    :legendfontfamily         => :match,
-    :legendfontsize           => 8,
-    :legendfonthalign         => :hcenter,
-    :legendfontvalign         => :vcenter,
-    :legendfontrotation       => 0.0,
-    :legendfontcolor          => :match,
-    :legendtitlefontfamily    => :match,
-    :legendtitlefontsize      => 11,
-    :legendtitlefonthalign    => :hcenter,
-    :legendtitlefontvalign    => :vcenter,
-    :legendtitlefontrotation  => 0.0,
-    :legendtitlefontcolor     => :match,
-    :annotations              => [],                # annotation tuples... list of (x,y,annotation)
-    :projection               => :none,             # can also be :polar or :3d
-    :aspect_ratio             => :auto,             # choose from :none or :equal
-    :margin                   => 1mm,
-    :left_margin              => :match,
-    :top_margin               => :match,
-    :right_margin             => :match,
-    :bottom_margin            => :match,
-    :subplot_index            => -1,
-    :colorbar_title                  => "",
-    :colorbar_titlefontsize          => 10,
-    :colorbar_title_location         => :center,           # also :left or :right
-    :colorbar_fontfamily             => :match,
-    :colorbar_titlefontfamily        => :match,
-    :colorbar_titlefonthalign        => :hcenter,
-    :colorbar_titlefontvalign        => :vcenter,
-    :colorbar_titlefontrotation      => 0.0,
-    :colorbar_titlefontcolor         => :match,
-    :framestyle                      => :axes,
-    :camera                          => (30,30),
-    :extra_kwargs                    => Dict()
+    :title                      => "",
+    :titlelocation              => :center,           # also :left or :right
+    :fontfamily_subplot         => :match,
+    :titlefontfamily            => :match,
+    :titlefontsize              => 14,
+    :titlefonthalign            => :hcenter,
+    :titlefontvalign            => :vcenter,
+    :titlefontrotation          => 0.0,
+    :titlefontcolor             => :match,
+    :background_color_subplot   => :match,            # default for other bg colors... match takes plot default
+    :background_color_legend    => :match,            # background of legend
+    :background_color_inside    => :match,            # background inside grid
+    :foreground_color_subplot   => :match,            # default for other fg colors... match takes plot default
+    :foreground_color_legend    => :match,            # foreground of legend
+    :foreground_color_title     => :match,            # title color
+    :color_palette              => :auto,
+    :legend                     => :best,
+    :legendtitle                => nothing,
+    :colorbar                   => :legend,
+    :clims                      => :auto,
+    :colorbar_fontfamily        => :match,
+    :colorbar_ticks             => :auto,
+    :colorbar_tickfontfamily    => :match,
+    :colorbar_tickfontsize      => 8,
+    :colorbar_tickfonthalign    => :hcenter,
+    :colorbar_tickfontvalign    => :vcenter,
+    :colorbar_tickfontrotation  => 0.0,
+    :colorbar_tickfontcolor     => :match,
+    :colorbar_scale             => :identity,
+    :colorbar_formatter         => :auto,
+    :colorbar_discrete_values   => [],
+    :colorbar_continuous_values   => zeros(0),
+    :legendfontfamily           => :match,
+    :legendfontsize             => 8,
+    :legendfonthalign           => :hcenter,
+    :legendfontvalign           => :vcenter,
+    :legendfontrotation         => 0.0,
+    :legendfontcolor            => :match,
+    :legendtitlefontfamily      => :match,
+    :legendtitlefontsize        => 11,
+    :legendtitlefonthalign      => :hcenter,
+    :legendtitlefontvalign      => :vcenter,
+    :legendtitlefontrotation    => 0.0,
+    :legendtitlefontcolor       => :match,
+    :annotations                => [],                # annotation tuples... list of (x,y,annotation)
+    :annotationfontfamily       => :match,
+    :annotationfontsize         => 14,
+    :annotationhalign           => :hcenter,
+    :annotationvalign           => :vcenter,
+    :annotationrotation         => 0.0,
+    :annotationcolor            => :match,
+    :projection                 => :none,             # can also be :polar or :3d
+    :aspect_ratio               => :auto,             # choose from :none or :equal
+    :margin                     => 1mm,
+    :left_margin                => :match,
+    :top_margin                 => :match,
+    :right_margin               => :match,
+    :bottom_margin              => :match,
+    :subplot_index              => -1,
+    :colorbar_title             => "",
+    :colorbar_titlefontsize     => 10,
+    :colorbar_title_location    => :center,           # also :left or :right
+    :colorbar_titlefontfamily   => :match,
+    :colorbar_titlefonthalign   => :hcenter,
+    :colorbar_titlefontvalign   => :vcenter,
+    :colorbar_titlefontrotation => 0.0,
+    :colorbar_titlefontcolor    => :match,
+    :framestyle                 => :axes,
+    :camera                     => (30,30),
+    :extra_kwargs               => Dict()
 )
 
 const _axis_defaults = KW(
-    :guide     => "",
-    :guide_position => :auto,
-    :lims      => :auto,
-    :ticks     => :auto,
-    :scale     => :identity,
-    :rotation  => 0,
-    :flip      => false,
-    :link      => [],
-    :tickfontfamily         => :match,
-    :tickfontsize           => 8,
-    :tickfonthalign         => :hcenter,
-    :tickfontvalign         => :vcenter,
-    :tickfontrotation       => 0.0,
-    :tickfontcolor          => :match,
-    :guidefontfamily         => :match,
-    :guidefontsize           => 11,
-    :guidefonthalign         => :hcenter,
-    :guidefontvalign         => :vcenter,
-    :guidefontrotation       => 0.0,
-    :guidefontcolor          => :match,
-    :foreground_color_axis   => :match,            # axis border/tick colors,
-    :foreground_color_border => :match,            # plot area border/spines,
-    :foreground_color_text   => :match,            # tick text color,
-    :foreground_color_guide  => :match,            # guide text color,
-    :discrete_values => [],
-    :formatter => :auto,
-    :mirror => false,
-    :grid                     => true,
-    :foreground_color_grid    => :match,            # grid color
-    :gridalpha                => 0.1,
-    :gridstyle                => :solid,
-    :gridlinewidth            => 0.5,
+    :guide                       => "",
+    :guide_position              => :auto,
+    :lims                        => :auto,
+    :ticks                       => :auto,
+    :scale                       => :identity,
+    :rotation                    => 0,
+    :flip                        => false,
+    :link                        => [],
+    :tickfontfamily              => :match,
+    :tickfontsize                => 8,
+    :tickfonthalign              => :hcenter,
+    :tickfontvalign              => :vcenter,
+    :tickfontrotation            => 0.0,
+    :tickfontcolor               => :match,
+    :guidefontfamily             => :match,
+    :guidefontsize               => 11,
+    :guidefonthalign             => :hcenter,
+    :guidefontvalign             => :vcenter,
+    :guidefontrotation           => 0.0,
+    :guidefontcolor              => :match,
+    :foreground_color_axis       => :match,            # axis border/tick colors,
+    :foreground_color_border     => :match,            # plot area border/spines,
+    :foreground_color_text       => :match,            # tick text color,
+    :foreground_color_guide      => :match,            # guide text color,
+    :discrete_values             => [],
+    :formatter                   => :auto,
+    :mirror                      => false,
+    :grid                        => true,
+    :foreground_color_grid       => :match,            # grid color
+    :gridalpha                   => 0.1,
+    :gridstyle                   => :solid,
+    :gridlinewidth               => 0.5,
     :foreground_color_minor_grid => :match,            # grid color
-    :minorgridalpha           => 0.05,
-    :minorgridstyle           => :solid,
-    :minorgridlinewidth       => 0.5,
-    :tick_direction           => :in,
-    :minorticks               => false,
-    :minorgrid                => false,
-    :showaxis                 => true,
-    :widen                    => true,
-    :draw_arrow               => false,
+    :minorgridalpha              => 0.05,
+    :minorgridstyle              => :solid,
+    :minorgridlinewidth          => 0.5,
+    :tick_direction              => :in,
+    :minorticks                  => false,
+    :minorgrid                   => false,
+    :showaxis                    => true,
+    :widen                       => true,
+    :draw_arrow                  => false,
 )
 
 const _suppress_warnings = Set{Symbol}([
@@ -508,6 +525,7 @@ const _initial_axis_defaults = deepcopy(_axis_defaults)
 const _initial_fontsizes = Dict(:titlefontsize  => _subplot_defaults[:titlefontsize],
                                 :legendfontsize => _subplot_defaults[:legendfontsize],
                                 :legendtitlefontsize => _subplot_defaults[:legendtitlefontsize],
+                                :annotationfontsize => _subplot_defaults[:annotationfontsize],
                                 :tickfontsize   => _axis_defaults[:tickfontsize],
                                 :guidefontsize  => _axis_defaults[:guidefontsize])
 
@@ -1329,10 +1347,10 @@ const _match_map = KW(
     :background_color_inside  => :background_color_subplot,
     :foreground_color_legend  => :foreground_color_subplot,
     :foreground_color_title   => :foreground_color_subplot,
-    :left_margin   => :margin,
-    :top_margin    => :margin,
-    :right_margin  => :margin,
-    :bottom_margin => :margin,
+    :left_margin              => :margin,
+    :top_margin               => :margin,
+    :right_margin             => :margin,
+    :bottom_margin            => :margin,
     :titlefontfamily          => :fontfamily_subplot,
     :titlefontcolor           => :foreground_color_subplot,
     :legendfontfamily         => :fontfamily_subplot,
@@ -1342,10 +1360,14 @@ const _match_map = KW(
     :colorbar_fontfamily      => :fontfamily_subplot,
     :colorbar_titlefontfamily => :fontfamily_subplot,
     :colorbar_titlefontcolor  => :foreground_color_subplot,
+    :colorbar_tickfontfamily  => :fontfamily_subplot,
+    :colorbar_tickfontcolor   => :foreground_color_subplot,
     :plot_titlefontfamily     => :fontfamily,
     :plot_titlefontcolor      => :foreground_color,
     :tickfontcolor            => :foreground_color_text,
     :guidefontcolor           => :foreground_color_guide,
+    :annotationfontfamily     => :fontfamily_subplot,
+    :annotationcolor          => :foreground_color_subplot,
 )
 
 # these can match values from the parent container (axis --> subplot --> plot)
@@ -1580,6 +1602,7 @@ function _update_subplot_args(plt::Plot, sp::Subplot, plotattributes_in, subplot
             lims_warned = true
         end
     end
+    _update_subplot_colorbars(sp)
 end
 
 # -----------------------------------------------------------------------------

src/axes.jl

@@ -137,11 +137,10 @@ const _label_func_tex = Dict{Symbol,Function}(
 labelfunc_tex(scale::Symbol) = get(_label_func_tex, scale, convert_sci_unicode)
 
 
-function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
-    amin, amax = axis_limits(sp, axis[:letter])
+function optimal_ticks_and_labels(ticks, alims, scale, formatter)
+    amin, amax = alims
 
     # scale the limits
-    scale = axis[:scale]
     sf = RecipesPipeline.scale_func(scale)
 
     # If the axis input was a Date or DateTime use a special logic to find
@@ -152,7 +151,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
     # rather than on the input format
     # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
     if ticks === nothing && scale == :identity
-        if axis[:formatter] == RecipesPipeline.dateformatter
+        if formatter == RecipesPipeline.dateformatter
             # optimize_datetime_ticks returns ticks and labels(!) based on
             # integers/floats corresponding to the DateTime type. Thus, the axes
             # limits, which resulted from converting the Date type to integers,
@@ -163,7 +162,7 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
                 k_min = 2, k_max = 4)
             # Now the ticks are converted back to floats corresponding to Dates.
             return ticks / 864e5, labels
-        elseif axis[:formatter] == RecipesPipeline.datetimeformatter
+        elseif formatter == RecipesPipeline.datetimeformatter
             return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
         end
     end
@@ -187,14 +186,13 @@ function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
             # chosen  ticks is not too much bigger than amin - amax:
             strict_span = false,
         )
-        axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
+        # axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
     else
         scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks)))
     end
     unscaled_ticks = map(RecipesPipeline.inverse_scale_func(scale), scaled_ticks)
 
     labels = if any(isfinite, unscaled_ticks)
-        formatter = axis[:formatter]
         if formatter in (:auto, :plain, :scientific, :engineering)
             map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, formatter))
         elseif formatter == :latex
@@ -221,52 +219,113 @@ end
 # return (continuous_values, discrete_values) for the ticks on this axis
 function get_ticks(sp::Subplot, axis::Axis; update = true)
     if update || !haskey(axis.plotattributes, :optimized_ticks)
+        dvals = axis[:discrete_values]
         ticks = _transform_ticks(axis[:ticks])
-        if ticks in (:none, nothing, false)
-            axis.plotattributes[:optimized_ticks] = nothing
+        axis.plotattributes[:optimized_ticks] = if ticks isa Symbol && ticks !== :none &&
+            ispolar(sp) && axis[:letter] === :x && !isempty(dvals)
+            collect(0:pi/4:7pi/4), string.(0:45:315)
         else
-            # treat :native ticks as :auto
-            ticks = ticks == :native ? :auto : ticks
-
-            dvals = axis[:discrete_values]
-            cv, dv = if typeof(ticks) <: Symbol
-                if !isempty(dvals)
-                    # discrete ticks...
-                    n = length(dvals)
-                    rng = if ticks == :auto && n > 15
-                        Δ = ceil(Int, n / 10)
-                        Δ:Δ:n
-                    else # if ticks == :all
-                        1:n
-                    end
-                    axis[:continuous_values][rng], dvals[rng]
-                elseif ispolar(axis.sps[1]) && axis[:letter] == :x
-                    #force theta axis to be full circle
-                    (collect(0:pi/4:7pi/4), string.(0:45:315))
-                else
-                    # compute optimal ticks and labels
-                    optimal_ticks_and_labels(sp, axis)
-                end
-            elseif typeof(ticks) <: Union{AVec, Int}
-                if !isempty(dvals) && typeof(ticks) <: Int
-                    rng = Int[round(Int,i) for i in range(1, stop=length(dvals), length=ticks)]
-                    axis[:continuous_values][rng], dvals[rng]
-                else
-                    # override ticks, but get the labels
-                    optimal_ticks_and_labels(sp, axis, ticks)
-                end
-            elseif typeof(ticks) <: NTuple{2, Any}
-                # assuming we're passed (ticks, labels)
-                ticks
-            else
-                error("Unknown ticks type in get_ticks: $(typeof(ticks))")
-            end
-            axis.plotattributes[:optimized_ticks] = (cv, dv)
+            cvals = axis[:continuous_values]
+            alims = axis_limits(sp, axis[:letter])
+            scale = axis[:scale]
+            formatter = axis[:formatter]
+            get_ticks(ticks, cvals, dvals, alims, scale, formatter)
         end
     end
-    axis.plotattributes[:optimized_ticks]
+    return axis.plotattributes[:optimized_ticks]
 end
 
+# Ticks getter functions
+for l in (:x, :y, :z)
+    axis = string(l, "-axis")  # "x-axis"
+    ticks = string(l, "ticks") # "xticks"
+    f = Symbol(ticks)          # :xticks
+    @eval begin
+        """
+            $($f)(p::Plot)
+
+        returns a vector of the $($axis) ticks of the subplots of `p`.
+
+        Example use:
+
+        ```jldoctest
+        julia> p = plot(1:5, $($ticks)=[1,2])
+
+        julia> $($f)(p)
+        1-element Vector{Tuple{Vector{Float64}, Vector{String}}}:
+         ([1.0, 2.0], ["1", "2"])
+        ```
+
+        If `p` consists of a single subplot, you might want to grab
+        only the first element, via
+
+        ```jldoctest
+        julia> $($f)(p)[1]
+        ([1.0, 2.0], ["1", "2"])
+        ```
+
+        or you can call $($f) on the first (only) subplot of `p` via
+
+        ```jldoctest
+        julia> $($f)(p[1])
+        ([1.0, 2.0], ["1", "2"])
+        ```
+        """
+        $f(p::Plot) = get_ticks(p, $(Meta.quot(l)))
+        """
+            $($f)(sp::Subplot)
+
+        returns the $($axis) ticks of the subplot `sp`.
+
+        Note that the ticks are returned as tuples of values and labels:
+
+        ```jldoctest
+        julia> sp = plot(1:5, $($ticks)=[1,2]).subplots[1]
+        Subplot{1}
+
+        julia> $($f)(sp)
+        ([1.0, 2.0], ["1", "2"])
+        ```
+        """
+        $f(sp::Subplot) = get_ticks(sp, $(Meta.quot(l)))
+        export $f
+    end
+end
+# get_ticks from axis symbol :x, :y, or :z
+get_ticks(sp::Subplot, s::Symbol) = get_ticks(sp, sp[Symbol(s, :axis)])
+get_ticks(p::Plot, s::Symbol) = [get_ticks(sp, s) for sp in p.subplots]
+
+function get_ticks(ticks::Symbol, cvals::T, dvals, args...) where T
+    if ticks === :none
+        return T[], String[]
+    elseif !isempty(dvals)
+        n = length(dvals)
+        if ticks === :all || n < 16
+            return cvals, string.(dvals)
+        else
+            Δ = ceil(Int, n / 10)
+            rng = Δ:Δ:n
+            return cvals[rng], string.(dvals[rng])
+        end
+    else
+        return optimal_ticks_and_labels(nothing, args...)
+    end
+end
+get_ticks(ticks::AVec, cvals, dvals, args...) = optimal_ticks_and_labels(ticks, args...)
+function get_ticks(ticks::Int, dvals, cvals, args...)
+    if !isempty(dvals)
+        rng = round.(Int, range(1, stop=length(dvals), length=ticks))
+        cvals[rng], string.(dvals[rng])
+    else
+        optimal_ticks_and_labels(ticks, args...)
+    end
+end
+get_ticks(ticks::NTuple{2, Any}, args...) = ticks
+get_ticks(::Nothing, cvals::T, args...) where T = T[], String[]
+get_ticks(ticks::Bool, args...) =
+    ticks ? get_ticks(:auto, args...) : get_ticks(nothing, args...)
+get_ticks(::T, args...) where T = error("Unknown ticks type in get_ticks: $T")
+
 _transform_ticks(ticks) = ticks
 _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.value.(ticks)
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])
@@ -442,7 +501,7 @@ function widen(lmin, lmax, scale = :identity)
 end
 
 # figure out if widening is a good idea.
-const _widen_seriestypes = (:line, :path, :steppre, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
+const _widen_seriestypes = (:line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
 
 function default_should_widen(axis::Axis)
     should_widen = false
@@ -638,17 +697,19 @@ function axis_drawing_info(sp, letter)
         if !(ax[:ticks] in (:none, nothing, false))
             f = RecipesPipeline.scale_func(oax[:scale])
             invf = RecipesPipeline.inverse_scale_func(oax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
-                (oa1, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
+                    (oa1, t)
+                end
             end
 
             for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                     push!(
                         tick_segments,
                         reverse_if((tick, tick_start), isy),
@@ -757,7 +818,7 @@ function axis_drawing_info_3d(sp, letter)
                 # don't show the 0 tick label for the origin framestyle
                 if sp[:framestyle] == :origin && !(ticks in (:none, nothing, false)) && length(ticks) > 1
                     i0 = findfirst(==(0), ticks[1])
-                    if ind !== nothing
+                    if i0 !== nothing
                         deleteat!(ticks[1], i0)
                         deleteat!(ticks[2], i0)
                     end
@@ -775,18 +836,20 @@ function axis_drawing_info_3d(sp, letter)
         if !(ax[:ticks] in (:none, nothing, false))
             f = RecipesPipeline.scale_func(nax[:scale])
             invf = RecipesPipeline.inverse_scale_func(nax[:scale])
-            tick_start, tick_stop = if sp[:framestyle] == :origin
-                t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
-                (-t, t)
-            else
-                ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
-                (na0, t)
+            if ax[:tick_direction] !== :none
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
+                    (-t, t)
+                else
+                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                    t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
+                    (na0, t)
+                end
             end
 
             ga0, ga1 = sp[:framestyle] in (:origin, :zerolines) ? (namin, namax) : (na0, na1)
             for tick in ticks[1]
-                if ax[:showaxis]
+                if ax[:showaxis] && ax[:tick_direction] !== :none
                     push!(
                         tick_segments,
                         sort_3d_axes(tick, tick_start, fa0, letter),
@@ -816,7 +879,7 @@ function axis_drawing_info_3d(sp, letter)
                     (na0, t)
                 end
                 for tick in minor_ticks
-                    if ax[:showaxis]
+                    if ax[:showaxis] && ax[:tick_direction] !== :none
                         push!(
                             tick_segments,
                             sort_3d_axes(tick, tick_start, fa0, letter),

src/backends.jl

@@ -531,6 +531,10 @@ const _pyplot_attr = merge_with_base_supported([
     :guidefontfamily, :guidefontsize, :guidefontcolor,
     :grid, :gridalpha, :gridstyle, :gridlinewidth,
     :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
+    :colorbar_ticks, :colorbar_tickfontfamily, :colorbar_tickfontsize,
+    :colorbar_tickfonthalign, :colorbar_tickfontvalign,
+    :colorbar_tickfontrotation, :colorbar_tickfontcolor,
+    :colorbar_scale,
     :marker_z, :line_z, :fill_z,
     :levels,
     :ribbon, :quiver, :arrow,
@@ -551,6 +555,7 @@ const _pyplot_attr = merge_with_base_supported([
 const _pyplot_seriestype = [
     :path,
     :steppre,
+    :stepmid,
     :steppost,
     :shape,
     :straightline,
@@ -632,6 +637,7 @@ const _hdf5_attr = merge_with_base_supported([
 const _hdf5_seriestype = [
     :path,
     :steppre,
+    :stepmid,
     :steppost,
     :shape,
     :straightline,
@@ -703,7 +709,7 @@ const _inspectdr_attr = merge_with_base_supported([
   ])
 const _inspectdr_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _inspectdr_seriestype = [
-        :path, :scatter, :shape, :straightline, #, :steppre, :steppost
+        :path, :scatter, :shape, :straightline, #, :steppre, :stepmid, :steppost
     ]
 #see: _allMarkers, _shape_keys
 const _inspectdr_marker = Symbol[

src/backends/gr.jl

@@ -571,6 +571,26 @@ end
 gr_view_xcenter(viewport_plotarea) = 0.5 * (viewport_plotarea[1] + viewport_plotarea[2])
 gr_view_ycenter(viewport_plotarea) = 0.5 * (viewport_plotarea[3] + viewport_plotarea[4])
 
+gr_view_xposition(viewport_plotarea, position) = viewport_plotarea[1] + position * (viewport_plotarea[2] - viewport_plotarea[1])
+gr_view_yposition(viewport_plotarea, position) = viewport_plotarea[3] + position * (viewport_plotarea[4] - viewport_plotarea[3])
+
+function position(symb)
+    if symb == :top || symb == :right
+        return 0.95
+    elseif symb == :left || symb == :bottom
+        return 0.05
+    end
+    return 0.5
+end
+
+function alignment(symb)
+    if symb == :top || symb == :right
+        return GR.TEXT_HALIGN_RIGHT
+    elseif symb == :left || symb == :bottom
+        return GR.TEXT_HALIGN_LEFT
+    end
+    return GR.TEXT_HALIGN_CENTER
+end
 
 # --------------------------------------------------------------------------------------
 
@@ -743,7 +763,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
         xticks, yticks, zticks = get_ticks(sp, xaxis), get_ticks(sp, yaxis), get_ticks(sp, zaxis)
         # Add margin for x and y ticks
         h = 0mm
-        if !(xticks in (nothing, false, :none))
+        if !isempty(first(xticks))
             gr_set_font(
                 tickfont(xaxis),
                 halign = (:left, :hcenter, :right)[sign(xaxis[:rotation]) + 2],
@@ -754,7 +774,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
             l = 0.01 + last(gr_get_ticks_size(xticks, xaxis[:rotation]))
             h = max(h, 1mm + get_size(sp)[2] * l * px)
         end
-        if !(yticks in (nothing, false, :none))
+        if !isempty(first(yticks))
             gr_set_font(
                 tickfont(yaxis),
                 halign = (:left, :hcenter, :right)[sign(yaxis[:rotation]) + 2],
@@ -774,7 +794,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
             end
         end
 
-        if !(zticks in (nothing, false, :none))
+        if !isempty(first(zticks))
             gr_set_font(
                 tickfont(zaxis),
                 halign = (zaxis[:mirror] ? :left : :right),
@@ -825,7 +845,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
     else
         # Add margin for x and y ticks
         xticks, yticks = get_ticks(sp, sp[:xaxis]), get_ticks(sp, sp[:yaxis])
-        if !(xticks in (nothing, false, :none))
+        if !isempty(first(xticks))
             gr_set_tickfont(sp, :x)
             l = 0.01 + last(gr_get_ticks_size(xticks, sp[:xaxis][:rotation]))
             h = 1mm + get_size(sp)[2] * l * px
@@ -835,7 +855,7 @@ function _update_min_padding!(sp::Subplot{GRBackend})
                 bottompad += h
             end
         end
-        if !(yticks in (nothing, false, :none))
+        if !isempty(first(yticks))
             gr_set_tickfont(sp, :y)
             l = 0.01 + first(gr_get_ticks_size(yticks, sp[:yaxis][:rotation]))
             w = 1mm + get_size(sp)[1] * l * px
@@ -1484,31 +1504,35 @@ end
 
 function gr_label_axis(sp, letter, viewport_plotarea)
     axis = sp[Symbol(letter, :axis)]
+    mirror = axis[:mirror]
     # guide
     if axis[:guide] != ""
         GR.savestate()
         gr_set_font(guidefont(axis), sp)
         guide_position = axis[:guide_position]
         if letter === :y
-            w = 0.03 + gr_axis_width(sp, axis)
             GR.setcharup(-1, 0)
-            if guide_position == :right || (guide_position == :auto && axis[:mirror])
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-                gr_text(viewport_plotarea[2] + w, gr_view_ycenter(viewport_plotarea), axis[:guide])
+            ypos = gr_view_yposition(viewport_plotarea, position(axis[:guidefontvalign]))
+            yalign = alignment(axis[:guidefontvalign])
+            if guide_position === :right || (guide_position == :auto && mirror)
+                GR.settextalign(yalign, GR.TEXT_VALIGN_BOTTOM)
+                xpos = viewport_plotarea[2] + 0.03 + mirror * gr_axis_width(sp, axis)
             else
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-                gr_text(viewport_plotarea[1] - w, gr_view_ycenter(viewport_plotarea), axis[:guide])
+                GR.settextalign(yalign, GR.TEXT_VALIGN_TOP)
+                xpos = viewport_plotarea[1] - 0.03 - !mirror * gr_axis_width(sp, axis)
             end
         else
-            h = 0.015 + gr_axis_height(sp, axis)
-            if guide_position == :top || (guide_position == :auto && axis[:mirror])
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_TOP)
-                gr_text(gr_view_xcenter(viewport_plotarea), viewport_plotarea[4] + h, axis[:guide])
+            xpos = gr_view_xposition(viewport_plotarea, position(axis[:guidefonthalign]))
+            xalign = alignment(axis[:guidefonthalign])
+            if guide_position === :top || (guide_position == :auto && mirror)
+                GR.settextalign(xalign, GR.TEXT_VALIGN_TOP)
+                ypos = viewport_plotarea[4] + 0.015 + (mirror ? gr_axis_height(sp, axis) : 0.015)
             else
-                GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_BOTTOM)
-                gr_text(gr_view_xcenter(viewport_plotarea), viewport_plotarea[3] - h, axis[:guide])
+                GR.settextalign(xalign, GR.TEXT_VALIGN_BOTTOM)
+                ypos = viewport_plotarea[3] - 0.015 - (mirror ? 0.015 : gr_axis_height(sp, axis))
             end
         end
+        gr_text(xpos, ypos, axis[:guide])
         GR.restorestate()
     end
 end

src/backends/inspectdr.jl

@@ -17,9 +17,6 @@ Add in functionality to Plots.jl:
 
 is_marker_supported(::InspectDRBackend, shape::Shape) = true
 
-_inspectdr_to_pixels(bb::BoundingBox) =
-    InspectDR.BoundingBox(to_pixels(left(bb)), to_pixels(right(bb)), to_pixels(top(bb)), to_pixels(bottom(bb)))
-
 #Do we avoid Map to avoid possible pre-comile issues?
 function _inspectdr_mapglyph(s::Symbol)
     s == :rect && return :square
@@ -290,7 +287,7 @@ For st in :shape:
                 color = linecolor, fillcolor = fillcolor
             )
         end
-   elseif st in (:path, :scatter, :straightline) #, :steppre, :steppost)
+   elseif st in (:path, :scatter, :straightline) #, :steppre, :stepmid, :steppost)
         #NOTE: In Plots.jl, :scatter plots have 0-linewidths (I think).
         linewidth = series[:linewidth]
         #More efficient & allows some support for markerstrokewidth:
@@ -366,37 +363,37 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
         a.title = sp[:title]
         a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
 
-    l = plot.layout
-        #IMPORTANT: Don't forget to actually register changes
-        #(TODO: need to find a better way to set layout properties)
-        l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
-            l[:frame_canvas] = l[:frame_canvas] #register changes
-        l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
-            l[:frame_data] = l[:frame_data] #register changes
-
-        l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
-            l[:frame_data] = l[:frame_data] #register changes
-        l[:font_title] = InspectDR.Font(sp[:titlefontfamily],
+    #Modify base layout of new object:
+    l = plot.layout.defaults = deepcopy(InspectDR.defaults.plotlayout)
+        #IMPORTANT: Must deepcopy to ensure we don't change layouts of other plots.
+        #Works because plot uses defaults (not user-overwritten `layout.values`)
+        l.frame_canvas.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+        l.frame_data.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+        l.frame_data.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+        l.font_title = InspectDR.Font(sp[:titlefontfamily],
             _inspectdr_mapptsize(sp[:titlefontsize]),
             color = _inspectdr_mapcolor(sp[:titlefontcolor])
         )
         #Cannot independently control fonts of axes with InspectDR:
-        l[:font_axislabel] = InspectDR.Font(xaxis[:guidefontfamily],
+        l.font_axislabel = InspectDR.Font(xaxis[:guidefontfamily],
             _inspectdr_mapptsize(xaxis[:guidefontsize]),
             color = _inspectdr_mapcolor(xaxis[:guidefontcolor])
         )
-        l[:font_ticklabel] = InspectDR.Font(xaxis[:tickfontfamily],
+        l.font_ticklabel = InspectDR.Font(xaxis[:tickfontfamily],
             _inspectdr_mapptsize(xaxis[:tickfontsize]),
             color = _inspectdr_mapcolor(xaxis[:tickfontcolor])
         )
-        l[:enable_legend] = (sp[:legend] != :none)
-        #l[:halloc_legend] = 150 #TODO: compute???
-        l[:font_legend] = InspectDR.Font(sp[:legendfontfamily],
+        l.enable_legend = (sp[:legend] != :none)
+        #l.halloc_legend = 150 #TODO: compute???
+        l.font_legend = InspectDR.Font(sp[:legendfontfamily],
             _inspectdr_mapptsize(sp[:legendfontsize]),
             color = _inspectdr_mapcolor(sp[:legendfontcolor])
         )
-        l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
-            l[:frame_legend] = l[:frame_legend] #register changes
+        l.frame_legend.fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+
+        #_round!() ensures values use integer spacings (looks better on screen):
+        InspectDR._round!(InspectDR.autofit2font!(l, legend_width=10.0)) #10 "em"s wide
+    return
 end
 
 # called just before updating layout bounding boxes... in case you need to prep
@@ -476,11 +473,16 @@ end
 function _update_plot_object(plt::Plot{InspectDRBackend})
     mplot = _inspectdr_getmplot(plt.o)
     if nothing == mplot; return; end
+    mplot.bblist = InspectDR.BoundingBox[]
 
     for (i, sp) in enumerate(plt.subplots)
-        graphbb = _inspectdr_to_pixels(plotarea(sp))
-        plot = mplot.subplots[i]
-        plot.plotbb = InspectDR.plotbounds(plot.layout.values, graphbb)
+        figw, figh = sp.plt[:size]
+        pcts = bbox_to_pcts(sp.bbox, figw*px, figh*px)
+        _left, _bottom, _width, _height = pcts
+        ymax = 1.0-_bottom
+        ymin = ymax - _height
+        bb = InspectDR.BoundingBox(_left, _left+_width, ymin, ymax)
+        push!(mplot.bblist, bb)
     end
 
     gplot = _inspectdr_getgui(plt.o)

src/backends/pgfplotsx.jl

@@ -82,6 +82,7 @@ function surface_to_vecs(x::AVec, y::AVec, s::Union{AMat,Surface})
     end
     return xn, yn, zn
 end
+surface_to_vecs(x::AVec, y::AVec, z::AVec) = x, y, z
 
 function Base.push!(pgfx_plot::PGFPlotsXPlot, item)
     push!(pgfx_plot.the_plot, item)
@@ -131,9 +132,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             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]))
             title_cstr = plot_color(sp[:titlefontcolor])
             title_a = alpha(title_cstr)
             title_loc = sp[:titlelocation]
@@ -142,7 +140,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             axis_opt = PGFPlotsX.Options(
                 "point meta max" => get_clims(sp)[2],
                 "point meta min" => get_clims(sp)[1],
-                "legend cell align" => "left",
                 "title" => sp[:title],
                 "title style" => PGFPlotsX.Options(
                         pgfx_get_title_pos(title_loc)...,
@@ -154,22 +151,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     "draw opacity" => title_a,
                     "rotate" => sp[:titlefontrotation],
                 ),
-                "legend style" => PGFPlotsX.Options(
-                    pgfx_linestyle(
-                        pgfx_thickness_scaling(sp),
-                        sp[:foreground_color_legend],
-                        fg_alpha,
-                        "solid",
-                    ) => nothing,
-                    "fill" => cstr,
-                    "fill opacity" => a,
-                    "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
-                    "font" => pgfx_font(
-                        sp[:legendfontsize],
-                        pgfx_thickness_scaling(sp),
-                    ),
-                    "text" => plot_color(sp[:legendfontcolor]),
-                ),
+                "legend style" => pgfx_get_legend_style(sp),
                 "axis background/.style" => PGFPlotsX.Options(
                     "fill" => bgc_inside,
                     "opacity" => bgc_inside_a,
@@ -183,8 +165,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             nothing
             sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) :
             nothing
-            # legend position
-            push!(axis_opt["legend style"], pgfx_get_legend_pos(sp[:legend])...)
             for letter in (:x, :y, :z)
                 if letter != :z || RecipesPipeline.is3d(sp)
                     pgfx_axis!(axis_opt, sp, letter)
@@ -225,16 +205,22 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
             @label colorbar_end
 
             if hascolorbar(sp)
+                cticks = get_colorbar_ticks(sp)[2]
                 colorbar_style = PGFPlotsX.Options(
                     "title" => sp[:colorbar_title],
-                    "xticklabel style" => pgfx_get_ticklabel_style(sp, sp[:xaxis]),
-                    "yticklabel style" => pgfx_get_ticklabel_style(sp, sp[:yaxis]),
                 )
                 if sp[:colorbar] === :top
                     push!(colorbar_style,
                         "at" => string((0.5, 1.05)),
                         "anchor" => "south",
+                        "xtick" => string("{", join(cticks, ","), "}"),
                         "xticklabel pos" => "upper",
+                        "xticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
+                    )
+                else
+                    push!(colorbar_style,
+                        "ytick" => string("{", join(cticks, ","), "}"),
+                        "yticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
                     )
                 end
                 push!(
@@ -242,6 +228,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                     string("colorbar", pgfx_get_colorbar_pos(sp[:colorbar])) => nothing,
                     "colorbar style" => colorbar_style,
                 )
+            else
+                push!(axis_opt, "colorbar" => "false") 
             end
             if RecipesPipeline.is3d(sp)
                 azim, elev = sp[:camera]
@@ -341,7 +329,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
     # treat segments
     segments = collect(series_segments(series, series[:seriestype]))
     sf = opt[:fillrange]
-    for segment in segments
+    for (k, segment) in enumerate(segments)
         i, rng = segment.attr_index, segment.range
         segment_opt = PGFPlotsX.Options()
         segment_opt = merge(segment_opt, pgfx_linestyle(opt, i))
@@ -397,7 +385,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                 )
                 end
             end
-            if i == 1 &&
+            if k == 1 &&
                series[:subplot][:legend] != :none && pgfx_should_add_to_legend(series)
                 pgfx_filllegend!(series_opt, opt)
             end
@@ -492,13 +480,14 @@ function pgfx_add_series!(::Val{:scatter3d}, axis, series_opt, series, series_fu
 end
 
 function pgfx_add_series!(::Val{:surface}, axis, series_opt, series, series_func, opt)
+    alpha = get_fillalpha(series)
     push!(
         series_opt,
         "surf" => nothing,
-        "mesh/rows" => length(opt[:x]),
-        "mesh/cols" => length(opt[:y]),
+        "mesh/rows" => length(unique(opt[:x])), # unique if its all vectors
+        "mesh/cols" => length(unique(opt[:y])),
         "z buffer" => "sort",
-        "opacity" => get_fillalpha(series),
+        "opacity" => alpha === nothing ? 1.0 : alpha,
     )
     pgfx_add_series!(axis, series_opt, series, series_func, opt)
 end
@@ -791,6 +780,31 @@ function pgfx_get_legend_pos(v::Tuple{S,Symbol}) where S <: Real
     return ("at"=>"$(string(legend_pos_from_angle(v[1],rect...)))", "anchor"=>anchor)
 end
 
+function pgfx_get_legend_style(sp)
+    cstr = plot_color(sp[:background_color_legend])
+    a = alpha(cstr)
+    fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
+    legfont = legendfont(sp)
+    PGFPlotsX.Options(
+        pgfx_linestyle(
+            pgfx_thickness_scaling(sp),
+            sp[:foreground_color_legend],
+            fg_alpha,
+            "solid",
+        ) => nothing,
+        "fill" => cstr,
+        "fill opacity" => a,
+        "text opacity" => alpha(plot_color(sp[:legendfontcolor])),
+        "font" => pgfx_font(
+            sp[:legendfontsize],
+            pgfx_thickness_scaling(sp),
+        ),
+        "text" => plot_color(sp[:legendfontcolor]),
+        "cells" => PGFPlotsX.Options("anchor" => get((left = "west", right = "east", hcenter = "center"), legfont.halign, "west")),
+        pgfx_get_legend_pos(sp[:legend])...,
+    )
+end
+
 pgfx_get_colorbar_pos(s) =
     get((left = " left", bottom = " horizontal", top = " horizontal"), s, "")
 pgfx_get_colorbar_pos(b::Bool) = ""
@@ -809,15 +823,23 @@ function pgfx_get_ticklabel_style(sp, axis)
     return PGFPlotsX.Options(
         "font" => pgfx_font(
             axis[:tickfontsize], pgfx_thickness_scaling(sp)
-        ),
-        "color" => cstr,
+        ), "color" => cstr,
         "draw opacity" => alpha(cstr),
         "rotate" => axis[:tickfontrotation],
     )
 end
 
+function pgfx_get_colorbar_ticklabel_style(sp)
+    cstr = plot_color(sp[:colorbar_tickfontcolor])
+    return PGFPlotsX.Options(
+        "font" => pgfx_font(
+            sp[:colorbar_tickfontsize], pgfx_thickness_scaling(sp)
+        ), "color" => cstr,
+        "draw opacity" => alpha(cstr),
+        "rotate" => sp[:colorbar_tickfontrotation],
+    )
+end
 ## --------------------------------------------------------------------------------------
-# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_arrow(::Nothing) = "every arrow/.append style={-}"
 function pgfx_arrow(arr::Arrow, side = arr.side)
     components = String[]
@@ -848,6 +870,7 @@ function pgfx_filllegend!(series_opt, opt)
               }""")
 end
 
+# Generates a colormap for pgfplots based on a ColorGradient
 pgfx_colormap(cl::PlotUtils.AbstractColorList) = pgfx_colormap(color_list(cl))
 function pgfx_colormap(v::Vector{<:Colorant})
     join(map(v) do c
@@ -1261,11 +1284,18 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
         else
             push!(opt, string(letter, "ticklabels") => "{}")
         end
-        push!(
-            opt,
-            string(letter, "tick align") =>
-                (axis[:tick_direction] == :out ? "outside" : "inside"),
-        )
+        if axis[:tick_direction] === :none
+            push!(
+                opt,
+                string(letter, "tick style") => "draw=none",
+            )
+        else
+            push!(
+                opt,
+                string(letter, "tick align") =>
+                    (axis[:tick_direction] == :out ? "outside" : "inside"),
+            )
+        end
         push!(
             opt, string(letter, "ticklabel style") => pgfx_get_ticklabel_style(sp, axis)
         )

src/backends/plotly.jl

@@ -7,7 +7,7 @@ function _plotly_framestyle(style::Symbol)
         return style
     else
         default_style = get((semi = :box, origin = :zerolines), style, :axes)
-        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was cosen instead.")
+        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was chosen instead.")
         default_style
     end
 end
@@ -143,7 +143,8 @@ function plotly_axis(axis, sp, anchor = nothing, domain = nothing)
         :zerolinecolor => rgba_string(axis[:foreground_color_axis]),
         :showline   => framestyle in (:box, :axes) && axis[:showaxis],
         :linecolor  => rgba_string(plot_color(axis[:foreground_color_axis])),
-        :ticks      => axis[:tick_direction] == :out ? "outside" : "inside",
+        :ticks      => axis[:tick_direction] === :out ? "outside" : 
+                       axis[:tick_direction] === :in ? "inside" : "",
         :mirror     => framestyle == :box,
         :showticklabels => axis[:showaxis],
     )
@@ -662,7 +663,7 @@ function plotly_series(plt::Plot, series::Series)
 end
 
 function plotly_series_shapes(plt::Plot, series::Series, clims)
-    segments = collect(series_segments(series))
+    segments = series_segments(series)
     plotattributes_outs = Vector{KW}(undef, length(segments))
 
     # TODO: create a plotattributes_out for each polygon
@@ -681,7 +682,7 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
         for (letter, data) in zip((:x, :y), shape_data(series, 100))
     )
 
-    for segment in segments
+    for (k, segment) in enumerate(segments)
         i, rng = segment.attr_index, segment.range
         length(rng) < 2 && continue
 
@@ -701,10 +702,10 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
                 :dash => string(get_linestyle(series, i)),
             )
         end
-        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
+        plotattributes_out[:showlegend] = k==1 ? should_add_to_legend(series) : false
         plotly_polar!(plotattributes_out, series)
         plotly_hover!(plotattributes_out, _cycle(series[:hover], i))
-        plotattributes_outs[i] = plotattributes_out
+        plotattributes_outs[k] = plotattributes_out
     end
     if series[:fill_z] !== nothing
         push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
@@ -789,6 +790,8 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
                 :width => get_linewidth(series, i),
                 :shape => if st == :steppre
                     "vh"
+                elseif st == :stepmid
+                    "hvh"
                 elseif st == :steppost
                     "hv"
                 else

src/backends/plotlyjs.jl

@@ -39,8 +39,7 @@ _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standal
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
 function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
-    plt_html = sprint(show, MIME("text/html"), plt)
-    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
+    return PlotlyJS.WebIO.render(plotlyjs_syncplot(plt))
 end
 
 function closeall(::PlotlyJSBackend)

src/backends/pyplot.jl

@@ -152,12 +152,14 @@ end
 
 function py_stepstyle(seriestype::Symbol)
     seriestype == :steppost && return "steps-post"
+    seriestype == :stepmid && return "steps-mid"
     seriestype == :steppre && return "steps-pre"
     return "default"
 end
 
 function py_fillstepstyle(seriestype::Symbol)
     seriestype == :steppost && return "post"
+    seriestype == :stepmid && return "mid"
     seriestype == :steppre && return "pre"
     return nothing
 end
@@ -206,13 +208,13 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
 end
 
 function py_linecolormap(series::Series)
-    py_colormap(cgrad(get_linecolor(series), alpha=get_linealpha(series)))
+    py_colormap(cgrad(series[:linecolor], alpha=get_linealpha(series)))
 end
 function py_markercolormap(series::Series)
-    py_colormap(cgrad(get_markercolor(series), alpha=get_markeralpha(series)))
+    py_colormap(cgrad(series[:markercolor], alpha=get_markeralpha(series)))
 end
 function py_fillcolormap(series::Series)
-    py_colormap(cgrad(get_fillcolor(series), alpha=get_fillalpha(series)))
+    py_colormap(cgrad(series[:fillcolor], alpha=get_fillalpha(series)))
 end
 
 # ---------------------------------------------------------------------------
@@ -408,7 +410,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     # for each plotting command, optionally build and add a series handle to the list
 
     # line plot
-    if st in (:path, :path3d, :steppre, :steppost, :straightline)
+    if st in (:path, :path3d, :steppre, :stepmid, :steppost, :straightline)
         if maximum(series[:linewidth]) > 0
             # TODO: check LineCollection alternative for speed
             # if length(segments) > 1 && (any(typeof(series[attr]) <: AbstractVector for attr in (:fillcolor, :fillalpha)) || series[:fill_z] !== nothing) && !(typeof(series[:linestyle]) <: AbstractVector)
@@ -485,7 +487,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
 
     # add markers?
     if series[:markershape] != :none && st in (
-        :path, :scatter, :path3d, :scatter3d, :steppre, :steppost, :bar
+        :path, :scatter, :path3d, :scatter3d, :steppre, :stepmid, :steppost, :bar
     )
         for segment in series_segments(series, :scatter)
             i, rng = segment.attr_index, segment.range
@@ -757,7 +759,7 @@ function py_surround_latextext(latexstring, env)
 end
 
 
-function py_set_ticks(ax, ticks, letter, env)
+function py_set_ticks(sp, ax, ticks, letter, env)
     ticks == :auto && return
     axis = getproperty(ax, Symbol(letter,"axis"))
     if ticks == :none || ticks === nothing || ticks == false
@@ -775,7 +777,7 @@ function py_set_ticks(ax, ticks, letter, env)
     elseif ttype == :ticks_and_labels
         axis."set_ticks"(ticks[1])
 
-        if pyrcparams["text.usetex"]
+        if get(sp[:extra_kwargs], :rawticklabels, false)
             tick_labels = ticks[2]
         else
             tick_labels = [py_surround_latextext(ticklabel, env) for ticklabel in ticks[2]]
@@ -807,36 +809,52 @@ function py_compute_axis_minval(sp::Subplot, axis::Axis)
     minval
 end
 
-function py_set_scale(ax, sp::Subplot, axis::Axis)
-    scale = axis[:scale]
-    letter = axis[:letter]
+function py_set_scale(ax, sp::Subplot, scale::Symbol, letter::Symbol)
     scale in supported_scales() || return @warn("Unhandled scale value in pyplot: $scale")
     func = getproperty(ax, Symbol("set_", letter, "scale"))
     if PyPlot.version ≥ v"3.3" # https://matplotlib.org/3.3.0/api/api_changes.html
-        letter = Symbol("")
+        pyletter = Symbol("")
+    else
+        pyletter = letter
     end
     kw = KW()
     arg = if scale == :identity
         "linear"
     else
-        kw[Symbol(:base,letter)] = if scale == :ln
+        kw[Symbol(:base, pyletter)] = if scale == :ln
             ℯ
         elseif scale == :log2
             2
         elseif scale == :log10
             10
         end
-        kw[Symbol(:linthresh,letter)] = NaNMath.max(1e-16, py_compute_axis_minval(sp, axis))
+        axis = sp[Symbol(letter, :axis)]
+        kw[Symbol(:linthresh, pyletter)] = NaNMath.max(1e-16, py_compute_axis_minval(sp, axis))
         "symlog"
     end
     func(arg; kw...)
 end
 
+function py_set_scale(ax, sp::Subplot, axis::Axis)
+    scale = axis[:scale]
+    letter = axis[:letter]
+    py_set_scale(ax, sp, scale, letter)
+end
+
+function py_set_spine_color(spines, color)
+    for loc in spines
+        spines[loc]."set_color"(color)
+    end
+end
+
+function py_set_spine_color(spines::Dict, color)
+    for (loc, spine) in spines
+        spine."set_color"(color)
+    end
+end
 
 function py_set_axis_colors(sp, ax, a::Axis)
-    for (loc, spine) in ax.spines
-        spine."set_color"(py_color(a[:foreground_color_border]))
-    end
+    py_set_spine_color(ax.spines, py_color(a[:foreground_color_border]))
     axissym = Symbol(a[:letter], :axis)
     if PyPlot.PyCall.hasproperty(ax, axissym)
         tickcolor = sp[:framestyle] in (:zerolines, :grid) ? py_color(plot_color(a[:foreground_color_grid], a[:gridalpha])) : py_color(a[:foreground_color_axis])
@@ -972,24 +990,31 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
 
             end
 
-            cb."set_label"(sp[:colorbar_title],size=py_thickness_scale(plt, sp[:yaxis][:guidefontsize]),family=sp[:yaxis][:guidefontfamily], color = py_color(sp[:yaxis][:guidefontcolor]))
+            cb."set_label"(sp[:colorbar_title],size=py_thickness_scale(plt, sp[:colorbar_titlefontsize]),family=sp[:colorbar_titlefontfamily], color = py_color(sp[:colorbar_titlefontcolor]))
 
             # cb."formatter".set_useOffset(false)   # This for some reason does not work, must be a pyplot bug, instead this is a workaround:
             cb."formatter".set_powerlimits((-Inf, Inf))
             cb."update_ticks"()
 
+            env = "\\mathregular"  # matches the outer fonts https://matplotlib.org/tutorials/text/mathtext.html
+            ticks = get_colorbar_ticks(sp)
+
             if sp[:colorbar] in (:top, :bottom)
                 axis = sp[:xaxis]  # colorbar inherits from x axis
                 cbar_axis = cb."ax"."xaxis"
+                ticks_letter=:x
             else
                 axis = sp[:yaxis]  # colorbar inherits from y axis
                 cbar_axis = cb."ax"."yaxis"
+                ticks_letter=:y
             end
+            py_set_scale(cb.ax, sp, sp[:colorbar_scale], ticks_letter)
+            sp[:colorbar_ticks] == :native ? nothing : py_set_ticks(sp, cb.ax, ticks, ticks_letter, env)
 
             for lab in cbar_axis."get_ticklabels"()
-                  lab."set_fontsize"(py_thickness_scale(plt, axis[:tickfontsize]))
-                  lab."set_family"(axis[:tickfontfamily])
-                  lab."set_color"(py_color(axis[:tickfontcolor]))
+                  lab."set_fontsize"(py_thickness_scale(plt, sp[:colorbar_tickfontsize]))
+                  lab."set_family"(sp[:colorbar_tickfontfamily])
+                  lab."set_color"(py_color(sp[:colorbar_tickfontcolor]))
             end
 
             # Adjust thickness of the cbar ticks
@@ -997,7 +1022,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             cbar_axis."set_tick_params"(
                 direction = axis[:tick_direction] == :out ? "out" : "in",
                 width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
             )
 
 
@@ -1038,8 +1063,14 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                     ax.spines["left"]."set_position"("zero")
                 end
             elseif sp[:framestyle] in (:grid, :none, :zerolines)
-                for (loc, spine) in ax.spines
-                    spine."set_visible"(false)
+                if PyPlot.version >= v"3.4.1" # that is one where it worked, the API change may have some other value
+                    for spine in ax.spines
+                        ax.spines[string(spine)]."set_visible"(false)
+                    end
+                else
+                    for (loc, spine) in ax.spines
+                        spine."set_visible"(false)
+                    end
                 end
                 if sp[:framestyle] == :zerolines
                     ax."axhline"(y = 0, color = py_color(sp[:xaxis][:foreground_color_axis]), lw = py_thickness_scale(plt, 0.75))
@@ -1106,13 +1137,13 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
             # workaround to set mathtext.fontspec per Text element
             env = "\\mathregular"  # matches the outer fonts https://matplotlib.org/tutorials/text/mathtext.html
 
-            axis[:ticks] == :native ? nothing : py_set_ticks(ax, ticks, letter, env)
+            axis[:ticks] == :native ? nothing : py_set_ticks(sp, ax, ticks, letter, env)
             # Tick marks
             intensity = 0.5  # This value corresponds to scaling of other grid elements
             pyaxis."set_tick_params"(
                 direction = axis[:tick_direction] == :out ? "out" : "in",
                 width=py_thickness_scale(plt, intensity),
-                length= 5 * py_thickness_scale(plt, intensity)
+                length = axis[:tick_direction] == :none ? 0 : 5 * py_thickness_scale(plt, intensity)
                                      )
 
             getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
@@ -1151,7 +1182,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 pyaxis."set_tick_params"(
                     which = "minor",
                     direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity),
+                )
             end
 
             if axis[:minorgrid]
@@ -1161,7 +1193,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 pyaxis."set_tick_params"(
                     which = "minor",
                     direction = axis[:tick_direction] == :out ? "out" : "in",
-                    width=py_thickness_scale(plt, intensity))
+                    length = axis[:tick_direction] == :none ? 0 : py_thickness_scale(plt, intensity)
+                )
 
                 pyaxis."grid"(true,
                     which = "minor",
@@ -1350,7 +1383,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                             linestyle = py_linestyle(series[:seriestype], get_linestyle(series)),
                             capstyle = "butt"
                         )
-                    elseif series[:seriestype] in (:path, :straightline, :scatter, :steppre, :steppost)
+                    elseif series[:seriestype] in (:path, :straightline, :scatter, :steppre, :stepmid, :steppost)
                         hasline = get_linewidth(series) > 0
                         PyPlot.plt."Line2D"((0, 1),(0,0),
                             color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),

src/colorbars.jl

@@ -0,0 +1,90 @@
+# These functions return an operator for use in `get_clims(::Seres, op)`
+process_clims(lims::Tuple{<:Number,<:Number}) = (zlims -> ifelse.(isfinite.(lims), lims, zlims)) ∘ ignorenan_extrema
+process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
+# don't specialize on ::Function otherwise python functions won't work
+process_clims(f) = f
+
+function get_clims(sp::Subplot, op=process_clims(sp[:clims]))
+    zmin, zmax = Inf, -Inf
+    for series in series_list(sp)
+        if series[:colorbar_entry]
+            zmin, zmax = _update_clims(zmin, zmax, get_clims(series, op)...)
+        end
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+function get_clims(sp::Subplot, series::Series, op=process_clims(sp[:clims]))
+    zmin, zmax = if series[:colorbar_entry]
+        get_clims(sp, op)
+    else
+        get_clims(series, op)
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+"""
+    get_clims(::Series, op=Plots.ignorenan_extrema)
+
+Finds the limits for the colorbar by taking the "z-values" for the series and passing them into `op`,
+which must return the tuple `(zmin, zmax)`. The default op is the extrema of the finite
+values of the input.
+"""
+function get_clims(series::Series, op=ignorenan_extrema)
+    zmin, zmax = Inf, -Inf
+    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
+    for vals in (series[:seriestype] in z_colored_series ? series[:z] : nothing, series[:line_z], series[:marker_z], series[:fill_z])
+        if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Union{Missing, Real})
+            zmin, zmax = _update_clims(zmin, zmax, op(vals.surf)...)
+        elseif (vals !== nothing) && (eltype(vals) <: Union{Missing, Real})
+            zmin, zmax = _update_clims(zmin, zmax, op(vals)...)
+        end
+    end
+    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
+end
+
+_update_clims(zmin, zmax, emin, emax) = NaNMath.min(zmin, emin), NaNMath.max(zmax, emax)
+
+@enum ColorbarStyle cbar_gradient cbar_fill cbar_lines
+
+function colorbar_style(series::Series)
+    colorbar_entry = series[:colorbar_entry]
+    if !(colorbar_entry isa Bool)
+        @warn "Non-boolean colorbar_entry ignored."
+        colorbar_entry = true
+    end
+
+    if !colorbar_entry
+        nothing
+    elseif isfilledcontour(series)
+        cbar_fill
+    elseif iscontour(series)
+        cbar_lines
+    elseif series[:seriestype] ∈ (:heatmap,:surface) ||
+            any(series[z] !== nothing for z ∈ [:marker_z,:line_z,:fill_z])
+        cbar_gradient
+    else
+        nothing
+    end
+end
+
+hascolorbar(series::Series) = colorbar_style(series) !== nothing
+hascolorbar(sp::Subplot) = sp[:colorbar] != :none && any(hascolorbar(s) for s in series_list(sp))
+
+function get_colorbar_ticks(sp::Subplot; update = true)
+    if update || !haskey(sp.attr, :colorbar_optimized_ticks)
+        ticks = _transform_ticks(sp[:colorbar_ticks])
+        cvals = sp[:colorbar_continuous_values]
+        dvals = sp[:colorbar_discrete_values]
+        clims = get_clims(sp)
+        scale = sp[:colorbar_scale]
+        formatter = sp[:colorbar_formatter]
+        sp.attr[:colorbar_optimized_ticks] =
+            get_ticks(ticks, cvals, dvals, clims, scale, formatter)
+    end
+    return sp.attr[:colorbar_optimized_ticks]
+end
+
+function _update_subplot_colorbars(sp::Subplot)
+    # Dynamic callback from the pipeline if needed
+end

src/components.jl

@@ -9,9 +9,9 @@ compute_angle(v::P2) = (angle = atan(v[2], v[1]); angle < 0 ? 2π - angle : angl
 
 # -------------------------------------------------------------
 
-struct Shape
-    x::Vector{Float64}
-    y::Vector{Float64}
+struct Shape{X<:Number, Y<:Number}
+    x::Vector{X}
+    y::Vector{Y}
     # function Shape(x::AVec, y::AVec)
     #     # if x[1] != x[end] || y[1] != y[end]
     #     #     new(vcat(x, x[1]), vcat(y, y[1]))
@@ -52,7 +52,7 @@ end
 
 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-    Tuple{Float64,Float64}[(r*cos(u),r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
+    [(r*cos(u), r*sin(u)) for u in range(start_θ, stop=end_θ, length=n)]
 end
 
 "interleave 2 vectors into each other (like a zipper's teeth)"
@@ -205,9 +205,12 @@ function rotate!(shape::Shape, Θ::Real, c = center(shape))
 end
 
 "rotate an object in space"
-function rotate(shape::Shape, Θ::Real, c = center(shape))
-    shapecopy = deepcopy(shape)
-    rotate!(shapecopy, Θ, c)
+function rotate(shape::Shape, θ::Real, c = center(shape))
+    x, y = coords(shape)
+    cx, cy = c
+    x_new = rotate_x.(x, y, θ, cx, cy)
+    y_new = rotate_y.(x, y, θ, cx, cy)
+    Shape(x_new, y_new)
 end
 
 # -----------------------------------------------------------------------
@@ -572,11 +575,21 @@ annotations(sa::SeriesAnnotations) = sa
 
 # Expand arrays of coordinates, positions and labels into induvidual annotations
 # and make sure labels are of type PlotText
-function process_annotation(sp::Subplot, xs, ys, labs, font = font())
+function process_annotation(sp::Subplot, xs, ys, labs, font = nothing)
     anns = []
     labs = makevec(labs)
     xlength = length(methods(length, (typeof(xs),))) == 0 ? 1 : length(xs)
     ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys)
+    if isnothing(font)
+        font = Plots.font(;
+                    family=sp[:annotationfontfamily],
+                    pointsize=sp[:annotationfontsize],
+                    halign=sp[:annotationhalign],
+                    valign=sp[:annotationvalign],
+                    rotation=sp[:annotationrotation],
+                    color=sp[:annotationcolor],
+                         )
+    end
     for i in 1:max(xlength, ylength, length(labs))
       x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
         x = typeof(x) <: TimeType ? Dates.value(x) : x
@@ -585,14 +598,24 @@ function process_annotation(sp::Subplot, xs, ys, labs, font = font())
             alphabet = "abcdefghijklmnopqrstuvwxyz"
             push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
         else
-            push!(anns, (x, y, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab...) : text(lab, font)))
+            push!(anns, (x, y, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font)))
         end
     end
     anns
 end
-function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol}, labs, font = font())
+function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol}, labs, font = nothing)
     anns = []
     positions, labs = makevec(positions), makevec(labs)
+    if isnothing(font)
+        font = Plots.font(;
+                          family=sp[:annotationfontfamily],
+                          pointsize=sp[:annotationfontsize],
+                          halign=sp[:annotationhalign],
+                          valign=sp[:annotationvalign],
+                          rotation=sp[:annotationrotation],
+                          color=sp[:annotationcolor],
+                         )
+    end
     for i in 1:max(length(positions), length(labs))
         pos, lab = _cycle(positions, i), _cycle(labs, i)
         pos = get(_positionAliases, pos, pos)
@@ -600,7 +623,7 @@ function process_annotation(sp::Subplot, positions::Union{AVec{Symbol},Symbol},
             alphabet = "abcdefghijklmnopqrstuvwxyz"
             push!(anns, (pos, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
         else
-            push!(anns, (pos, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab...) : text(lab, font)))
+            push!(anns, (pos, isa(lab, PlotText) ? lab : isa(lab, Tuple) ? text(lab[1], font, lab[2:end]...) : text(lab, font)))
         end
     end
     anns

src/examples.jl

@@ -7,7 +7,7 @@ mutable struct PlotExample
     exprs::Vector{Expr}
 end
 
-# the _examples we'll run for each
+# the _examples we'll run for each backend
 const _examples = PlotExample[
     PlotExample( # 1
         "Lines",
@@ -241,14 +241,15 @@ const _examples = PlotExample[
                         m -> m in Plots.supported_markers(),
                         Plots._shape_keys,
                     )
-                    markers = reshape(markers, 1, length(markers))
+                    markers = permutedims(markers)
                     n = length(markers)
                     x = range(0, stop = 10, length = n + 2)[2:(end - 1)]
                     y = repeat(reshape(reverse(x), 1, :), n, 1)
                     scatter(
                         x,
                         y,
-                        m = (8, :auto),
+                        m = markers,
+                        markersize = 8,
                         lab = map(string, markers),
                         bg = :linen,
                         xlim = (0, 10),
@@ -1119,6 +1120,49 @@ const _examples = PlotExample[
             quiver(x,y,z, quiver=(u,v,w))
         end]
     ),
+    PlotExample( # 53
+        "Step Types",
+        "A comparison of the various step-like `seriestype`s",
+        [
+            :(
+              begin
+                  x = 1:5
+                  y = [1, 2, 3, 2, 1]
+                  default(shape=:circle)
+                  plot(
+                       plot(x, y, markershape=:circle, seriestype=:steppre, label="steppre"),
+                       plot(x, y, markershape=:circle, seriestype=:stepmid, label="stepmid"),
+                       plot(x, y, markershape=:circle, seriestype=:steppost, label="steppost"),
+                       layout=(3,1)
+                      )
+              end
+            ),
+        ],
+    ),
+    PlotExample( # 54
+        "Guide positions and alignment",
+        "",
+        [
+            :(
+              begin
+                plot(
+                    rand(10, 4),
+                    layout=4,
+                    xguide="x guide",
+                    yguide="y guide",
+                    xguidefonthalign=[:left :right :right :left],
+                    yguidefontvalign=[:top :bottom :bottom :top],
+                    xguideposition=:top,
+                    yguideposition=[:right :left :right :left],
+                    ymirror=[false true true false],
+                    xmirror=[false false true true],
+                    legend=false,
+                    seriestype=[:bar :scatter :path :stepmid]
+                )
+              end
+            ),
+        ],
+    ),
 ]
 
 # Some constants for PlotDocs and PlotReferenceImages
@@ -1127,7 +1171,7 @@ _backend_skips = Dict(
     :gr => [25, 30, 47],
     :pyplot => [2, 25, 30, 31, 47, 49],
     :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51],
-    :plotly => [2, 21, 24, 25, 30, 31, 49, 51],
+    :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51],
     :pgfplotsx => [
         2, # animation
         6, # images

src/recipes.jl

@@ -165,49 +165,81 @@ end
     x := x
     y := y
     seriestype := :scatter
+    @series begin
+        ()
+    end
     @series begin
         seriestype := :path
         label := ""
         primary := false
         ()
     end
+    primary := false
     ()
 end
 @deps scatterpath path scatter
 
+
+# ---------------------------------------------------------------------------
+# regression line and scatter
+
+# plots line corresponding to linear regression of y on a constant and x
+@recipe function f(::Type{Val{:linearfit}}, x, y, z)
+    x := x
+    y := y
+    seriestype := :scatter
+    @series begin
+        ()
+    end
+    @series begin
+        y := mean(y) .+ cov(x, y) / var(x) .* (x .- mean(x))
+        seriestype := :path
+        label := ""
+        primary := false
+        ()
+    end
+    primary := false
+    ()
+end
+
+
 @specialize
 
 
 # ---------------------------------------------------------------------------
 # steps
 
-make_steps(x, st) = x
-function make_steps(x::AbstractArray, st)
+make_steps(x, st, even) = x
+function make_steps(x::AbstractArray, st, even)
     n = length(x)
     n == 0 && return zeros(0)
-    newx = zeros(2n - 1)
-    for i = 1:n
+    newx = zeros(2n - (even ? 0 : 1))
+    newx[1] = x[1]
+    for i = 2:n
         idx = 2i - 1
-        newx[idx] = x[i]
-        if i > 1
+        if st == :mid
+            newx[idx] = newx[idx-1] = (x[i] + x[i-1]) / 2
+        else
+            newx[idx] = x[i]
             newx[idx - 1] = x[st == :pre ? i : i - 1]
         end
     end
+    even && (newx[end] = x[end])
     return newx
 end
-make_steps(t::Tuple, st) = Tuple(make_steps(ti, st) for ti in t)
+make_steps(t::Tuple, st, even) = Tuple(make_steps(ti, st, even) for ti in t)
 
 
 @nospecialize
 
 # create a path from steps
 @recipe function f(::Type{Val{:steppre}}, x, y, z)
-    plotattributes[:x] = make_steps(x, :post)
-    plotattributes[:y] = make_steps(y, :pre)
+    plotattributes[:x] = make_steps(x, :post, false)
+    plotattributes[:y] = make_steps(y, :pre, false)
     seriestype := :path
 
     # handle fillrange
-    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :pre)
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :pre, false)
 
     # create a secondary series for the markers
     if plotattributes[:markershape] != :none
@@ -226,13 +258,38 @@ end
 @deps steppre path scatter
 
 # create a path from steps
-@recipe function f(::Type{Val{:steppost}}, x, y, z)
-    plotattributes[:x] = make_steps(x, :pre)
-    plotattributes[:y] = make_steps(y, :post)
+@recipe function f(::Type{Val{:stepmid}}, x, y, z)
+    plotattributes[:x] = make_steps(x, :mid, true)
+    plotattributes[:y] = make_steps(y, :post, true)
     seriestype := :path
 
     # handle fillrange
-    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post)
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post, true)
+
+    # create a secondary series for the markers
+    if plotattributes[:markershape] != :none
+        @series begin
+            seriestype := :scatter
+            x := x
+            y := y
+            label := ""
+            primary := false
+            ()
+        end
+        markershape := :none
+    end
+    ()
+end
+@deps stepmid path scatter
+
+# create a path from steps
+@recipe function f(::Type{Val{:steppost}}, x, y, z)
+    plotattributes[:x] = make_steps(x, :pre, false)
+    plotattributes[:y] = make_steps(y, :post, false)
+    seriestype := :path
+
+    # handle fillrange
+    plotattributes[:fillrange] = make_steps(plotattributes[:fillrange], :post, false)
 
     # create a secondary series for the markers
     if plotattributes[:markershape] != :none
@@ -398,7 +455,7 @@ end
     bw = plotattributes[:bar_width]
     hw = if bw === nothing
         if nx > 1
-            0.5 * _bar_width * ignorenan_minimum(filter(x -> x > 0, diff(procx)))
+            0.5 * _bar_width * ignorenan_minimum(filter(x -> x > 0, diff(sort(procx))))
         else
             0.5 * _bar_width
         end

src/utils.jl

@@ -82,7 +82,7 @@ function series_segments(series::Series, seriestype::Symbol = :path)
     args = RecipesPipeline.is3d(series) ? (x, y, z) : (x, y)
     nan_segments = collect(iter_segments(args...))
 
-    result = if has_attribute_segments(series)
+    segments = if has_attribute_segments(series)
         Iterators.flatten(map(nan_segments) do r
             if seriestype in (:scatter, :scatter3d)
                 (SeriesSegment(i:i, i) for i in r)
@@ -94,8 +94,14 @@ function series_segments(series::Series, seriestype::Symbol = :path)
         (SeriesSegment(r, 1) for r in nan_segments)
     end 
 
-    seg_range = UnitRange(minimum(first(seg.range) for seg in result),
-                                maximum(last(seg.range) for seg in result))
+    warn_on_attr_dim_mismatch(series, x, y, z, segments)
+    return segments
+end
+
+function warn_on_attr_dim_mismatch(series, x, y, z, segments)
+    isempty(segments) && return
+    seg_range = UnitRange(minimum(first(seg.range) for seg in segments),
+                          maximum(last(seg.range) for seg in segments))
     for attr in _segmenting_vector_attributes
         v = get(series, attr, nothing)
         if v isa AVec && eachindex(v) != seg_range
@@ -111,8 +117,6 @@ function series_segments(series::Series, seriestype::Symbol = :path)
             end
         end
     end
-
-    return result
 end
 
 # helpers to figure out if there are NaN values in a list of array types
@@ -428,79 +432,6 @@ xlims(sp_idx::Int = 1) = xlims(current(), sp_idx)
 ylims(sp_idx::Int = 1) = ylims(current(), sp_idx)
 zlims(sp_idx::Int = 1) = zlims(current(), sp_idx)
 
-# These functions return an operator for use in `get_clims(::Seres, op)`
-process_clims(lims::Tuple{<:Number,<:Number}) = (zlims -> ifelse.(isfinite.(lims), lims, zlims)) ∘ ignorenan_extrema
-process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
-# don't specialize on ::Function otherwise python functions won't work
-process_clims(f) = f
-
-function get_clims(sp::Subplot, op=process_clims(sp[:clims]))
-    zmin, zmax = Inf, -Inf
-    for series in series_list(sp)
-        if series[:colorbar_entry]
-            zmin, zmax = _update_clims(zmin, zmax, get_clims(series, op)...)
-        end
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-function get_clims(sp::Subplot, series::Series, op=process_clims(sp[:clims]))
-    zmin, zmax = if series[:colorbar_entry]
-        get_clims(sp, op)
-    else
-        get_clims(series, op)
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-"""
-    get_clims(::Series, op=Plots.ignorenan_extrema)
-
-Finds the limits for the colorbar by taking the "z-values" for the series and passing them into `op`,
-which must return the tuple `(zmin, zmax)`. The default op is the extrema of the finite
-values of the input.
-"""
-function get_clims(series::Series, op=ignorenan_extrema)
-    zmin, zmax = Inf, -Inf
-    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
-    for vals in (series[:seriestype] in z_colored_series ? series[:z] : nothing, series[:line_z], series[:marker_z], series[:fill_z])
-        if (typeof(vals) <: AbstractSurface) && (eltype(vals.surf) <: Union{Missing, Real})
-            zmin, zmax = _update_clims(zmin, zmax, op(vals.surf)...)
-        elseif (vals !== nothing) && (eltype(vals) <: Union{Missing, Real})
-            zmin, zmax = _update_clims(zmin, zmax, op(vals)...)
-        end
-    end
-    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
-end
-
-_update_clims(zmin, zmax, emin, emax) = NaNMath.min(zmin, emin), NaNMath.max(zmax, emax)
-
-@enum ColorbarStyle cbar_gradient cbar_fill cbar_lines
-
-function colorbar_style(series::Series)
-    colorbar_entry = series[:colorbar_entry]
-    if !(colorbar_entry isa Bool)
-        @warn "Non-boolean colorbar_entry ignored."
-        colorbar_entry = true
-    end
-
-    if !colorbar_entry
-        nothing
-    elseif isfilledcontour(series)
-        cbar_fill
-    elseif iscontour(series)
-        cbar_lines
-    elseif series[:seriestype] ∈ (:heatmap,:surface) ||
-            any(series[z] !== nothing for z ∈ [:marker_z,:line_z,:fill_z])
-        cbar_gradient
-    else
-        nothing
-    end
-end
-
-hascolorbar(series::Series) = colorbar_style(series) !== nothing
-hascolorbar(sp::Subplot) = sp[:colorbar] != :none && any(hascolorbar(s) for s in series_list(sp))
-
 iscontour(series::Series) = series[:seriestype] in (:contour, :contour3d)
 isfilledcontour(series::Series) = iscontour(series) && series[:fillrange] !== nothing
 

test/runtests.jl

@@ -18,12 +18,12 @@ using RecipesBase
     @test Plots.plotly_local_file_path[] === nothing
     temp = Plots.use_local_dependencies[]
     withenv("PLOTS_HOST_DEPENDENCY_LOCAL" => true) do
-        Plots.__init__()
-        @test Plots.plotly_local_file_path[] isa String
-        @test isfile(Plots.plotly_local_file_path[])
-        @test Plots.use_local_dependencies[] = true
-        @test_nowarn Plots._init_ijulia_plotting()
-    end
+    Plots.__init__()
+    @test Plots.plotly_local_file_path[] isa String
+    @test isfile(Plots.plotly_local_file_path[])
+    @test Plots.use_local_dependencies[] = true
+    @test_nowarn Plots._init_ijulia_plotting()
+end
     Plots.plotly_local_file_path[] = nothing
     Plots.use_local_dependencies[] = temp
 end # testset
@@ -43,7 +43,7 @@ reference_dir(args...) = joinpath(homedir(), ".julia", "dev", "PlotReferenceImag
 function reference_file(backend, i, version)
     refdir = reference_dir("Plots", string(backend))
     fn = "ref$i.png"
-    versions = sort(VersionNumber.(readdir(refdir)), rev = true)
+    versions = sort(VersionNumber.(readdir(refdir)), rev=true)
 
     reffn = joinpath(refdir, string(version), fn)
     for v in versions
@@ -107,7 +107,7 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @static if haskey(ENV, "APPVEYOR")
             @info "Skipping GR image comparison tests on AppVeyor"
         else
-            image_comparison_facts(:gr, tol=IMG_TOL, skip = Plots._backend_skips[:gr])
+            image_comparison_facts(:gr, tol=IMG_TOL, skip=Plots._backend_skips[:gr])
         end
     end
 
@@ -139,6 +139,15 @@ const IMG_TOL = VERSION < v"1.4" && Sys.iswindows() ? 1e-1 : is_ci() ? 1e-2 : 1e
         @test isa(display(p), Nothing) == true
     end
 
+    @testset "PlotlyJS" begin
+        @test plotlyjs() == Plots.PlotlyJSBackend()
+        @test backend() == Plots.PlotlyJSBackend()
+
+        p = plot(rand(10))
+        @test isa(p, Plots.Plot) == true
+        @test_broken isa(display(p), Nothing) == true
+    end
+
 end
 
 @testset "Axes" begin
@@ -147,27 +156,42 @@ end
     @test typeof(axis) == Plots.Axis
     @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
     @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
-    @test Plots.ignorenan_extrema(axis) == (0.5,1.5)
+    @test Plots.ignorenan_extrema(axis) == (0.5, 1.5)
     @test axis[:discrete_map] == Dict{Any,Any}(:yo  => 2, "HI" => 1)
 
-    Plots.discrete_value!(axis, ["x$i" for i=1:5])
-    Plots.discrete_value!(axis, ["x$i" for i=0:2])
+    Plots.discrete_value!(axis, ["x$i" for i = 1:5])
+    Plots.discrete_value!(axis, ["x$i" for i = 0:2])
     @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
 end
 
 @testset "NoFail" begin
-    plots = [histogram([1, 0, 0, 0, 0, 0]),
-             plot([missing]),
-             plot([missing; 1:4]),
-             plot([fill(missing,10); 1:4]),
-             plot([1 1; 1 missing]),
-             plot(["a" "b"; missing "d"], [1 2; 3 4])]
-    for plt in plots
-        display(plt)
+    #ensure backend with tested display
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    @testset "Plot" begin
+        plots = [histogram([1, 0, 0, 0, 0, 0]),
+                 plot([missing]),
+                 plot([missing, missing]),
+                 plot(fill(missing, 10)),
+                 plot([missing; 1:4]),
+                 plot([fill(missing, 10); 1:4]),
+                 plot([1 1; 1 missing]),
+                 plot(["a" "b"; missing "d"], [1 2; 3 4])]
+        for plt in plots
+            display(plt)
+        end
+        @test_nowarn plot(x -> x^2, 0, 2)
+    end
+
+    @testset "Bar" begin
+       p = bar([3,2,1], [1,2,3]);
+       @test isa(p, Plots.Plot)
+       @test isa(display(p), Nothing) == true
     end
-    @test_nowarn plot(x->x^2,0,2)
 end
 
+
 @testset "EmptyAnim" begin
     anim = @animate for i in []
     end
@@ -178,7 +202,7 @@ end
 @testset "NaN-separated Segments" begin
     segments(args...) = collect(iter_segments(args...))
 
-    nan10 = fill(NaN,10)
+    nan10 = fill(NaN, 10)
     @test segments(11:20) == [1:10]
     @test segments([NaN]) == []
     @test segments(nan10) == []
@@ -190,10 +214,10 @@ end
 end
 
 @testset "Utils" begin
-    zipped = ([(1,2)], [("a","b")], [(1,"a"),(2,"b")],
-              [(1,2),(3,4)], [(1,2,3),(3,4,5)], [(1,2,3,4),(3,4,5,6)],
-              [(1,2.0),(missing,missing)], [(1,missing),(missing,"a")],
-              [(missing,missing)], [(missing,missing,missing),("a","b","c")])
+    zipped = ([(1, 2)], [("a", "b")], [(1, "a"),(2, "b")],
+              [(1, 2),(3, 4)], [(1, 2, 3),(3, 4, 5)], [(1, 2, 3, 4),(3, 4, 5, 6)],
+              [(1, 2.0),(missing, missing)], [(1, missing),(missing, "a")],
+              [(missing, missing)], [(missing, missing, missing),("a", "b", "c")])
     for z in zipped
         @test isequal(collect(zip(Plots.unzip(z)...)), z)
         @test isequal(collect(zip(Plots.unzip(GeometryBasics.Point.(z))...)), z)

test/test_axes.jl

@@ -21,3 +21,13 @@ end # testset
     @test Plots.get_ticks(p2[1], p2[1][:xaxis])[2] == string.('C':3:'Z')
     @test Plots.get_ticks(p3[1], p3[1][:xaxis])[2] == string.('A':'Z')
 end
+
+@testset "Ticks getter functions" begin
+    ticks1 = ([1,2,3], ("a","b","c"))
+    ticks2 = ([4,5], ("e","f"))
+    p1 = plot(1:5, 1:5, 1:5, xticks=ticks1, yticks=ticks1, zticks=ticks1)
+    p2 = plot(1:5, 1:5, 1:5, xticks=ticks2, yticks=ticks2, zticks=ticks2)
+    p = plot(p1, p2)
+    @test xticks(p) == yticks(p) == zticks(p) == [ticks1, ticks2]
+    @test xticks(p[1]) == yticks(p[1]) == zticks(p[1]) == ticks1
+end

test/test_components.jl

@@ -1,6 +1,11 @@
 using Plots, Test
 
 @testset "Shapes" begin
+    @testset "Type" begin
+        square = Shape([(0,0.0),(1,0.0),(1,1.0),(0,1.0)])
+        @test isa(square, Shape{Int64, Float64})
+    end
+
     @testset "Copy" begin
         square = Shape([(0,0),(1,0),(1,1),(0,1)])
         square2 = Shape(square)

test/test_recipes.jl

@@ -31,3 +31,19 @@ end # testset
     sticks = plot(tri, seriestype = :sticks)
     @test length(sticks) == 1
 end
+
+@testset "framestyle axes" begin
+    pl = plot(-1:1, -1:1, -1:1)
+    sp = pl.subplots[1]
+    defaultret = Plots.axis_drawing_info_3d(sp, :x)
+    for letter in [:x, :y, :z]
+        for fr in [:box :semi :origin :zerolines :grid :none]
+            prevha = UInt64(0)
+            push!(sp.attr, :framestyle => fr)
+            ret = Plots.axis_drawing_info_3d(sp, letter)
+            ha = hash(string(ret))
+            @test ha != prevha
+            prevha = ha
+        end
+    end
+end