remove math font from tick font dict

Update precompile_*.jl file [skip ci] (#4197 )
Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>
2022-05-14 02:05:58 -04:00 · 2022-05-06 08:51:03 +02:00 · 2022-05-05 15:15:56 +02:00 · 2022-05-05 11:40:46 +02:00 · 2022-05-04 21:37:19 +02:00 · 2022-05-04 16:58:23 +02:00
46 changed files with 1314 additions and 538 deletions
--- a/.github/workflows/SnoopCompile.yml
+++ b/.github/workflows/SnoopCompile.yml
@ -16,15 +16,17 @@ jobs:
    if: "!contains(github.event.head_commit.message, '[skip ci]')"
    env:
      GKS_ENCODING: "utf8"
-      GKSwstype: "100"
+      GKSwstype: "nul"
      PLOTS_TEST: "true"
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{matrix.os}}
+    continue-on-error: ${{ matrix.version == '~1.8.0-0' }}
    strategy:
      fail-fast: false
      matrix:
        version:   # NOTE: the versions below should match those in your botconfig
          - '1.6'       # ⎤
          - '1.7'       # |
+          - '~1.8.0-0'  # |
          # - 'nightly'   # ⎦ <<< keep these versions in sync with deps/SnoopCompile/snoop_bot_config.jl
          # ^^^^^^^^^ for 'nightly', see github.com/JuliaPlots/Plots.jl/issues/4079
        os:        # NOTE: should match the os setting of your botconfig
@ -36,10 +38,20 @@ jobs:
      - uses: actions/checkout@v2
      - uses: julia-actions/setup-julia@latest
        with:
-          version: ${{ matrix.version }}
+          version: ${{matrix.version}}
+          
+      - name: Set Swap Space
+        uses: pierotofy/set-swap-space@master
+        with:
+          swap-size-gb: 10  # required (not enough memory on github actions virtual machine)

      - name: Install dependencies
        run: |
+          cat /proc/cpuinfo
+          cat /proc/meminfo
+          cat /proc/swaps
+          free
+          df -h
          julia --project -e 'using Pkg; Pkg.instantiate()'
          julia -e 'using Pkg; Pkg.add(PackageSpec(name="CompileBot", version="1")); Pkg.develop(PackageSpec(; path=pwd())); using CompileBot; CompileBot.addtestdep()'

@ -88,7 +100,6 @@ jobs:
            no changelog
          branch: "Test_SnoopCompile_AutoPR_${{ github.ref }}"

-
  Skip:
    if: "contains(github.event.head_commit.message, '[skip ci]')"
    runs-on: ubuntu-latest
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -15,7 +15,7 @@ jobs:
    if: "!contains(github.event.head_commit.message, '[skip ci]')"
    env:
      GKS_ENCODING: "utf8"
-      GKSwstype: "100"
+      GKSwstype: "nul"

    name: Julia ${{ matrix.version }} - ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
@ -55,19 +55,16 @@ jobs:
            ${{ runner.os }}-test-
            ${{ runner.os }}-

-      ## maybe required if we ever want to run graphical tests for plotly
-      # OS Dependencies
-      # - name: Ubuntu OS dependencies
-      #   if: startsWith(matrix.os,'ubuntu')
-      #   run: |
-      #    ./test/install_wkhtmltoimage.sh
-
      # TESTCMD
      - name: Default TESTCMD
        run: echo "TESTCMD=julia" >> $GITHUB_ENV
      - name: Ubuntu TESTCMD
        if: startsWith(matrix.os,'ubuntu')
-        run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
+        run: |
+          echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
+          sudo apt-get -y update
+          sudo apt-get -y install gnuplot poppler-utils texlive-{latex-base,latex-extra,luatex}
+          sudo fc-cache -vr

      # Julia Dependencies
      - name: Install Julia dependencies
@ -82,7 +79,9 @@ jobs:

      # Codecov
      - uses: julia-actions/julia-processcoverage@v1
+        if: startsWith(matrix.os,'ubuntu')
      - uses: codecov/codecov-action@v2
+        if: startsWith(matrix.os,'ubuntu')
        with:
          file: lcov.info

--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@ -9,7 +9,7 @@ on:
 
 jobs:
  Build_docs:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
        with:
@ -21,41 +21,14 @@ jobs:
          cache-name: cache-artifacts
        with:
          path: ~/.julia/artifacts 
-          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          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 \
-            gnuplot
-          sudo fc-cache -vr
-            
-      - name: build documentation
+            ${{runner.os}}-test-${{env.cache-name}}-
+            ${{runner.os}}-test-
+            ${{runner.os}}-
+      - name: Build documentation
        env:
          PYTHON: ""
-          DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
-        run: |
-          echo $GITHUB_REF
-          export JULIA_DEBUG=Documenter
-          export PLOTDOCS_ANSICOLOR=true
-          export GKSwstype=nul  # Plots.jl/issues/3664
-          export UP_DEBUG_IO=$(mktemp)
-          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 'using Pkg; pkg"add Documenter#master"'
-          xvfb-run julia --color=yes --project=docs/ -e 'using Pkg; pkg"st -m"'
-          xvfb-run julia --color=yes --project=docs/ -e 'withenv("GITHUB_REPOSITORY" => "JuliaPlots/PlotDocs.jl") do; include("docs/make.jl"); end'
-          cat $UP_DEBUG_IO | sed 's,\x1B,ESC,g'
-          rm $UP_DEBUG_IO
+          DOCUMENTER_KEY: ${{secrets.DOCUMENTER_KEY}}
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+        run: bash docs/ci_build.sh
--- a/.github/workflows/format_check.yml
+++ b/.github/workflows/format_check.yml
@ -1,37 +1,54 @@
 name: format

 on:
+  pull_request:
  push:
    branches:
      - 'master'
-    tags: '*'
-  pull_request:

 jobs:
-  check:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        julia-version: ['1']
-        julia-arch: [x64]
-        os: [ubuntu-latest]
+  code-style:
+    runs-on: ubuntu-latest
    steps:
-      - uses: julia-actions/setup-julia@latest
-        with:
-          version: ${{ matrix.julia-version }}
-
      - uses: actions/checkout@v2
-      - name: Install JuliaFormatter and format
+      - uses: julia-actions/setup-julia@v1
+      - name: Install dependencies
        run: |
-          julia -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
-          julia -e 'using JuliaFormatter; format(["src", "test"], verbose=true)'
-      - name: Format check
+          using Pkg
+          Pkg.add([
+              PackageSpec("JuliaFormatter"),
+              PackageSpec(url = "https://github.com/tkf/JuliaProjectFormatter.jl.git"),
+          ])
+        shell: julia --color=yes {0}
+
+      - name: Format Julia files
        run: |
-          julia -e '
-          out = Cmd(`git diff --name-only`) |> read |> String
-          if out == ""
-              exit(0)
-          else
-              @error "These files have not been formatted:\n$out"
-              exit(1)
-          end'
+          using JuliaFormatter
+          format(["src", "test"])
+        shell: julia --color=yes --compile=min -O0 {0}
+      - name: suggester / JuliaFormatter
+        uses: reviewdog/action-suggester@v1
+        with:
+          tool_name: JuliaFormatter
+          fail_on_error: true
+
+      # reviewdog/action-suggester not using `cleanup` flag?
+      - name: Cleanup
+        if: success() || failure()
+        run: |
+          git checkout -- .
+          git clean --force
+        shell: bash
+
+      - name: Format Julia project files
+        if: success() || failure()
+        run: |
+          using JuliaProjectFormatter
+          format_projects()
+        shell: julia --color=yes --compile=min -O0 {0}
+      - name: suggester / JuliaProjectFormatter
+        if: success() || failure()
+        uses: reviewdog/action-suggester@v1
+        with:
+          tool_name: JuliaProjectFormatter
+          fail_on_error: true
--- a/.zenodo.json
+++ b/.zenodo.json
@ -3,7 +3,7 @@
    "license": "MIT",
    "creators": [
        {
-            "affiliation": "Elemental Cognition",
+            "affiliation": "Headlands Technologies",
            "name": "Tom Breloff"
        }
    ],
@ -142,6 +142,8 @@
        },
        {
            "name": "Anshul Singhvi",
+            "affiliation": "Columbia University",
+            "orcid": "0000-0001-6055-1291",
            "type": "Other"
        },
        {
@ -706,6 +708,14 @@
        {
            "name": "Tom Gillam",
            "type": "Other"
+        },
+        {
+            "name": "Steve Leung",
+            "type": "Other"
+        },
+        {
+            "name": "Xu Zhi-Yuan",
+            "type": "Other"
        }
    ],
    "upload_type": "software"
--- a/Project.toml
+++ b/Project.toml
@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.25.10"
+version = "1.29.0"

 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@ -17,6 +17,7 @@ Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Measures = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
 NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 PlotThemes = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
 PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043"
 Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
@ -44,9 +45,13 @@ GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
 Measures = "0.3"
-NaNMath = "0.3"
-PlotThemes = "2"
+NaNMath = "0.3, 1"
+PGFPlotsX = "1"
+PlotThemes = "2, 3"
 PlotUtils = "1"
+PlotlyBase = "0.7"
+PlotlyJS = "0.18"
+PyPlot = "2"
 RecipesBase = "1.2"
 RecipesPipeline = "0.5"
 Reexport = "0.2, 1.0"
@ -55,7 +60,7 @@ Scratch = "1"
 Showoff = "0.3.1, 1.0"
 StatsBase = "0.32 - 0.33"
 UnicodeFun = "0.4"
-UnicodePlots = "2.8"
+UnicodePlots = "2.10"
 Unzip = "0.1"
 julia = "1.6"

@ -63,14 +68,18 @@ julia = "1.6"
 Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+Gaston = "4b11ee91-296f-5714-9832-002c20994614"
 Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
 HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
 ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+InspectDR = "d0351b0e-4b05-5898-87b3-e2a8edfddd1d"
 LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
 OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
 PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
+PlotlyBase = "a03496cd-edff-5a9b-9e67-9cda94a718b5"
 PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a"
+PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee"
 RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
 StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
@ -81,4 +90,4 @@ UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"

 [targets]
-test = ["Colors", "Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]
+test = ["Colors", "Distributions", "FileIO", "Gaston", "Gtk", "ImageMagick", "Images", "InspectDR", "LibGit2", "OffsetArrays", "PGFPlotsX", "PlotlyJS", "PlotlyBase", "PyPlot", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "TestImages", "UnicodePlots", "VisualRegressionTests"]
--- a/deps/SnoopCompile/precompile/1.6/precompile_Plots.jl
+++ b/deps/SnoopCompile/precompile/1.6/precompile_Plots.jl
@ -66,27 +66,29 @@ end

 function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(areaplot)),Any,typeof(areaplot),Any,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{RGBA{Float64}, Bool, Float64, Symbol, Int64}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
@ -96,6 +98,9 @@ function _precompile_()
    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{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
@ -117,14 +122,20 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
    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}},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},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!),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
    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},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, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},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}})
@ -178,8 +189,10 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriescolor, :fillalpha), Tuple{Matrix{Symbol}, Matrix{Float64}}},typeof(plot),AreaPlot})
    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),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
@ -196,10 +209,12 @@ function _precompile_()
    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},UnitRange{Int64}})
    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})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
    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})
@ -226,12 +241,17 @@ function _precompile_()
    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
    Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    Base.precompile(Tuple{typeof(_bin_centers),Vector{Float64}})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
    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),UnitRange{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},UnitRange{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@ -241,8 +261,6 @@ function _precompile_()
    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_legend),Subplot{GRBackend},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{PlotlyBackend},Dict{Symbol, Any}})
    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(axis_limits),Subplot{GRBackend},Symbol,Bool,Bool})
@ -252,13 +270,17 @@ function _precompile_()
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(default),Symbol,Bool})
+    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(fakedata),Int64,Int64})
+    Base.precompile(Tuple{typeof(fakedata),MersenneTwister,Int64,Vararg{Int64, N} where N})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_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})
@ -272,11 +294,17 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},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,UnitRange{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Vector{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_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}})
@ -287,21 +315,20 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
+    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_text),Float64,Float64,String})
+    Base.precompile(Tuple{typeof(gr_text_size),String})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Int64},Symbol,Bool})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
    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})
@ -309,9 +336,12 @@ function _precompile_()
    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})
+    Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot, N} where N})
    Base.precompile(Tuple{typeof(plot),Any,Any})
    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
@ -330,9 +360,15 @@ function _precompile_()
    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(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Int64, Int64, Float64},Tuple{Int64, Int64, Float64}})
    Base.precompile(Tuple{typeof(resetfontsizes)})
    Base.precompile(Tuple{typeof(scalefontsizes),Float64})
    Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
+    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
    Base.precompile(Tuple{typeof(spy),Any})
    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@ -341,14 +377,26 @@ function _precompile_()
    Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#297#333")) && Base.precompile(Tuple{getfield(Plots, Symbol("#297#333"))})
-    isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#166#167")) && Base.precompile(Tuple{getfield(Plots, Symbol("#166#167")),Any})
+    isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
+    isdefined(Plots, Symbol("#295#331")) && Base.precompile(Tuple{getfield(Plots, Symbol("#295#331"))})
+    isdefined(Plots, Symbol("#316#352")) && Base.precompile(Tuple{getfield(Plots, Symbol("#316#352"))})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#100")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#100")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#101")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#101")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
    let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any, N} where N,))) catch missing end
    if !ismissing(fbody)
        precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any, N} where N,))
    end
+end
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(gr_set_font, (Font,Subplot{GRBackend},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,RGBA{Float64},Float64,typeof(gr_set_font),Font,Subplot{GRBackend},))
+    end
 end
    let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
    if !ismissing(fbody)
@ -359,6 +407,26 @@ end
    if !ismissing(fbody)
        precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any, N} where N,))
    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot!),Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot!),Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot!),Plot,Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,Vararg{Plot, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot!),Plot,Plot,Plot,Vararg{Plot, N} where N,))
+    end
 end
    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
    if !ismissing(fbody)
@ -369,6 +437,11 @@ end
    if !ismissing(fbody)
        precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, N} where N,))
    end
+end
+    let fbody = try __lookup_kwbody__(which(scatter, (Any,Vararg{Any, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(scatter),Any,Vararg{Any, N} where N,))
+    end
 end
    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
    if !ismissing(fbody)
--- a/deps/SnoopCompile/precompile/1.7/precompile_Plots.jl
+++ b/deps/SnoopCompile/precompile/1.7/precompile_Plots.jl
@ -74,7 +74,9 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(areaplot)),Any,typeof(areaplot),Any,Vararg{Any}})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:foreground_color_grid, :grid, :gridalpha, :gridstyle, :gridlinewidth), Tuple{RGBA{Float64}, Bool, Float64, Symbol, Int64}},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, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
@ -83,7 +85,6 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guidefonthalign, :guide_position, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@ -92,6 +93,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid,), Tuple{Bool}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
@ -131,6 +133,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
@ -143,7 +146,7 @@ function _precompile_()
    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},Vector{Float64},Vararg{Any}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},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}})
@ -202,6 +205,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64, Int64}, LinRange{Float64, Int64}}}},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{(:seriescolor, :fillalpha), Tuple{Matrix{Symbol}, Matrix{Float64}}},typeof(plot),AreaPlot})
    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),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{DateTime},UnitRange{Int64},Matrix{Float64}})
@ -218,6 +222,7 @@ function _precompile_()
    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},UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any}})
    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64}})
@ -246,6 +251,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{GRBackend},Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
@ -261,9 +267,12 @@ function _precompile_()
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
    Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),UnitRange{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(_cycle),Vector{Int64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Int64},UnitRange{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@ -274,8 +283,6 @@ function _precompile_()
    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_legend),Subplot{GRBackend},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{PlotlyBackend},Dict{Symbol, Any}})
    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(annotate!),AbstractVector{<:Tuple}})
@ -285,8 +292,8 @@ function _precompile_()
    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
-    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{Union{Missing, Float64}}})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}}})
    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}}})
@ -310,21 +317,24 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64},Int64,Int64})
    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Vector{Int64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Int64},Vector{Int64},Nothing,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
@ -336,12 +346,13 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
+    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_text),Float64,Float64,String})
+    Base.precompile(Tuple{typeof(gr_text_size),String})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
@ -350,7 +361,6 @@ function _precompile_()
    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64, Int64}})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@ -359,9 +369,12 @@ function _precompile_()
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(partialcircle),Float64,Float64,Int64})
    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
+    Base.precompile(Tuple{typeof(plot!),Any})
+    Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot}})
    Base.precompile(Tuple{typeof(plot),Any,Any})
    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
    Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
@ -371,6 +384,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Stroke})
    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Symbol})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
@ -396,53 +410,78 @@ function _precompile_()
    Base.precompile(Tuple{typeof(spy),Any})
    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any}})
+    Base.precompile(Tuple{typeof(text),String,Symbol})
    Base.precompile(Tuple{typeof(title!),AbstractString})
-    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
-    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,Vector{Float64},typeof(ignorenan_extrema)})
    Base.precompile(Tuple{typeof(vline!),Any})
    Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
    Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any}})
    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#172#173")) && Base.precompile(Tuple{getfield(Plots, Symbol("#172#173")),Any})
-    isdefined(Plots, Symbol("#174#175")) && Base.precompile(Tuple{getfield(Plots, Symbol("#174#175")),Any})
-    isdefined(Plots, Symbol("#303#339")) && Base.precompile(Tuple{getfield(Plots, Symbol("#303#339"))})
-    isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#104")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#104")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#105")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#105")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#168#169")) && Base.precompile(Tuple{getfield(Plots, Symbol("#168#169")),Any})
+    isdefined(Plots, Symbol("#170#171")) && Base.precompile(Tuple{getfield(Plots, Symbol("#170#171")),Any})
+    isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
+    isdefined(Plots, Symbol("#301#337")) && Base.precompile(Tuple{getfield(Plots, Symbol("#301#337"))})
+    isdefined(Plots, Symbol("#322#358")) && Base.precompile(Tuple{getfield(Plots, Symbol("#322#358"))})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
    let fbody = try __lookup_kwbody__(which(annotate!, (AbstractVector{<:Tuple},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(annotate!),AbstractVector{<:Tuple},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Any,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,Vararg{Any},))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(title!),AbstractString,))
-        end
-    end
-    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any},))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(yaxis!),Any,Vararg{Any},))
-        end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(annotate!),AbstractVector{<:Tuple},))
    end
+end
+    let fbody = try __lookup_kwbody__(which(font, (Font,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(gr_set_font, (Font,Subplot{GRBackend},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Symbol,Symbol,RGBA{Float64},Float64,typeof(gr_set_font),Font,Subplot{GRBackend},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Any,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,Plot,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Plot,Plot,Plot,Vararg{Plot},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot!),Plot,Plot,Plot,Vararg{Plot},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(plot),Any,Vararg{Any},))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(title!, (AbstractString,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(title!),AbstractString,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any},))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Base.Pairs{Symbol, V, Tuple{Vararg{Symbol, N}}, NamedTuple{names, T}} where {V, N, names, T<:Tuple{Vararg{Any, N}}},typeof(yaxis!),Any,Vararg{Any},))
+    end
+end
 end
--- a/deps/SnoopCompile/precompile/1.8/precompile_Plots.jl
+++ b/deps/SnoopCompile/precompile/1.8/precompile_Plots.jl
@ -15,37 +15,22 @@ end

 function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
-    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
-    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
-    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:rotation, :color), Tuple{Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
@ -73,15 +58,15 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
    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},Matrix{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, String, Symbol}},typeof(plot),Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@ -141,6 +126,7 @@ function _precompile_()
    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{(:zcolor, :m, :leg, :cbar, :w), Tuple{StepRange{Int64, Int64}, Tuple{Int64, Float64, Symbol, Stroke}, Bool, Bool, Int64}},typeof(plot),Vector{Float64},Vector{Float64},UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(portfoliocomposition)),Any,typeof(portfoliocomposition),Any,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(yaxis!)),Any,typeof(yaxis!),Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
@ -151,9 +137,11 @@ function _precompile_()
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hspan}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
@ -168,21 +156,16 @@ function _precompile_()
    Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
-    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}},String})
-    Base.precompile(Tuple{typeof(_cycle),ColorPalette,Int64})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},Vector{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
-    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
-    Base.precompile(Tuple{typeof(_replace_markershape),Vector{Symbol}})
    Base.precompile(Tuple{typeof(_update_min_padding!),GridLayout})
    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{GRBackend},Subplot{GRBackend},Dict{Symbol, Any},Int64,Bool})
    Base.precompile(Tuple{typeof(_update_subplot_args),Plot{PlotlyBackend},Subplot{PlotlyBackend},Dict{Symbol, Any},Int64,Bool})
-    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{GRBackend},Dict{Symbol, Any}})
-    Base.precompile(Tuple{typeof(_update_subplot_legend),Subplot{PlotlyBackend},Dict{Symbol, Any}})
    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(annotate!),AbstractVector{<:Tuple}})
@ -193,12 +176,14 @@ function _precompile_()
    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64},Tuple{Int64, Float64}})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}}})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
    Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
    Base.precompile(Tuple{typeof(get_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}})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any}})
@ -213,9 +198,10 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
-    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64},Int64,Int64})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
@ -223,7 +209,6 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
-    Base.precompile(Tuple{typeof(gr_get_3d_axis_angle),Vector{Float64},Float64,Float64,Symbol})
    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
@ -231,20 +216,17 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
    Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
    Base.precompile(Tuple{typeof(gr_text),Float64,Float64,String})
+    Base.precompile(Tuple{typeof(gr_text_size),String})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
    Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}}})
    Base.precompile(Tuple{typeof(gr_viewport_from_bbox),Subplot{GRBackend},BoundingBox{Tuple{AbsoluteLength, AbsoluteLength}, Tuple{AbsoluteLength, AbsoluteLength}},AbsoluteLength,AbsoluteLength,Vector{Float64}})
-    Base.precompile(Tuple{typeof(heatmap_edges),Base.OneTo{Int64},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
    Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
    Base.precompile(Tuple{typeof(is_marker_supported),GRBackend,Vector{Symbol}})
-    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
-    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
    Base.precompile(Tuple{typeof(link_axes!),GridLayout,Symbol})
-    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@ -254,13 +236,14 @@ function _precompile_()
    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
    Base.precompile(Tuple{typeof(plot!),Plot,Plot,Plot,Vararg{Plot}})
    Base.precompile(Tuple{typeof(plot),Any,Any})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
    Base.precompile(Tuple{typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{typeof(plot),Plot{GRBackend}})
    Base.precompile(Tuple{typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
-    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Int64})
    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},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},Symbol})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText,Font})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,PlotText})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol},Font})
@ -274,17 +257,15 @@ function _precompile_()
    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String},Font})
    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
-    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},String,Symbol})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
-    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64}},Tuple{Int64, Int64},Tuple{Float64, Int64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64, Float64}},Tuple{Float64, Int64, Int64},Tuple{Float64, Int64, Int64}})
    Base.precompile(Tuple{typeof(resetfontsizes)})
    Base.precompile(Tuple{typeof(scalefontsizes),Float64})
-    Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
    Base.precompile(Tuple{typeof(spy),Any})
    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
    Base.precompile(Tuple{typeof(title!),AbstractString})
@ -294,8 +275,8 @@ function _precompile_()
    Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
    Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any}})
    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#303#339")) && Base.precompile(Tuple{getfield(Plots, Symbol("#303#339"))})
-    isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#104")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#104")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#105")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#105")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#2#6")) && Base.precompile(Tuple{getfield(Plots, Symbol("#2#6")),UnitRange{Int64}})
+    isdefined(Plots, Symbol("#322#358")) && Base.precompile(Tuple{getfield(Plots, Symbol("#322#358"))})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
+    isdefined(Plots, Symbol("#add_major_or_minor_segments#103")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#103")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
 end
--- a/deps/SnoopCompile/snoop_bot_config.jl
+++ b/deps/SnoopCompile/snoop_bot_config.jl
@ -2,6 +2,6 @@ using CompileBot

 botconfig = BotConfig(
    "Plots",
-    version = ["1.6", "1.7", "nightly"],  # <<< keep these versions in sync with .github/workflows/SnoopCompile.yml
+    version = ["1.6", "1.7", "1.8", "nightly"],  # <<< keep these versions in sync with .github/workflows/SnoopCompile.yml
    # else_version = "nightly",
 )
--- a/src/Plots.jl
+++ b/src/Plots.jl
@ -1,5 +1,7 @@
 module Plots

+using Pkg
+
 if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@optlevel"))
    @eval Base.Experimental.@optlevel 1
 end
@ -7,17 +9,26 @@ if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@max_m
    @eval Base.Experimental.@max_methods 1
 end

-const _current_plots_version = VersionNumber(
-    split(
-        first(
-            filter(
-                line -> occursin("version", line),
-                readlines(normpath(@__DIR__, "..", "Project.toml")),
-            ),
-        ),
-        "\"",
-    )[2],
-)
+const _plots_project = Pkg.Types.read_project(normpath(@__DIR__, "..", "Project.toml"))
+const _current_plots_version = _plots_project.version
+const _plots_compats = _plots_project.compat
+function _check_compat(sim::Module)
+    sim_str = string(sim)
+    if !haskey(_plots_compats, sim_str)
+        return nothing
+    end
+    be_v = Pkg.Types.read_project(joinpath(Base.pkgdir(sim), "Project.toml")).version
+    be_c = _plots_compats[sim_str]
+    if be_c isa String # julia 1.6
+        if !(be_v in Pkg.Types.semver_spec(be_c))
+            @warn "$sim $be_v is not compatible with this version of Plots. The declared compatibility is $(be_c)."
+        end
+    else
+        if isempty(intersect(be_v, be_c.val))
+            @warn "$sim $be_v is not compatible with this version of Plots. The declared compatibility is $(be_c.str)."
+        end
+    end
+end

 using Reexport

--- a/src/arg_desc.jl
+++ b/src/arg_desc.jl
@ -32,7 +32,8 @@ const _arg_desc = KW(
    :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 (number of contours) or AbstractVector (contour values). Determines contour 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).",
+    :permute            => "Tuple{Symbol,Symbol}. Permutes data and axis properties of the axes given in the tuple. E.g. (:x, :y).",
+    :orientation        => "Symbol. (deprecated) 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)?",
@ -52,6 +53,7 @@ const _arg_desc = KW(
    :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.",
+    :z_order            => "Symbol or Integer. :front (default), :back or index of position where 1 is farest in the background.",

    # plot args
    :plot_title               => "String. Title for the whole plot (not the subplots)",
--- a/src/args.jl
+++ b/src/args.jl
@ -399,6 +399,8 @@ const _series_defaults = KW(
    :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
+    :z_order      => :front, # one of :front, :back or integer in 1:length(sp.series_list)
+    :permute      => :none, # tuple of two symbols to be permuted
    :extra_kwargs => Dict(),
 )

@ -1347,7 +1349,12 @@ function processFontArg!(plotattributes::AKW, fontname::Symbol, arg)
    T = typeof(arg)
    if T <: Font
        plotattributes[Symbol(fontname, :family)] = arg.family
-        plotattributes[Symbol(fontname, :size)] = arg.pointsize
+        # TODO: this is neccessary in the transition from old fontsize to new font_pointsize and should be removed when it is completed
+        if in(Symbol(fontname, :size), _all_args)
+            plotattributes[Symbol(fontname, :size)] = arg.pointsize
+        else
+            plotattributes[Symbol(fontname, :_pointsize)] = arg.pointsize
+        end
        plotattributes[Symbol(fontname, :halign)] = arg.halign
        plotattributes[Symbol(fontname, :valign)] = arg.valign
        plotattributes[Symbol(fontname, :rotation)] = arg.rotation
@ -1368,7 +1375,11 @@ function processFontArg!(plotattributes::AKW, fontname::Symbol, arg)
            plotattributes[Symbol(fontname, :family)] = string(arg)
        end
    elseif typeof(arg) <: Integer
-        plotattributes[Symbol(fontname, :size)] = arg
+        if in(Symbol(fontname, :size), _all_args)
+            plotattributes[Symbol(fontname, :size)] = arg
+        else
+            plotattributes[Symbol(fontname, :_pointsize)] = arg
+        end
    elseif typeof(arg) <: Real
        plotattributes[Symbol(fontname, :rotation)] = convert(Float64, arg)
    else
@ -1487,7 +1498,8 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)
    end

    # fonts
-    for fontname in (:titlefont, :legendtitlefont, :plot_titlefont, :colorbar_titlefont)
+    for fontname in
+        (:titlefont, :legend_title_font, :plot_titlefont, :colorbar_titlefont, :legend_font)
        args = RecipesPipeline.pop_kw!(plotattributes, fontname, ())
        for arg in wraptuple(args)
            processFontArg!(plotattributes, fontname, arg)
@ -1575,7 +1587,11 @@ function RecipesPipeline.preprocess_attributes!(plotattributes::AKW)

    # warnings for moved recipes
    st = get(plotattributes, :seriestype, :path)
-    if st in (:boxplot, :violin, :density) && !isdefined(Main, :StatsPlots)
+    if st in (:boxplot, :violin, :density) &&
+       !haskey(
+        Base.loaded_modules,
+        Base.PkgId(Base.UUID("f3b207a7-027a-5e70-b257-86293d7955fd"), "StatsPlots"),
+    )
        @warn(
            "seriestype $st has been moved to StatsPlots.  To use: \`Pkg.add(\"StatsPlots\"); using StatsPlots\`"
        )
@ -1596,7 +1612,7 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
    already_warned = get!(_already_warned, bend, Set{Symbol}())
    extra_kwargs = Dict{Symbol,Any}()
    for k in keys(plotattributes)
-        is_attr_supported(pkg, k) && continue
+        is_attr_supported(pkg, k) && !(k in keys(_deprecated_attributes)) && continue
        k in _suppress_warnings && continue
        default_value = default(k)
        if ismissing(default_value)
@ -1610,9 +1626,16 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
       get(plotattributes, :warn_on_unsupported, should_warn_on_unsupported(pkg))
        for k in sort(collect(_to_warn))
            push!(already_warned, k)
-            @warn(
-                "Keyword argument $k not supported with $pkg.  Choose from: $(supported_attrs(pkg))"
-            )
+            if k in keys(_deprecated_attributes)
+                @warn("""
+                Keyword argument `$k` is deprecated.
+                Please use `$(_deprecated_attributes[k])` instead.
+                """)
+            else
+                @warn(
+                    "Keyword argument $k not supported with $pkg.  Choose from: $(join(supported_attrs(pkg), ", "))"
+                )
+            end
        end
    end
    return extra_kwargs
@ -1748,15 +1771,17 @@ function slice_arg!(
    remove_pair::Bool,
 )
    v = get(plotattributes_in, k, plotattributes_out[k])
-    plotattributes_out[k] =
-        if haskey(plotattributes_in, k) &&
-           typeof(v) <: AMat &&
-           !isempty(v) &&
-           !(k in _plot_args)
+    plotattributes_out[k] = if haskey(plotattributes_in, k) && !(k in _plot_args)
+        if typeof(v) <: AMat && !isempty(v)
            slice_arg(v, idx)
+        elseif typeof(v) <: NTuple{2,AMat}
+            (slice_arg(v[1], idx), slice_arg(v[2], idx))
        else
            v
        end
+    else
+        v
+    end
    if remove_pair
        RecipesPipeline.reset_kw!(plotattributes_in, k)
    end
@ -1955,29 +1980,6 @@ function _update_subplot_colors(sp::Subplot)
    return
 end

-function _update_subplot_legend(sp::Subplot, plotattributes_in)
-    f_attr = NamedTuple(
-        k => plotattributes_in[Symbol(:legend_font_, k)] for
-        k in (:family, :pointsize, :valign, :halign, :rotation, :color) if
-        haskey(plotattributes_in, Symbol(:legend_font_, k))
-    )
-    #! format: off
-    match_attr = NamedTuple(
-        (
-            lk = Symbol(:legend_font_, k);
-            k =>
-                haskey(_match_map, lk) ? sp[lk] :
-                haskey(plotattributes_in, :legend_font) ?
-                getproperty(plotattributes_in[:legend_font], k) :
-                haskey(sp.attr, :legend_font) ?
-                getproperty(sp.attr[:legend_font], k) :
-                default(plotattributes_in, lk)
-        ) for k in (:family, :pointsize, :valign, :halign, :rotation, :color)
-    )
-    #! format: on
-    sp.attr[:legend_font] = font(; merge(match_attr, f_attr)...)
-end
-
 function _update_axis(
    plt::Plot,
    sp::Subplot,
--- a/src/axes.jl
+++ b/src/axes.jl
@ -675,9 +675,17 @@ end
 # these methods track the discrete (categorical) values which correspond to axis continuous values (cv)
 # whenever we have discrete values, we automatically set the ticks to match.
 # we return (continuous_value, discrete_index)
+function discrete_value!(plotattributes, letter::Symbol, dv)
+    l = if plotattributes[:permute] !== :none
+        only(filter(!=(letter), plotattributes[:permute]))
+    else
+        letter
+    end
+    discrete_value!(plotattributes[:subplot][get_attr_symbol(l, :axis)], dv)
+end
+
 function discrete_value!(axis::Axis, dv)
    cv_idx = get(axis[:discrete_map], dv, -1)
-    # @show axis[:discrete_map], axis[:discrete_values], dv
    if cv_idx == -1
        ex = axis[:extrema]
        cv = NaNMath.max(0.5, ex.emax + 1.0)
--- a/src/backends.jl
+++ b/src/backends.jl
@ -240,6 +240,8 @@ const _base_supported_args = [
    :discrete_values,
    :projection,
    :show_empty_bins,
+    :z_order,
+    :permute,
 ]

 function merge_with_base_supported(v::AVec)
@ -284,7 +286,7 @@ for s in (:attr, :seriestype, :marker, :style, :scale)
        v = Symbol("_", bend, "_", s)
        @eval begin
            $f(::$bend_type, $s::Symbol) = $s in $v
-            $f2(::$bend_type) = $v
+            $f2(::$bend_type) = sort(collect($v))
        end
    end
 end
@ -300,11 +302,23 @@ function _initialize_backend(pkg::AbstractBackend)
    @eval Main begin
        import $sym
        export $sym
+        $(_check_compat)($sym)
    end
 end

 _initialize_backend(pkg::GRBackend) = nothing

+function _initialize_backend(pkg::PlotlyBackend)
+    try
+        @eval Main begin
+            import PlotlyBase
+        end
+        _check_compat(PlotlyBase)
+    catch
+        @info "For saving to png with the Plotly backend PlotlyBase has to be installed."
+    end
+end
+
 # ------------------------------------------------------------------------------
 # gr

@ -335,6 +349,7 @@ const _gr_attr = merge_with_base_supported([
    :fillrange,
    :fillcolor,
    :fillalpha,
+    :fillstyle,
    :bins,
    :layout,
    :title,
@ -423,16 +438,6 @@ is_marker_supported(::GRBackend, shape::Shape) = true
 # ------------------------------------------------------------------------------
 # plotly

-function _initialize_backend(pkg::PlotlyBackend)
-    try
-        @eval Main begin
-            import PlotlyBase
-        end
-    catch
-        @info "For saving to png with the Plotly backend PlotlyBase has to be installed."
-    end
-end
-
 const _plotly_attr = merge_with_base_supported([
    :annotations,
    :legend_background_color,
@ -945,6 +950,7 @@ const _unicodeplots_seriestype = [
    :heatmap,
    :contour,
    # :contour3d,
+    :permute,
    :spy,
    :surface,
    :wireframe,
@ -1317,7 +1323,6 @@ const _pgfplotsx_marker = [
    :pentagon,
    :hline,
    :vline,
-    Shape,
 ]
 const _pgfplotsx_scale = [:identity, :ln, :log2, :log10]
 is_marker_supported(::PGFPlotsXBackend, shape::Shape) = true
--- a/src/backends/deprecated/pgfplots.jl
+++ b/src/backends/deprecated/pgfplots.jl
@ -3,7 +3,7 @@
 # significant contributions by: @pkofod

 # --------------------------------------------------------------------------------------
-
+# COV_EXCL_START
 const _pgfplots_linestyles = KW(
    :solid => "solid",
    :dash => "dashed",
@ -740,3 +740,5 @@ function _display(plt::Plot{PGFPlotsBackend})
    # cleanup
    PGFPlots.cleanup(plt.o)
 end
+
+# COV_EXCL_STOP
--- a/src/backends/gaston.jl
+++ b/src/backends/gaston.jl
@ -1,8 +1,6 @@
 # https://github.com/mbaz/Gaston.

-# --------------------------------------------
-# These functions are called by Plots
-# --------------------------------------------
+should_warn_on_unsupported(::GastonBackend) = false

 # Create the window/figure for this backend.
 function _create_backend_figure(plt::Plot{GastonBackend})
@ -112,7 +110,7 @@ function gaston_saveopts(plt::Plot{GastonBackend})

    # Scale all plot elements to match Plots.jl DPI standard
    scaling = plt.attr[:dpi] / Plots.DPI
-    push!(saveopts, "fontscale $scaling lw $scaling dl $scaling ps $scaling")
+    push!(saveopts, "fontscale $scaling lw $scaling dl $scaling")  #  ps $scaling

    return join(saveopts, " ")
 end
@ -246,10 +244,9 @@ function gaston_add_series(plt::Plot{GastonBackend}, series::Series)
                if (lx = length(x)) == 2 && lx != nc
                    x = collect(range(x[1], x[2], length = nc))
                end
-            elseif st == :heatmap
-                length(x) == size(z, 2) + 1 && (x = @view x[1:(end - 1)])
-                length(y) == size(z, 1) + 1 && (y = @view y[1:(end - 1)])
            end
+            length(x) == size(z, 2) + 1 && (x = (x[1:(end - 1)] + x[2:end]) / 2)
+            length(y) == size(z, 1) + 1 && (y = (y[1:(end - 1)] + y[2:end]) / 2)
        end
        if st == :mesh3d
            x, y, z = mesh3d_triangles(x, y, z, series[:connections])
--- a/src/backends/gr.jl
+++ b/src/backends/gr.jl
@ -1272,7 +1272,7 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
        GR.restorestate()
    end

-    legend_width_factor = 0.02
+    legend_width_factor = (viewport_plotarea[2] - viewport_plotarea[1]) / 45 # Determines the width of legend box
    legend_textw = legendw
    legend_rightw = legend_width_factor
    legend_leftw = legend_width_factor * 4
--- a/src/backends/inspectdr.jl
+++ b/src/backends/inspectdr.jl
@ -13,7 +13,7 @@ Add in functionality to Plots.jl:
    :aspect_ratio,
 =#

-# ---------------------------------------------------------------------------
+should_warn_on_unsupported(::InspectDRBackend) = false

 is_marker_supported(::InspectDRBackend, shape::Shape) = true

--- a/src/backends/pgfplotsx.jl
+++ b/src/backends/pgfplotsx.jl
@ -162,7 +162,6 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                "anchor" => "north west",
                "xshift" => string(dx),
                "yshift" => string(-dy),
-                "clip mode" => "individual",
            )
            sp_width > 0 * mm ? push!(axis_opt, "width" => string(axis_width)) : nothing
            sp_height > 0 * mm ? push!(axis_opt, "height" => string(axis_height)) : nothing
@ -207,8 +206,8 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})

            if hascolorbar(sp)
                cticks = get_colorbar_ticks(sp)[2]
-                colorbar_style = PGFPlotsX.Options("ylabel" => sp[:colorbar_title])
                if sp[:colorbar] === :top
+                    colorbar_style = PGFPlotsX.Options("xlabel" => sp[:colorbar_title])
                    push!(
                        colorbar_style,
                        "at" => string((0.5, 1.05)),
@ -218,6 +217,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                        "xticklabel style" => pgfx_get_colorbar_ticklabel_style(sp),
                    )
                else
+                    colorbar_style = PGFPlotsX.Options("ylabel" => sp[:colorbar_title])
                    push!(
                        colorbar_style,
                        "ytick" => string("{", join(cticks, ","), "}"),
@ -404,6 +404,9 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                    ),
                ),
            )
+            if opt[:label] == ""
+                push!(arrow_opt, "forget plot" => nothing)
+            end
            if arrow.side == :head
                x_arrow = opt[:x][rng][(end - 1):end]
                y_arrow = opt[:y][rng][(end - 1):end]
@ -427,6 +430,7 @@ function pgfx_add_series!(::Val{:path}, axis, series_opt, series, series_func, o
                :v => [y_arrow[i] - y_arrow[i - 1] for i in 2:2:lastindex(y_arrow)],
            ])
            arrow_plot = series_func(merge(series_opt, arrow_opt), coordinates)
+            push!(series_opt, "forget plot" => nothing)
            push!(axis, arrow_plot)
            coordinates = PGFPlotsX.Table(x_path, y_path)
            segment_plot = series_func(merge(series_opt, segment_opt), coordinates)
@ -1056,11 +1060,7 @@ function pgfx_add_annotation!(
    push!(
        o,
        join([
-            raw"""
-            \begin{scope}
-                \clip \pgfextra{\pgfplotspathaxisoutline};
-                \node
-            """,
+            "\\node",
            sprint(
                PGFPlotsX.print_tex,
                merge(
@ -1079,7 +1079,6 @@ function pgfx_add_annotation!(
                ),
            ),
            string(" at (", cs, x, ",", y, ") {", val.str, "};"),
-            "\\end{scope}",
        ]),
    )
 end
--- a/src/backends/plotly.jl
+++ b/src/backends/plotly.jl
@ -752,14 +752,14 @@ function plotly_series(plt::Plot, series::Series)
    end

    plotly_polar!(plotattributes_out, series)
-    plotly_hover!(plotattributes_out, series[:hover])
+    plotly_adjust_hover_label!(plotattributes_out, series[:hover])

-    return [plotattributes_out]
+    return [merge(plotattributes_out, series[:extra_kwargs])]
 end

 function plotly_series_shapes(plt::Plot, series::Series, clims)
    segments = series_segments(series; check = true)
-    plotattributes_outs = Vector{KW}(undef, length(segments))
+    plotattributes_outs = [KW() for _ in 1:length(segments)]

    # TODO: create a plotattributes_out for each polygon
    # x, y = series[:x], series[:y]
@ -807,8 +807,8 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
        end
        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[k] = plotattributes_out
+        plotly_adjust_hover_label!(plotattributes_out, _cycle(series[:hover], i))
+        plotattributes_outs[k] = merge(plotattributes_out, series[:extra_kwargs])
    end
    if series[:fill_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
@ -931,7 +931,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
        end

        plotly_polar!(plotattributes_out, series)
-        plotly_hover!(plotattributes_out, _cycle(series[:hover], rng))
+        plotly_adjust_hover_label!(plotattributes_out, _cycle(series[:hover], rng))

        if hasfillrange
            # if hasfillrange is true, return two dictionaries (one for original
@ -969,6 +969,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
        else
            plotattributes_outs[k] = plotattributes_out
        end
+        plotattributes_outs[k] = merge(plotattributes_outs[k], series[:extra_kwargs])
    end

    if series[:line_z] !== nothing
@ -1019,14 +1020,16 @@ function plotly_polar!(plotattributes_out::KW, series::Series)
    end
 end

-function plotly_hover!(plotattributes_out::KW, hover)
-    # hover text
-    if hover === nothing || all(in([:none, false]), hover)
+function plotly_adjust_hover_label!(plotattributes_out::KW, hover)
+    if hover === nothing
+        return nothing
+    elseif all(in([:none, false]), hover)
        plotattributes_out[:hoverinfo] = "none"
    elseif any(!isnothing, hover)
        plotattributes_out[:hoverinfo] = "text"
        plotattributes_out[:text] = hover
    end
+    return nothing
 end

 # get a list of dictionaries, each representing the series params
--- a/src/backends/pyplot.jl
+++ b/src/backends/pyplot.jl
@ -1297,8 +1297,8 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
            fontProperties = PyPlot.PyCall.PyDict(
                Dict(
                    "family" => axis[:tickfontfamily],
-                    "math_fontfamily" =>
-                        py_get_matching_math_font(axis[:tickfontfamily]),
+                   # "math_fontfamily" =>
+                   #     py_get_matching_math_font(axis[:tickfontfamily]),
                    "size" => py_thickness_scale(plt, axis[:tickfontsize]),
                    "rotation" => axis[:tickfontrotation],
                ),
--- a/src/backends/unicodeplots.jl
+++ b/src/backends/unicodeplots.jl
@ -1,8 +1,5 @@
 # https://github.com/JuliaPlots/UnicodePlots.jl

-should_warn_on_unsupported(::UnicodePlotsBackend) = false
-
-# ------------------------------------------------------------------------------------------
 const _canvas_map = (
    braille = UnicodePlots.BrailleCanvas,
    density = UnicodePlots.DensityCanvas,
@ -13,11 +10,10 @@ const _canvas_map = (
    dot = UnicodePlots.DotCanvas,
 )

-# do all the magic here... build it all at once,
-# since we need to know about all the series at the very beginning
-function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
-    plt.o = UnicodePlots.Plot[]
+should_warn_on_unsupported(::UnicodePlotsBackend) = false

+function _before_layout_calcs(plt::Plot{UnicodePlotsBackend})
+    plt.o = UnicodePlots.Plot[]
    up_width = UnicodePlots.DEFAULT_WIDTH[]
    up_height = UnicodePlots.DEFAULT_HEIGHT[]

@ -162,6 +158,10 @@ function addUnicodeSeries!(
        series[:x], series[:y]
    end

+    if ispolar(sp) || ispolar(series)
+        return UnicodePlots.polarplot(x, y)
+    end
+
    # special handling (src/interface)
    fix_ar = get(se_kw, :fix_ar, true)
    if st === :histogram2d
@ -254,45 +254,56 @@ end

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

-# since this is such a hack, it's only callable using `png`...
-# should error during normal `show`
-function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
-    fn = addExtension(fn, "png")
-
-    @static if Sys.isapple()
-        # make some whitespace and show the plot
-        println("\n\n\n\n\n\n")
-        gui(plt)
-        sleep(0.5)
-        # use osx screen capture when my terminal is maximized
-        # and cursor starts at the bottom (I know, right?)
-        run(`screencapture -R50,600,700,420 $fn`)
-        return
-    elseif Sys.islinux()
-        run(`clear`)
-        gui(plt)
-        win = if "WINDOWID" in keys(ENV)
-            ENV["WINDOWID"]
-        else
-            readchomp(`xdotool getactivewindow`)
+function _show(io::IO, ::MIME"image/png", plt::Plot{UnicodePlotsBackend})
+    prepare_output(plt)
+    nr, nc = size(plt.layout)
+    s1 = zeros(Int, nr, nc)
+    s2 = zeros(Int, nr, nc)
+    canvas_type = nothing
+    imgs = []
+    sps = 0
+    for r in 1:nr
+        for c in 1:nc
+            if (l = plt.layout[r, c]) isa GridLayout && size(l) != (1, 1)
+                error("Plots(UnicodePlots): complex nested layout is currently unsupported")
+            else
+                img = UnicodePlots.png_image(plt.o[sps += 1])
+                canvas_type = eltype(img)
+                h, w = size(img)
+                s1[r, c] = h
+                s2[r, c] = w
+                push!(imgs, img)
+            end
        end
-        run(`import -window $win $fn`)
-        return
    end
-
-    error(
-        "Can only savepng on MacOS or Linux with UnicodePlots " *
-        "(though even then I wouldn't do it)",
-    )
+    if canvas_type !== nothing
+        m1 = maximum(s1; dims = 2)
+        m2 = maximum(s2; dims = 1)
+        img = zeros(canvas_type, sum(m1), sum(m2))
+        sps = 0
+        n1 = 1
+        for r in 1:nr
+            n2 = 1
+            for c in 1:nc
+                sp = imgs[sps += 1]
+                h, w = size(sp)
+                img[n1:(n1 + (h - 1)), n2:(n2 + (w - 1))] = sp
+                n2 += m2[c]
+            end
+            n1 += m1[r]
+        end
+        stream = UnicodePlots.FileIO.Stream{UnicodePlots.FileIO.format"PNG"}(io)
+        UnicodePlots.FileIO.save(stream, img)
+    end
+    nothing
 end

-# ------------------------------------------------------------------------------------------
 Base.show(plt::Plot{UnicodePlotsBackend}) = show(stdout, plt)
 Base.show(io::IO, plt::Plot{UnicodePlotsBackend}) = _show(io, MIME("text/plain"), plt)

 # NOTE: _show(...) must be kept for Base.showable (src/output.jl)
 function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
-    unicodeplots_rebuild(plt)
+    prepare_output(plt)
    nr, nc = size(plt.layout)
    if nr == 1 && nc == 1  # fast path
        n = length(plt.o)
@ -301,7 +312,6 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
            i < n && println(io)
        end
    else
-        re_ansi = r"\e\[[0-9;]*[a-zA-Z]"  # m: color, [a-zA-Z]: all escape sequences
        have_color = Base.get_have_color()
        buf = IOContext(PipeBuffer(), :color => have_color)
        lines_colored = Array{Union{Nothing,Vector{String}}}(undef, nr, nc)
@ -312,9 +322,10 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
        for r in 1:nr
            lmax = 0
            for c in 1:nc
-                l = plt.layout[r, c]
-                if l isa GridLayout && size(l) != (1, 1)
-                    @error "Plots(UnicodePlots): complex nested layout is currently unsupported"
+                if (l = plt.layout[r, c]) isa GridLayout && size(l) != (1, 1)
+                    error(
+                        "Plots(UnicodePlots): complex nested layout is currently unsupported",
+                    )
                else
                    if get(l.attr, :blank, false)
                        lines_colored[r, c] = lines_uncolored[r, c] = nothing
@ -324,7 +335,7 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
                        colored = read(buf, String)
                        lines_colored[r, c] = lu = lc = split(colored, '\n')
                        if have_color
-                            uncolored = replace(colored, re_ansi => "")
+                            uncolored = UnicodePlots.no_ansi_escape(colored)
                            lines_uncolored[r, c] = lu = split(uncolored, '\n')
                        end
                        lmax = max(length(lc), lmax)
@ -356,4 +367,7 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
 end

 # we only support MIME"text/plain", hence display(...) falls back to plain-text on stdout
-_display(plt::Plot{UnicodePlotsBackend}) = (show(stdout, plt); println(stdout))
+function _display(plt::Plot{UnicodePlotsBackend})
+    show(stdout, plt)
+    println(stdout)
+end
--- a/src/components.jl
+++ b/src/components.jl
@ -159,10 +159,15 @@ function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
    shape
 end

+"""
+    scale(shape, x, y = x, c = center(shape))
+    scale!(shape, x, y = x, c = center(shape))
+
+Scale shape by a factor.
+"""
 scale(shape::Shape, x::Real, y::Real = x, c = center(shape)) =
    scale!(deepcopy(shape), x, y, c)

-"translate a Shape in space"
 function translate!(shape::Shape, x::Real, y::Real = x)
    sx, sy = coords(shape)
    for i in eachindex(sx)
@ -172,22 +177,27 @@ function translate!(shape::Shape, x::Real, y::Real = x)
    shape
 end

+"""
+    translate(shape, x, y = x)
+    translate!(shape, x, y = x)
+
+Translate a Shape in space.
+"""
 translate(shape::Shape, x::Real, y::Real = x) = translate!(deepcopy(shape), x, y)

-rotate_x(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real) =
-    ((x - centerx) * cos(Θ) - (y - centery) * sin(Θ) + centerx)
+rotate_x(x::Real, y::Real, θ::Real, centerx::Real, centery::Real) =
+    ((x - centerx) * cos(θ) - (y - centery) * sin(θ) + centerx)

-rotate_y(x::Real, y::Real, Θ::Real, centerx::Real, centery::Real) =
-    ((y - centery) * cos(Θ) + (x - centerx) * sin(Θ) + centery)
+rotate_y(x::Real, y::Real, θ::Real, centerx::Real, centery::Real) =
+    ((y - centery) * cos(θ) + (x - centerx) * sin(θ) + centery)

-rotate(x::Real, y::Real, θ::Real, c = center(shape)) =
-    (rotate_x(x, y, Θ, c...), rotate_y(x, y, Θ, c...))
+rotate(x::Real, y::Real, θ::Real, c) = (rotate_x(x, y, θ, c...), rotate_y(x, y, θ, c...))

-function rotate!(shape::Shape, Θ::Real, c = center(shape))
+function rotate!(shape::Shape, θ::Real, c = center(shape))
    x, y = coords(shape)
    for i in eachindex(x)
-        xi = rotate_x(x[i], y[i], Θ, c...)
-        yi = rotate_y(x[i], y[i], Θ, c...)
+        xi = rotate_x(x[i], y[i], θ, c...)
+        yi = rotate_y(x[i], y[i], θ, c...)
        x[i], y[i] = xi, yi
    end
    shape
--- a/src/consts.jl
+++ b/src/consts.jl
@ -1,4 +1,5 @@

+const _deprecated_attributes = Dict{Symbol,Symbol}(:orientation => :permute)
 const _all_defaults = KW[_series_defaults, _plot_defaults, _subplot_defaults]

 const _initial_defaults = deepcopy(_all_defaults)
@ -41,29 +42,27 @@ const _initial_fontsizes =
 const _internal_args =
    [:plot_object, :series_plotindex, :markershape_to_add, :letter, :idxfilter]

-const _axis_args = sort(union(collect(keys(_axis_defaults))))
-const _series_args = sort(union(collect(keys(_series_defaults))))
-const _subplot_args = sort(union(collect(keys(_subplot_defaults))))
-const _plot_args = sort(union(collect(keys(_plot_defaults))))
+const _axis_args = Set(keys(_axis_defaults))
+const _series_args = Set(keys(_series_defaults))
+const _subplot_args = Set(keys(_subplot_defaults))
+const _plot_args = Set(keys(_plot_defaults))

 const _magic_axis_args = [:axis, :tickfont, :guidefont, :grid, :minorgrid]
 const _magic_subplot_args =
    [:title_font, :legend_font, :legend_title_font, :plot_title_font, :colorbar_titlefont]
 const _magic_series_args = [:line, :marker, :fill]
 const _all_magic_args =
-    sort(union(_magic_axis_args, _magic_series_args, _magic_subplot_args))
+    Set(union(_magic_axis_args, _magic_series_args, _magic_subplot_args))

-const _all_axis_args = sort(union([_axis_args; _magic_axis_args]))
-const _all_subplot_args = sort(union([_subplot_args; _magic_subplot_args]))
-const _all_series_args = sort(union([_series_args; _magic_series_args]))
+const _all_axis_args = union(_axis_args, _magic_axis_args)
+const _lettered_all_axis_args =
+    Set([Symbol(letter, kw) for letter in (:x, :y, :z) for kw in _all_axis_args])
+const _all_subplot_args = union(_subplot_args, _magic_subplot_args)
+const _all_series_args = union(_series_args, _magic_series_args)
 const _all_plot_args = _plot_args

-const _all_args = sort(union([
-    _all_axis_args
-    _all_subplot_args
-    _all_series_args
-    _all_plot_args
-]))
+const _all_args =
+    union(_lettered_all_axis_args, _all_subplot_args, _all_series_args, _all_plot_args)

 # add all pluralized forms to the _keyAliases dict
 for arg in _all_args
--- a/src/examples.jl
+++ b/src/examples.jl
@ -849,7 +849,6 @@ const _examples = PlotExample[
        [
            quote
                begin
-                    using Plots
                    default(
                        titlefont = (20, "times"),
                        legendfontsize = 18,
@ -1071,7 +1070,6 @@ const _examples = PlotExample[
        "",
        [
            quote
-                using Plots
                using TestImages
                img = testimage("lighthouse")

@ -1092,8 +1090,6 @@ const _examples = PlotExample[
        "3d quiver",
        "",
        [quote
-            using Plots
-
            ϕs = range(-π, π, length = 50)
            θs = range(0, π, length = 25)
            θqs = range(1, π - 1, length = 25)
@ -1277,12 +1273,30 @@ const _examples = PlotExample[
            end
        )],
    ),
+    PlotExample( # 58
+        "Stacked area chart",
+        """
+        `areaplot` draws stacked area plots.
+        """,
+        [
+            :(
+                begin
+                    areaplot(
+                        1:3,
+                        [1 2 3; 7 8 9; 4 5 6],
+                        seriescolor = [:red :green :blue],
+                        fillalpha = [0.2 0.3 0.4],
+                    )
+                end
+            ),
+        ],
+    ),
 ]

 # Some constants for PlotDocs and PlotReferenceImages
 _animation_examples = [2, 31]
 _backend_skips = Dict(
-    :gr => [25, 30],
+    :gr => [30],
    :pyplot => [2, 25, 30, 31, 49, 55, 56],
    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 50, 51, 55, 56],
    :pgfplotsx => [
@ -1303,8 +1317,8 @@ _backend_skips = Dict(
        16,  # nested layout unsupported
        21,  # custom markers unsupported
        26,  # nested layout unsupported
-        27,  # polar plots unsupported
        29,  # nested layout unsupported
+        31,  # nested layout unsupported
        33,  # grid lines unsupported
        34,  # framestyle unsupported
        37,  # ribbons / filled unsupported
--- a/src/ijulia.jl
+++ b/src/ijulia.jl
@ -49,6 +49,9 @@ function _ijulia_display_dict(plt::Plot)
        mime = "text/html"
        out[mime] = sprint(show, MIME(mime), plt)
        _ijulia__extra_mime_info!(plt, out)
+    elseif output_type == :pdf
+        mime = "application/pdf"
+        out[mime] = base64encode(show, MIME(mime), plt)
    else
        error("Unsupported output type $output_type")
    end
--- a/src/legend.jl
+++ b/src/legend.jl
@ -4,8 +4,7 @@ legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax, inout)
 ```

 Return `(x,y)` at an angle `theta` degrees from
-`(xcenter,ycenter)` on a rectangle defined by (`xmin`,
-`xmax`, `ymin`, `ymax`).
+`(xcenter,ycenter)` on a rectangle defined by (`xmin`, `xmax`, `ymin`, `ymax`).
 """
 function legend_pos_from_angle(theta, xmin, xcenter, xmax, ymin, ycenter, ymax)
    (s, c) = sincosd(theta)
--- a/src/output.jl
+++ b/src/output.jl
@ -2,74 +2,65 @@
 defaultOutputFormat(plt::Plot) = "png"

 function png(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "png")
-    io = open(fn, "w")
-    show(io, MIME("image/png"), plt)
-    close(io)
+    open(addExtension(fn, "png"), "w") do io
+        show(io, MIME("image/png"), plt)
+    end
 end
 png(fn::AbstractString) = png(current(), fn)

 function svg(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "svg")
-    io = open(fn, "w")
-    show(io, MIME("image/svg+xml"), plt)
-    close(io)
+    open(addExtension(fn, "svg"), "w") do io
+        show(io, MIME("image/svg+xml"), plt)
+    end
 end
 svg(fn::AbstractString) = svg(current(), fn)

 function pdf(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "pdf")
-    io = open(fn, "w")
-    show(io, MIME("application/pdf"), plt)
-    close(io)
+    open(addExtension(fn, "pdf"), "w") do io
+        show(io, MIME("application/pdf"), plt)
+    end
 end
 pdf(fn::AbstractString) = pdf(current(), fn)

 function ps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "ps")
-    io = open(fn, "w")
-    show(io, MIME("application/postscript"), plt)
-    close(io)
+    open(addExtension(fn, "ps"), "w") do io
+        show(io, MIME("application/postscript"), plt)
+    end
 end
 ps(fn::AbstractString) = ps(current(), fn)

 function eps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "eps")
-    io = open(fn, "w")
-    show(io, MIME("image/eps"), plt)
-    close(io)
+    open(addExtension(fn, "eps"), "w") do io
+        show(io, MIME("image/eps"), plt)
+    end
 end
 eps(fn::AbstractString) = eps(current(), fn)

 function tex(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "tex")
-    io = open(fn, "w")
-    show(io, MIME("application/x-tex"), plt)
-    close(io)
+    open(addExtension(fn, "tex"), "w") do io
+        show(io, MIME("application/x-tex"), plt)
+    end
 end
 tex(fn::AbstractString) = tex(current(), fn)

 function json(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "json")
-    io = open(fn, "w")
-    show(io, MIME("application/vnd.plotly.v1+json"), plt)
-    close(io)
+    open(addExtension(fn, "json"), "w") do io
+        show(io, MIME("application/vnd.plotly.v1+json"), plt)
+    end
 end
 json(fn::AbstractString) = json(current(), fn)

 function html(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "html")
-    io = open(fn, "w")
-    show(io, MIME("text/html"), plt)
-    close(io)
+    open(addExtension(fn, "html"), "w") do io
+        show(io, MIME("text/html"), plt)
+    end
 end
 html(fn::AbstractString) = html(current(), fn)

-function txt(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "txt")
-    io = open(fn, "w")
-    show(io, MIME("text/plain"), plt)
-    close(io)
+function txt(plt::Plot, fn::AbstractString; color::Bool = true)
+    open(addExtension(fn, "txt"), "w") do io
+        show(IOContext(io, :color => color), MIME("text/plain"), plt)
+    end
 end
 txt(fn::AbstractString) = txt(current(), fn)

@ -88,6 +79,13 @@ const _savemap = Dict(
    "txt" => txt,
 )

+for out in Symbol.(unique(values(_savemap)))
+    @eval @doc """
+        $($out)([plot,], filename)
+    Save plot as $($out)-file.
+    """ $out
+end
+
 const _extension_map = Dict("tikz" => "tex")

 function addExtension(fn::AbstractString, ext::AbstractString)
--- a/src/pipeline.jl
+++ b/src/pipeline.jl
@ -68,6 +68,17 @@ end
 function _preprocess_userrecipe(kw::AKW)
    _add_markershape(kw)

+    if get(kw, :permute, default(:permute)) != :none
+        l1, l2 = kw[:permute]
+        for k in _axis_args
+            k1 = _attrsymbolcache[l1][k]
+            k2 = _attrsymbolcache[l2][k]
+            kwk = keys(kw)
+            if k1 in kwk || k2 in kwk
+                kw[k1], kw[k2] = get(kw, k2, default(k2)), get(kw, k1, default(k1))
+            end
+        end
+    end
    # map marker_z if it's a Function
    if isa(get(kw, :marker_z, default(:marker_z)), Function)
        # TODO: should this take y and/or z as arguments?
@ -275,7 +286,6 @@ function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
            get(sp_attrs, sp, KW())
        end
        _update_subplot_args(plt, sp, attr, idx, false)
-        _update_subplot_legend(sp, attr)
    end

    # do we need to link any axes together?
@ -339,6 +349,19 @@ RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported

 function RecipesPipeline.add_series!(plt::Plot, plotattributes)
    sp = _prepare_subplot(plt, plotattributes)
+    if plotattributes[:permute] != :none
+        letter1, letter2 = plotattributes[:permute]
+        if plotattributes[:markershape] == :hline &&
+           (plotattributes[:permute] == (:x, :y) || plotattributes[:permute] == (:y, :x))
+            plotattributes[:markershape] = :vline
+        elseif plotattributes[:markershape] == :vline && (
+            plotattributes[:permute] == (:x, :y) || plotattributes[:permute] == (:y, :x)
+        )
+            plotattributes[:markershape] = :hline
+        end
+        plotattributes[letter1], plotattributes[letter2] =
+            plotattributes[letter2], plotattributes[letter1]
+    end
    _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype])
    _update_series_attributes!(plotattributes, plt, sp)
    _add_the_series(plt, sp, plotattributes)
@ -428,7 +451,16 @@ function _add_the_series(plt, sp, plotattributes)
    warn_on_unsupported(plt.backend, plotattributes)
    series = Series(plotattributes)
    push!(plt.series_list, series)
-    push!(sp.series_list, series)
+    z_order = plotattributes[:z_order]
+    if z_order == :front
+        push!(sp.series_list, series)
+    elseif z_order == :back
+        pushfirst!(sp.series_list, series)
+    elseif z_order isa Integer
+        insert!(sp.series_list, z_order, series)
+    else
+        @error "Wrong type $(typeof(z_order)) for attribute z_order"
+    end
    _series_added(plt, series)
    _update_subplot_colorbars(sp)
 end
--- a/src/plot.jl
+++ b/src/plot.jl
@ -247,6 +247,12 @@ function prepare_output(plt::Plot)
    _update_plot_object(plt)
 end

+"""
+    backend_object(plot)
+
+Returns the backend representation of a Plot object.
+Returns `nothing` if the backend does not support this.
+"""
 function backend_object(plt::Plot)
    prepare_output(plt)
    plt.o
--- a/src/precompile_includer.jl
+++ b/src/precompile_includer.jl
@ -1,5 +1,5 @@
 #! format: off
-should_precompile =   true
+should_precompile =     true


 # Don't edit the following! Instead change the script for `snoop_bot`.
@ -29,6 +29,11 @@ elseif v"1.8.0-DEV" <= VERSION <= v"1.8.9"
        include("../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl")
        _precompile_()
    end
+elseif v"1.9.0-DEV" <= VERSION <= v"1.9.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.9/precompile_Plots.jl")
+        _precompile_()
+    end
 else 
    end

--- a/src/recipes.jl
+++ b/src/recipes.jl
@ -438,7 +438,7 @@ end
    procx, procy, xscale, yscale, baseline = _preprocess_barlike(plotattributes, x, y)
    nx, ny = length(procx), length(procy)
    axis = plotattributes[:subplot][isvertical(plotattributes) ? :xaxis : :yaxis]
-    cv = [discrete_value!(axis, xi)[1] for xi in procx]
+    cv = [discrete_value!(plotattributes, :x, xi)[1] for xi in procx]
    procx = if nx == ny
        cv
    elseif nx == ny + 1
@ -1037,6 +1037,8 @@ export lens!
        throw(ArgumentError("Inset bounding box needs to in relative coordinates."))
    end
    sp = plt.subplots[sp_index]
+    xscale = sp[:xaxis][:scale]
+    yscale = sp[:yaxis][:scale]
    xl1, xl2 = xlims(sp)
    bbx1 = xl1 + left(inset_bbox).value * (xl2 - xl1)
    bbx2 = bbx1 + width(inset_bbox).value * (xl2 - xl1)
@ -1046,8 +1048,8 @@ export lens!
    bbx = bbx1 + width(inset_bbox).value * (xl2 - xl1) / 2 * (sp[:xaxis][:flip] ? -1 : 1)
    bby = bby1 + height(inset_bbox).value * (yl2 - yl1) / 2 * (sp[:yaxis][:flip] ? -1 : 1)
    lens_index = last(plt.subplots)[:subplot_index] + 1
-    x1, x2 = plotattributes[:x]
-    y1, y2 = plotattributes[:y]
+    x1, x2 = RecipesPipeline.inverse_scale_func(xscale).(plotattributes[:x])
+    y1, y2 = RecipesPipeline.inverse_scale_func(yscale).(plotattributes[:y])
    backup = copy(plotattributes)
    empty!(plotattributes)

@ -1072,8 +1074,8 @@ export lens!
        @series begin
            primary := false
            subplot := sp_index
-            x := [xi_mag, xi_lens]
-            y := [yi_mag, yi_lens]
+            x := RecipesPipeline.scale_func(xscale).([xi_mag, xi_lens])
+            y := RecipesPipeline.scale_func(yscale).([yi_mag, yi_lens])
            ()
        end
    end
@ -1081,8 +1083,8 @@ export lens!
    @series begin
        primary := false
        subplot := sp_index
-        x := [x1, x1, x2, x2, x1]
-        y := [y1, y2, y2, y1, y1]
+        x := RecipesPipeline.scale_func(xscale).([x1, x1, x2, x2, x1])
+        y := RecipesPipeline.scale_func(yscale).([y1, y2, y2, y1, y1])
        ()
    end
    # add subplot
@ -1091,8 +1093,8 @@ export lens!
            plotattributes = merge(backup, copy(series.plotattributes))
            subplot := lens_index
            primary := false
-            xlims := (x1, x2)
-            ylims := (y1, y2)
+            xlims := RecipesPipeline.scale_func(xscale).((x1, x2))
+            ylims := RecipesPipeline.scale_func(yscale).((y1, y2))
            ()
        end
    end
@ -1138,6 +1140,13 @@ end
 # Error Bars

 function error_style!(plotattributes::AKW)
+    # errorbar color should soley determined by markerstrokecolor
+    if haskey(plotattributes, :marker_z)
+        reset_kw!(plotattributes, :marker_z)
+    end
+    if haskey(plotattributes, :line_z)
+        reset_kw!(plotattributes, :line_z)
+    end
    msc = plotattributes[:markerstrokecolor]
    msc = if msc === :match
        plotattributes[:subplot][:foreground_color_subplot]
@ -1380,7 +1389,8 @@ function clamp_greys!(mat::AMat{<:Gray})
 end

@recipe function f(mat::AMat{<:Gray})
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))
+
    if is_seriestype_supported(:image)
        seriestype := :image
        yflip --> true
@ -1398,7 +1408,7 @@ end

 # images - colors
@recipe function f(mat::AMat{T}) where {T<:Colorant}
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))

    if is_seriestype_supported(:image)
        seriestype := :image
@ -1622,7 +1632,6 @@ end

@nospecialize

-"Adds ax+b... straight line over the current plot, without changing the axis limits"
 abline!(plt::Plot, a, b; kw...) =
    plot!(plt, [0, 1], [b, b + a]; seriestype = :straightline, kw...)

@ -1667,16 +1676,6 @@ end
    end
 end

-"""
-    areaplot([x,] y)
-    areaplot!([x,] y)
-
-Draw a stacked area plot of the matrix y.
-# Examples
-```julia-repl
-julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], fillalpha = [0.2 0.3 0.4])
-```
-"""
@userplot AreaPlot

@recipe function f(a::AreaPlot)
--- a/src/shorthands.jl
+++ b/src/shorthands.jl
@ -472,10 +472,33 @@ yflip!(flip::Bool = true; kw...) = plot!(; yflip = flip, kw...)

 "Specify x axis attributes for an existing plot"
 xaxis!(args...; kw...) = plot!(; xaxis = args, kw...)
+xgrid!(args...; kw...) = plot!(; xgrid = args, kw...)

 "Specify y axis attributes for an existing plot"
 yaxis!(args...; kw...) = plot!(; yaxis = args, kw...)
-xgrid!(args...; kw...) = plot!(; xgrid = args, kw...)
 ygrid!(args...; kw...) = plot!(; ygrid = args, kw...)

+@doc """
+   abline!([plot,] a, b; kwargs...)
+
+Adds ax+b... straight line over the current plot, without changing the axis limits
+""" abline!
+
+@doc """
+    areaplot([x,] y)
+    areaplot!([x,] y)
+
+Draw a stacked area plot of the matrix y.
+# Examples
+```julia-repl
+julia> areaplot(1:3, [1 2 3; 7 8 9; 4 5 6], seriescolor = [:red :green :blue], fillalpha = [0.2 0.3 0.4])
+```
+""" areaplot
+
+@doc """
+    lens!([plot,] x, y, inset = (sp_index, bbox(x1, x2, y1, y2)))
+
+Magnify a region of a plot given by `x` and `y`.
+`sp_index` is the index of the subplot and `x1`, `x2`, `y1` and `y2` should be between `0` and `1`.
+""" lens!
@specialize
--- a/src/utils.jl
+++ b/src/utils.jl
@ -377,8 +377,7 @@ nanappend!(a::AbstractVector, b) = (push!(a, NaN); append!(a, b))
 function nansplit(v::AVec)
    vs = Vector{eltype(v)}[]
    while true
-        idx = findfirst(isnan, v)
-        if idx <= 0
+        if (idx = findfirst(isnan, v)) === nothing
            # no nans
            push!(vs, v)
            break
@ -986,7 +985,14 @@ titlefont(sp::Subplot) = font(;
    color = sp[:titlefontcolor],
 )

-legendfont(sp::Subplot) = sp[:legend_font]
+legendfont(sp::Subplot) = font(;
+    family = sp[:legend_font_family],
+    pointsize = sp[:legend_font_pointsize],
+    valign = sp[:legend_font_valign],
+    halign = sp[:legend_font_halign],
+    rotation = sp[:legend_font_rotation],
+    color = sp[:legend_font_color],
+)

 legendtitlefont(sp::Subplot) = font(;
    family = sp[:legend_title_font_family],
--- a/test/imgcomp.jl
+++ b/test/imgcomp.jl
@ -13,7 +13,6 @@ function replace_rand!(ex::Expr)
 end
 function fix_rand!(ex)
    replace_rand!(ex)
-    pushfirst!(ex.args[1].args, :(rng = StableRNG(PLOTS_SEED)))
 end

 function image_comparison_tests(
@ -39,10 +38,13 @@ function image_comparison_tests(

    # test function
    func = (fn, idx) -> begin
-        expr = Expr(:block)
-        append!(expr.args, example.exprs)
-        fix_rand!(expr)
-        eval(expr)
+        eval(:(rng = StableRNG(PLOTS_SEED)))
+        for the_expr in example.exprs
+            expr = Expr(:block)
+            push!(expr.args, the_expr)
+            fix_rand!(expr)
+            eval(expr)
+        end
        png(fn)
    end

--- a/test/runtests.jl
+++ b/test/runtests.jl
@ -37,7 +37,278 @@ end
    Plots.use_local_dependencies[] = temp
 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")],
+    )
+    for z in zipped
+        @test isequal(collect(zip(Plots.RecipesPipeline.unzip(z)...)), z)
+        @test isequal(
+            collect(zip(Plots.RecipesPipeline.unzip(GeometryBasics.Point.(z))...)),
+            z,
+        )
+    end
+    op1 = Plots.process_clims((1.0, 2.0))
+    op2 = Plots.process_clims((1, 2.0))
+    data = randn(100, 100)
+    @test op1(data) == op2(data)
+    @test Plots.process_clims(nothing) ==
+          Plots.process_clims(missing) ==
+          Plots.process_clims(:auto)
+
+    @test (==)(
+        Plots.texmath2unicode(
+            raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$",
+        ),
+        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²",
+    )
+
+    @test Plots.isvector([1, 2])
+    @test !Plots.isvector(nothing)
+    @test Plots.ismatrix([1 2; 3 4])
+    @test !Plots.ismatrix(nothing)
+    @test Plots.isscalar(1.0)
+    @test !Plots.isscalar(nothing)
+    @test Plots.tovec([]) isa AbstractVector
+    @test Plots.tovec(nothing) isa AbstractVector
+    @test Plots.anynan(1, 3, (1, NaN, 3))
+    @test Plots.allnan(1, 2, (NaN, NaN, 1))
+    @test Plots.makevec([]) isa AbstractVector
+    @test Plots.makevec(1) isa AbstractVector
+    @test Plots.maketuple(1) == (1, 1)
+    @test Plots.maketuple((1, 1)) == (1, 1)
+    @test Plots.ok(1, 2)
+    @test !Plots.ok(1, 2, NaN)
+    @test Plots.ok((1, 2, 3))
+    @test !Plots.ok((1, 2, NaN))
+    @test Plots.nansplit([1, 2, NaN, 3, 4]) == [[1.0, 2.0], [3.0, 4.0]]
+    @test Plots.nanvcat([1, NaN]) |> length == 4
+
+    @test Plots.nop() === nothing
+    @test_throws ErrorException Plots.notimpl()
+
+    @test Plots.inch2px(1) isa AbstractFloat
+    @test Plots.px2inch(1) isa AbstractFloat
+    @test Plots.inch2mm(1) isa AbstractFloat
+    @test Plots.mm2inch(1) isa AbstractFloat
+    @test Plots.px2mm(1) isa AbstractFloat
+    @test Plots.mm2px(1) isa AbstractFloat
+
+    p = plot()
+    @test xlims() isa Tuple
+    @test ylims() isa Tuple
+    @test zlims() isa Tuple
+
+    Plots.makekw(foo = 1, bar = 2) isa Dict
+
+    @test_throws ErrorException Plots.inline()
+    @test_throws ErrorException Plots._do_plot_show(plot(), :inline)
+    @test_throws ErrorException Plots.dumpcallstack()
+
+    Plots.debugplots(true)
+    Plots.debugplots(false)
+    Plots.debugshow(devnull, nothing)
+    Plots.debugshow(devnull, [1])
+
+    p = plot(1)
+    push!(p, 1.5)
+    push!(p, 1, 1.5)
+    # append!(p, [1., 2.])
+    append!(p, 1, 2.5, 2.5)
+    push!(p, (1.5, 2.5))
+    push!(p, 1, (1.5, 2.5))
+    append!(p, (1.5, 2.5))
+    append!(p, 1, (1.5, 2.5))
+
+    p = plot([1, 2, 3], [4, 5, 6])
+    @test Plots.xmin(p) == 1
+    @test Plots.xmax(p) == 3
+    @test Plots.ignorenan_extrema(p) == (1, 3)
+
+    @test Plots.get_attr_symbol(:x, "lims") == :xlims
+    @test Plots.get_attr_symbol(:x, :lims) == :xlims
+
+    @testset "NaN-separated Segments" begin
+        segments(args...) = collect(iter_segments(args...))
+
+        nan10 = fill(NaN, 10)
+        @test segments(11:20) == [1:10]
+        @test segments([NaN]) == []
+        @test segments(nan10) == []
+        @test segments([nan10; 1:5]) == [11:15]
+        @test segments([1:5; nan10]) == [1:5]
+        @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
+        @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
+        @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
+    end
+end
+
+@testset "Axes" begin
+    p = plot()
+    axis = p.subplots[1][:xaxis]
+    @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 axis[:discrete_map] == Dict{Any,Any}(:yo => 2, "HI" => 1)
+
+    Plots.discrete_value!(axis, ["x$i" for i in 1:5])
+    Plots.discrete_value!(axis, ["x$i" for i in 0:2])
+    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
+end
+
+@testset "NoFail" begin
+    # ensure backend with tested display
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
+
+    dsp = TextDisplay(IOContext(IOBuffer(), :color => true))
+
+    @testset "plot" begin
+        for plt in [
+            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]),
+        ]
+            display(dsp, plt)
+        end
+        @test_nowarn plot(x -> x^2, 0, 2)
+    end
+
+    @testset "bar" begin
+        p = bar([3, 2, 1], [1, 2, 3])
+        @test p isa Plots.Plot
+        @test display(dsp, p) isa Nothing
+    end
+
+    @testset "gui" begin
+        open(tempname(), "w") do io
+            redirect_stdout(io) do
+                gui(plot())
+            end
+        end
+    end
+end
+
+@testset "Coverage" begin
+    @testset "themes" begin
+        p = showtheme(:dark)
+        @test p isa Plots.Plot
+    end
+
+    @testset "plotattr" begin
+        tmp = tempname()
+        open(tmp, "w") do io
+            redirect_stdout(io) do
+                plotattr("seriestype")
+                plotattr(:Plot)
+                plotattr()
+            end
+        end
+        str = join(readlines(tmp), "")
+        @test occursin("seriestype", str)
+        @test occursin("Plot attributes", str)
+    end
+
+    @testset "legend" begin
+        @test isa(
+            Plots.legend_pos_from_angle(20, 0.0, 0.5, 1.0, 0.0, 0.5, 1.0),
+            NTuple{2,<:AbstractFloat},
+        )
+        @test Plots.legend_anchor_index(-1) == 1
+        @test Plots.legend_anchor_index(+0) == 2
+        @test Plots.legend_anchor_index(+1) == 3
+
+        @test Plots.legend_angle(:foo_bar) == (45, :inner)
+        @test Plots.legend_angle(20.0) ==
+              Plots.legend_angle((20.0, :inner)) ==
+              (20.0, :inner)
+        @test Plots.legend_angle((20.0, 10.0)) == (20.0, 10.0)
+    end
+end
+
+@testset "Output" begin
+    @test Plots.defaultOutputFormat(plot()) == "png"
+    @test Plots.addExtension("foo", "bar") == "foo.bar"
+
+    fn = tempname()
+    gr()
+    let p = plot()
+        Plots.png(p, fn)
+        Plots.png(fn)
+        savefig(p, "$fn.png")
+        savefig("$fn.png")
+
+        Plots.pdf(p, fn)
+        Plots.pdf(fn)
+        savefig(p, "$fn.pdf")
+        savefig("$fn.pdf")
+
+        Plots.ps(p, fn)
+        Plots.ps(fn)
+        savefig(p, "$fn.ps")
+        savefig("$fn.ps")
+
+        Plots.svg(p, fn)
+        Plots.svg(fn)
+        savefig(p, "$fn.svg")
+        savefig("$fn.svg")
+    end
+
+    if Sys.islinux()
+        pgfplotsx()
+        let p = plot()
+            Plots.tex(p, fn)
+            Plots.tex(fn)
+            savefig(p, "$fn.tex")
+            savefig("$fn.tex")
+        end
+    end
+
+    unicodeplots()
+    let p = plot()
+        Plots.txt(p, fn)
+        Plots.txt(fn)
+        savefig(p, "$fn.txt")
+        savefig("$fn.txt")
+    end
+
+    plotlyjs()
+    let p = plot()
+        Plots.html(p, fn)
+        Plots.html(fn)
+        savefig(p, "$fn.html")
+        savefig("$fn.html")
+
+        if Sys.islinux()
+            Plots.eps(p, fn)
+            Plots.eps(fn)
+            savefig(p, "$fn.eps")
+            savefig("$fn.eps")
+        end
+    end
+
+    @test_throws ErrorException savefig("$fn.foo")
+end
+
+gr()  # reset to default backend
+
 for fn in (
+    "test_args.jl",
    "test_defaults.jl",
    "test_pipeline.jl",
    "test_axes.jl",
@ -51,6 +322,7 @@ for fn in (
    "test_hdf5plots.jl",
    "test_pgfplotsx.jl",
    "test_plotly.jl",
+    "test_animations.jl",
 )
    @testset "$fn" begin
        include(fn)
@ -91,7 +363,10 @@ Random.seed!(PLOTS_SEED)
 default(show = false, reuse = true)  # don't actually show the plots

 is_ci() = get(ENV, "CI", "false") == "true"
-const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4" : "1e-5"))
+const PLOTS_IMG_TOL = parse(
+    Float64,
+    get(ENV, "PLOTS_IMG_TOL", is_ci() ? Sys.iswindows() ? "2e-4" : "1e-4" : "1e-5"),
+)

 ## Uncomment the following lines to update reference images for different backends

@ -116,106 +391,29 @@ const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4"

 ##

-@testset "Axes" begin
-    p = plot()
-    axis = p.subplots[1][:xaxis]
-    @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 axis[:discrete_map] == Dict{Any,Any}(:yo => 2, "HI" => 1)
-
-    Plots.discrete_value!(axis, ["x$i" for i in 1:5])
-    Plots.discrete_value!(axis, ["x$i" for i in 0:2])
-    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
-end
-
-@testset "NoFail" begin
-    # ensure backend with tested display
-    @test unicodeplots() == Plots.UnicodePlotsBackend()
-    @test backend() == Plots.UnicodePlotsBackend()
-
-    dsp = TextDisplay(IOContext(IOBuffer(), :color => true))
-
-    @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(dsp, plt)
-        end
-        @test_nowarn plot(x -> x^2, 0, 2)
-    end
-
-    @testset "Bar" begin
-        p = bar([3, 2, 1], [1, 2, 3])
-        @test p isa Plots.Plot
-        @test display(dsp, p) isa Nothing
-    end
-end
-
-@testset "EmptyAnim" begin
-    anim = @animate for i in []
-    end
-
-    @test_throws ArgumentError gif(anim)
-end
-
-@testset "NaN-separated Segments" begin
-    segments(args...) = collect(iter_segments(args...))
-
-    nan10 = fill(NaN, 10)
-    @test segments(11:20) == [1:10]
-    @test segments([NaN]) == []
-    @test segments(nan10) == []
-    @test segments([nan10; 1:5]) == [11:15]
-    @test segments([1:5; nan10]) == [1:5]
-    @test segments([nan10; 1:5; nan10; 1:5; nan10]) == [11:15, 26:30]
-    @test segments([NaN; 1], 1:10) == [2:2, 4:4, 6:6, 8:8, 10:10]
-    @test segments([nan10; 1:15], [1:15; nan10]) == [11:15]
-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")],
-    )
-    for z in zipped
-        @test isequal(collect(zip(Plots.RecipesPipeline.unzip(z)...)), z)
-        @test isequal(
-            collect(zip(Plots.RecipesPipeline.unzip(GeometryBasics.Point.(z))...)),
-            z,
+@testset "Examples" begin
+    if Sys.islinux()
+        backends = (
+            :unicodeplots,
+            :pgfplotsx,
+            :inspectdr,
+            :plotlyjs,
+            :gaston,
+            # :pyplot,  # FIXME: fails with system matplotlib
        )
+        only = setdiff(
+            1:length(Plots._examples),
+            (Plots._backend_skips[be] for be in backends)...,
+        )
+        for be in backends
+            @info be
+            for (i, p) in Plots.test_examples(be, only = only, disp = false)
+                fn = tempname() * ".png"
+                png(p, fn)
+                @test filesize(fn) > 1_000
+            end
+        end
    end
-    op1 = Plots.process_clims((1.0, 2.0))
-    op2 = Plots.process_clims((1, 2.0))
-    data = randn(100, 100)
-    @test op1(data) == op2(data)
-    @test Plots.process_clims(nothing) ==
-          Plots.process_clims(missing) ==
-          Plots.process_clims(:auto)
-
-    @test (==)(
-        Plots.texmath2unicode(
-            raw"Equation $y = \alpha \cdot x + \beta$ and eqn $y = \sin(x)^2$",
-        ),
-        raw"Equation y = α ⋅ x + β and eqn y = sin(x)²",
-    )
 end

@testset "Backends" begin
@ -229,33 +427,32 @@ end
        p = plot(rand(10))
        @test p isa Plots.Plot
        @test show(io, p) isa Nothing
+
        p = bar(randn(10))
        @test p isa Plots.Plot
        @test show(io, p) isa Nothing
+
        p = plot([1, 2], [3, 4])
        annotate!(p, [(1.5, 3.2, Plots.text("Test", :red, :center))])
        hline!(p, [3.1])
        @test p isa Plots.Plot
        @test show(io, p) isa Nothing
+
        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
        hline!(p, [3.1])
        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
        @test p isa Plots.Plot
        @test show(io, p) isa Nothing
+
        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, :auto)])
        hline!(p, [3.1])
        @test p isa Plots.Plot
        @test show(io, p) isa Nothing
-    end

-    @testset "PlotlyJS" begin
-        @test plotlyjs() == Plots.PlotlyJSBackend()
-        @test backend() == Plots.PlotlyJSBackend()
-
-        p = plot(rand(10))
+        p = plot((plot(i) for i in 1:4)..., layout = (2, 2))
        @test p isa Plots.Plot
-        @test_broken display(p) isa Nothing
+        @test show(io, p) isa Nothing
    end

    @testset "GR" begin
@ -274,4 +471,13 @@ end
            )
        end
    end
+
+    @testset "PlotlyJS" begin
+        @test plotlyjs() == Plots.PlotlyJSBackend()
+        @test backend() == Plots.PlotlyJSBackend()
+
+        p = plot(rand(10))
+        @test p isa Plots.Plot
+        @test_broken display(p) isa Nothing
+    end
 end
--- a/test/test_animations.jl
+++ b/test/test_animations.jl
@ -0,0 +1,61 @@
+
+@testset "Empty anim" begin
+    anim = @animate for i in []
+    end
+    @test_throws ArgumentError gif(anim)
+end
+
+@userplot CirclePlot
+@recipe function f(cp::CirclePlot)
+    x, y, i = cp.args
+    n = length(x)
+    inds = circshift(1:n, 1 - i)
+    linewidth --> range(0, 10, length = n)
+    seriesalpha --> range(0, 1, length = n)
+    aspect_ratio --> 1
+    label --> false
+    x[inds], y[inds]
+end
+
+@testset "Circle plot" begin
+    n = 10
+    t = range(0, 2π, length = n)
+    x = sin.(t)
+    y = cos.(t)
+
+    anim = @animate for i in 1:n
+        circleplot(x, y, i)
+    end
+    @test filesize(gif(anim).filename) > 10_000
+    @test filesize(mov(anim).filename) > 10_000
+    @test filesize(mp4(anim).filename) > 10_000
+    @test filesize(webm(anim).filename) > 10_000
+
+    @gif for i in 1:n
+        circleplot(x, y, i, line_z = 1:n, cbar = false, framestyle = :zerolines)
+    end every 5
+end
+
+@testset "html" begin
+    p = plot([sin, cos], zeros(0), leg = false, xlims = (0, 2π), ylims = (-1, 1))
+    anim = Animation()
+    for x in range(0, stop = 2π, length = 10)
+        push!(p, x, Float64[sin(x), cos(x)])
+        frame(anim)
+    end
+
+    agif = gif(anim)
+    html = tempname() * ".html"
+    open(html, "w") do io
+        show(io, MIME("text/html"), agif)
+    end
+    @test filesize(html) > 10_000
+    @test showable(MIME("image/gif"), agif)
+
+    agif = mp4(anim)
+    html = tempname() * ".html"
+    open(html, "w") do io
+        show(io, MIME("text/html"), agif)
+    end
+    @test filesize(html) > 10_000
+end
--- a/test/test_args.jl
+++ b/test/test_args.jl
@ -0,0 +1,27 @@
+using Plots, Test
+
+@testset "Series Attributes" begin
+    pl = plot([[1, 2, 3], [2, 3, 4]], lw = 5)
+    @test hline!(deepcopy(pl), [1.75])[1].series_list[3][:label] ==
+          hline!(deepcopy(pl), [1.75], z_order = :front)[1].series_list[3][:label] ==
+          "y3"
+    @test hline!(deepcopy(pl), [1.75], z_order = :back)[1].series_list[1][:label] == "y3"
+    @test hline!(deepcopy(pl), [1.75], z_order = 2)[1].series_list[2][:label] == "y3"
+end
+
+@testset "Axis Attributes" begin
+    pl = @test_nowarn plot(; tickfont = font(10, "Times"))
+    for axis in (:xaxis, :yaxis, :zaxis)
+        @test pl[1][axis][:tickfontsize] == 10
+        @test pl[1][axis][:tickfontfamily] == "Times"
+    end
+end
+
+@testset "Permute recipes" begin
+    pl = bar(["a", "b", "c"], [1, 2, 3])
+    ppl = bar(["a", "b", "c"], [1, 2, 3], permute = (:x, :y))
+    @test xticks(ppl) == yticks(pl)
+    @test yticks(ppl) == xticks(pl)
+    @test filter(isfinite, pl[1][1][:x]) == filter(isfinite, ppl[1][1][:y])
+    @test filter(isfinite, pl[1][1][:y]) == filter(isfinite, ppl[1][1][:x])
+end
--- a/test/test_components.jl
+++ b/test/test_components.jl
@ -3,6 +3,9 @@ using Plots, Test
@testset "Shapes" begin
    @testset "Type" begin
        square = Shape([(0, 0.0), (1, 0.0), (1, 1.0), (0, 1.0)])
+        @test Plots.get_xs(square) == [0, 1, 1, 0]
+        @test Plots.get_ys(square) == [0, 0, 1, 1]
+        @test Plots.vertices(square) == [(0, 0), (1, 0), (1, 1), (0, 1)]
        @test isa(square, Shape{Int64,Float64})
        @test coords(square) isa Tuple{Vector{S},Vector{T}} where {T,S}
    end
@ -58,6 +61,25 @@ using Plots, Test
        @test_nowarn p = plot(myshapes)
        @test p[1][1][:seriestype] == :shape
    end
+
+    @testset "Misc" begin
+        @test Plots.weave([1, 3], [2, 4]) == collect(1:4)
+        @test Plots.makeshape(3) isa Plots.Shape
+        @test Plots.makestar(3) isa Plots.Shape
+        @test Plots.makecross() isa Plots.Shape
+        @test Plots.makearrowhead(10.0) isa Plots.Shape
+
+        @test Plots.rotate(1.0, 2.0, 5.0, (0, 0)) isa Tuple
+
+        star = Plots.makestar(3)
+        star_scaled = Plots.scale(star, 0.5)
+
+        Plots.scale!(star, 0.5)
+        @test Plots.get_xs(star) == Plots.get_xs(star_scaled)
+        @test Plots.get_ys(star) == Plots.get_ys(star_scaled)
+
+        @test Plots.extrema_plus_buffer([1, 2], 0.1) == (0.9, 2.1)
+    end
 end

@testset "Brush" begin
@ -82,6 +104,39 @@ end
    end
 end

+@testset "Text" begin
+    t = Plots.PlotText("foo")
+    f = Plots.font()
+
+    @test Plots.PlotText(nothing).str == "nothing"
+    @test length(t) == 3
+    @test text(t).str == "foo"
+    @test text(t, f).str == "foo"
+    @test text("bar", f).str == "bar"
+    @test text(true).str == "true"
+end
+
+@testset "Annotations" begin
+    ann = Plots.series_annotations(missing)
+
+    @test Plots.series_annotations(["1" "2"; "3" "4"]) isa AbstractMatrix
+    @test Plots.series_annotations(10).strs[1].str == "10"
+    @test Plots.series_annotations(nothing) === nothing
+    @test Plots.series_annotations(ann) == ann
+
+    @test Plots.annotations(["1" "2"; "3" "4"]) isa AbstractMatrix
+    @test Plots.annotations(ann) == ann
+    @test Plots.annotations([ann]) == [ann]
+    @test Plots.annotations(nothing) == []
+
+    t = Plots.text("foo")
+    sp = plot(1)[1]
+    @test Plots.locate_annotation(sp, 1, 2, t) == (1, 2, t)
+    @test Plots.locate_annotation(sp, 1, 2, 3, t) == (1, 2, 3, t)
+    @test Plots.locate_annotation(sp, (0.1, 0.2), t) isa Tuple
+    @test Plots.locate_annotation(sp, (0.1, 0.2, 0.3), t) isa Tuple
+end
+
@testset "Fonts" begin
    @testset "Scaling" begin
        sizesToCheck = [
@ -158,3 +213,9 @@ end
    @test pos == (0.1, 0.5)
    @test txt.str == "(a)"
 end
+
+@testset "Bezier" begin
+    curve = Plots.BezierCurve([Plots.P2(0.0, 0.0), Plots.P2(0.5, 1.0), Plots.P2(1.0, 0.0)])
+    @test curve(0.75) == Plots.P2(0.75, 0.375)
+    @test length(coords(curve, 10)) == 10
+end
--- a/test/test_defaults.jl
+++ b/test/test_defaults.jl
@ -1,4 +1,4 @@
-using Plots, Test, Colors
+using Plots, Test, Plots.Colors

 const PLOTS_DEFAULTS = Dict(:theme => :wong2, :fontfamily => :palantino)
 Plots.__init__()
@ -93,4 +93,9 @@ end # testset
    # match mechanism
    @test sp[:legend_font_color] == sp[:foreground_color_subplot]
    @test Plots.legendfont(sp).color == sp[:foreground_color_subplot]
+
+    # magic invocation
+    @test_nowarn sp = plot(; legendfont = 12)[1]
+    @test sp[:legend_font_pointsize] == 12
+    @test Plots.legendfont(sp).pointsize == 12
 end # testset
--- a/test/test_layouts.jl
+++ b/test/test_layouts.jl
@ -32,3 +32,67 @@ end
    @test p[2][:framestyle] === :grid
    @test p[3][:framestyle] === :none
 end
+
+@testset "Coverage" begin
+    p = plot((plot(i) for i in 1:4)..., layout = (2, 2))
+
+    sp = p[end]
+    @test sp isa Plots.Subplot
+    @test size(sp) == (1, 1)
+    @test length(sp) == 1
+    @test sp[1, 1] == sp
+    @test Plots.get_subplot(p, UInt32(4)) == sp
+    @test Plots.series_list(sp) |> first |> Plots.get_subplot isa Plots.Subplot
+    @test Plots.get_subplot(p, keys(p.spmap) |> first) isa Plots.Subplot
+
+    gl = p[2, 2]
+    @test gl isa Plots.GridLayout
+    @test length(gl) == 1
+    @test size(gl) == (1, 1)
+    @test Plots.layout_args(gl) == (gl, 1)
+
+    @test size(p, 1) == 2
+    @test size(p, 2) == 2
+    @test size(p) === (2, 2)
+    @test ndims(p) == 2
+
+    @test p[1][end] isa Plots.Series
+    show(devnull, p[1])
+
+    @test Plots.getplot(p) == p
+    @test Plots.getattr(p) == p.attr
+    @test Plots.backend_object(p) == p.o
+    @test occursin("Plot", string(p))
+    print(devnull, p)
+
+    @test Plots.to_pixels(1Plots.mm) isa AbstractFloat
+    @test Plots.ispositive(1Plots.mm)
+    @test size(Plots.defaultbox) == (0Plots.mm, 0Plots.mm)
+    show(devnull, Plots.defaultbox)
+    show(devnull, p.layout)
+
+    @test Plots.make_measure_hor(1Plots.mm) == 1Plots.mm
+    @test Plots.make_measure_vert(1Plots.mm) == 1Plots.mm
+
+    @test Plots.parent(p.layout) isa Plots.RootLayout
+    show(devnull, Plots.parent_bbox(p.layout))
+
+    rl = Plots.RootLayout()
+    show(devnull, rl)
+    @test parent(rl) === nothing
+    @test Plots.parent_bbox(rl) == Plots.defaultbox
+    @test Plots.bbox(rl) == Plots.defaultbox
+
+    el = Plots.EmptyLayout()
+    @test Plots.update_position!(el) === nothing
+    @test size(el) == (0, 0)
+    @test length(el) == 0
+    @test el[1, 1] === nothing
+
+    @test Plots.left(el) == 0Plots.mm
+    @test Plots.top(el) == 0Plots.mm
+    @test Plots.right(el) == 0Plots.mm
+    @test Plots.bottom(el) == 0Plots.mm
+
+    @test_throws ErrorException Plots.layout_args(nothing)
+end
--- a/test/test_pgfplotsx.jl
+++ b/test/test_pgfplotsx.jl
@ -21,16 +21,19 @@ end
    @test !haskey(axis.contents[1].options.dict, "fill")

    @testset "Legends" begin
-        legends_plot = plot(rand(5, 2), lab = ["1" ""])
+        legends_plot = plot(rand(5, 2), lab = ["1" ""], arrow = true)
        scatter!(legends_plot, rand(5))
        Plots._update_plot_object(legends_plot)
        axis_contents = Plots.pgfx_axes(legends_plot.o)[1].contents
        leg_entries = filter(x -> x isa PGFPlotsX.LegendEntry, axis_contents)
        series = filter(x -> x isa PGFPlotsX.Plot, axis_contents)
        @test length(leg_entries) == 2
+        @test length(series) == 5
        @test !haskey(series[1].options.dict, "forget plot")
        @test haskey(series[2].options.dict, "forget plot")
-        @test !haskey(series[3].options.dict, "forget plot")
+        @test haskey(series[3].options.dict, "forget plot")
+        @test haskey(series[4].options.dict, "forget plot")
+        @test !haskey(series[5].options.dict, "forget plot")
    end # testset

    @testset "3D docs example" begin
--- a/test/test_pipeline.jl
+++ b/test/test_pipeline.jl
@ -32,5 +32,7 @@ end
            @test plot(data4; NamedTuple{tuple(attribute)}(Ref(mat))...)[1][i][attribute] ==
                  [2(i - 1) + 1, 2i]
        end
+        @test plot(data4, ribbon = (mat, mat))[1][i][:ribbon] ==
+              ([2(i - 1) + 1, 2i], [2(i - 1) + 1, 2i])
    end
 end
--- a/test/test_plotly.jl
+++ b/test/test_plotly.jl
@ -55,4 +55,10 @@ using Plots, Test
            end
        end
    end
+    @testset "Extra kwargs" begin
+        pl = plot(1:5, test = "me")
+        @test Plots.plotly_series(pl)[1][:test] == "me"
+        pl = plot(1:5, test = "me", extra_kwargs = :plot)
+        @test Plots.plotly_layout(pl)[:test] == "me"
+    end
 end
--- a/test/test_shorthands.jl
+++ b/test/test_shorthands.jl
@ -7,42 +7,132 @@ using Plots, Test
        xlims!((1, 20))
        @test xlims(p) == (1, 20)

+        xlims!(p, (1, 21))
+        @test xlims(p) == (1, 21)
+
        ylims!((-1, 1))
        @test ylims(p) == (-1, 1)

+        ylims!(p, (-2, 2))
+        @test ylims(p) == (-2, 2)
+
        zlims!((-1, 1))
        @test zlims(p) == (-1, 1)

+        zlims!(p, (-2, 2))
+        @test zlims(p) == (-2, 2)
+
        xlims!(-1, 11)
        @test xlims(p) == (-1, 11)

+        xlims!(p, -2, 12)
+        @test xlims(p) == (-2, 12)
+
        ylims!((-10, 10))
        @test ylims(p) == (-10, 10)

+        ylims!(p, (-11, 9))
+        @test ylims(p) == (-11, 9)
+
        zlims!((-10, 10))
        @test zlims(p) == (-10, 10)
+
+        zlims!(p, (-9, 8))
+        @test zlims(p) == (-9, 8)
+    end
+
+    @testset "Set Title / Labels" begin
+        p = plot()
+        title!(p, "Foo")
+        sp = p[1]
+        @test sp[:title] == "Foo"
+        xlabel!(p, "xlabel")
+        @test sp[:xaxis][:guide] == "xlabel"
+        ylabel!(p, "ylabel")
+        @test sp[:yaxis][:guide] == "ylabel"
+    end
+
+    @testset "Misc" begin
+        p = plot()
+        sp = p[1]
+
+        xflip!(p)
+        @test sp[:xaxis][:flip]
+
+        yflip!(p)
+        @test sp[:yaxis][:flip]
+
+        xgrid!(p, true)
+        @test sp[:xaxis][:grid]
+
+        xgrid!(p, false)
+        @test !sp[:xaxis][:grid]
+
+        ygrid!(p, true)
+        @test sp[:yaxis][:grid]
+
+        ygrid!(p, false)
+        @test !sp[:yaxis][:grid]
+
+        ann = [(7, 3, "(7,3)"), (3, 7, text("hey", 14, :left, :top, :green))]
+        annotate!(p, ann)
+        annotate!(p, ann...)
+
+        xaxis!(p, true)
+        @test sp[:xaxis][:showaxis]
+
+        xaxis!(p, false)
+        @test !sp[:xaxis][:showaxis]
+
+        yaxis!(p, true)
+        @test sp[:yaxis][:showaxis]
+
+        yaxis!(p, false)
+        @test !sp[:yaxis][:showaxis]
+
+        p = plot3d([1, 2], [1, 2], [1, 2])
+        plot3d!(p, [3, 4], [3, 4], [3, 4])
+        @test Plots.series_list(p[1])[1][:seriestype] == :path3d
    end

    @testset "Set Ticks" begin
        p = plot([0, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+        sp = p[1]

        xticks = 2:6
        xticks!(xticks)
-        @test Plots.get_subplot(current(), 1).attr[:xaxis][:ticks] == xticks
+        @test sp.attr[:xaxis][:ticks] == xticks
+
+        xticks = 1:5
+        xticks!(p, xticks)
+        @test sp.attr[:xaxis][:ticks] == xticks

        yticks = 0.2:0.1:0.7
        yticks!(yticks)
-        @test Plots.get_subplot(current(), 1).attr[:yaxis][:ticks] == yticks
+        @test sp.attr[:yaxis][:ticks] == yticks
+
+        yticks = 0.1:0.5
+        yticks!(p, yticks)
+        @test sp.attr[:yaxis][:ticks] == yticks

        xticks = [5, 6, 7.5]
        xlabels = ["a", "b", "c"]
-
        xticks!(xticks, xlabels)
-        @test Plots.get_subplot(current(), 1).attr[:xaxis][:ticks] == (xticks, xlabels)
+        @test sp.attr[:xaxis][:ticks] == (xticks, xlabels)
+
+        xticks = [5, 2]
+        xlabels = ["b", "a"]
+        xticks!(p, xticks, xlabels)
+        @test sp.attr[:xaxis][:ticks] == (xticks, xlabels)

        yticks = [0.5, 0.6, 0.75]
        ylabels = ["z", "y", "x"]
        yticks!(yticks, ylabels)
-        @test Plots.get_subplot(current(), 1).attr[:yaxis][:ticks] == (yticks, ylabels)
+        @test sp.attr[:yaxis][:ticks] == (yticks, ylabels)
+
+        yticks = [0.5, 0.1]
+        ylabels = ["z", "y"]
+        yticks!(p, yticks, ylabels)
+        @test sp.attr[:yaxis][:ticks] == (yticks, ylabels)
    end
 end
Author	SHA1	Message	Date
mantaohuang	2a7a1f2e2a	remove math font from tick font dict	2022-05-14 02:05:58 -04:00
github-actions[bot]	18b11a71e3	Update precompile_*.jl file [skip ci] (#4197 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-05-06 08:51:03 +02:00
Simon Christ	9e34ed0383	add permute, deprecate orientation (#4164 ) * add series_permutation * works for dates and categorical input, not vector of strings * Update src/pipeline.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * Update src/pipeline.jl Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * add test * correct test * make bar workign * add deprecation * rename series_permutation -> permute * add Documentation * fix uneccessary deprecation * permute h/vlines * Auto-format Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * 1.29.0 * Update Project.toml [skip ci] Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2022-05-05 15:15:56 +02:00
Simon Christ	561839a029	1.28.2	2022-05-05 11:40:46 +02:00
github-actions[bot]	88f2541288	Update precompile_*.jl file [skip ci] (#4194 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-05-04 21:37:19 +02:00
Simon Christ	92611ea3b4	reset marker_z for errorbars (#4193 ) * reset marker_z for errorbars * also reset line_z	2022-05-04 16:58:23 +02:00
Simon Christ	3e1bad0971	Update SnoopCompile.yml	2022-05-04 14:14:48 +02:00
Simon Christ	a13d4d8554	1.28.1	2022-05-02 17:11:46 +02:00
Jeremiah	b76dc2d7a3	quarto pdf fix? (#4188 )	2022-05-02 14:25:17 +02:00
zhiyuanzhai	137d339e0b	Fixing the colorbar title for colorbars on the top. (#4191 ) * To fix #4183. * Providing my information according to #3503.	2022-05-02 11:00:50 +02:00
Simon Christ	e06143ce33	fix #4190	2022-05-02 09:28:55 +02:00
Simon Christ	06220420a3	1.28.0	2022-04-29 12:57:16 +02:00
Simon Christ	d8da3c60d9	update anshul's data	2022-04-28 09:05:49 +02:00
t-bltg	9e92ada61a	Update examples.jl	2022-04-26 16:29:08 +02:00
t-bltg	cebca5174b	UnicodePlots: support `polarplot` (#4185 )	2022-04-26 15:36:23 +02:00
Stephan Antholzer	e3e86aa6cd	merge series extra_kwargs for plotly_series (#4172 )	2022-04-22 11:12:55 +02:00
Simon Christ	add8364bbd	1.27.6	2022-04-20 17:39:10 +02:00
github-actions[bot]	09abf2e40f	Update precompile_*.jl file [skip ci] (#4174 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-04-20 09:12:50 +02:00
Benoit Pasquier	182d4683e6	Add areaplot example to gallery (#4178 ) * Add areaplot example to gallery Not sure this is the right way to add example to the gallery but hopefully this is helpful :) * format files Co-authored-by: Simon Christ <SimonChrist@gmx.de>	2022-04-19 16:03:50 +02:00
t-bltg	a681f3e307	Update SnoopCompile.yml	2022-04-16 15:17:41 +02:00
t-bltg	1c59b19343	Update SnoopCompile.yml	2022-04-16 15:13:29 +02:00
t-bltg	6773666549	Update SnoopCompile.yml	2022-04-16 14:59:00 +02:00
t-bltg	42bf100ad3	Update precompile_Plots.jl	2022-04-16 14:53:10 +02:00
t-bltg	e826c87114	Update SnoopCompile.yml	2022-04-16 14:27:59 +02:00
Jeff Bezanson	616d72476a	Add version check for `1.8` precompiles (#4179 ) Co-authored-by: t-bltg <tf.bltg@gmail.com>	2022-04-14 13:32:59 +02:00
Simon Christ	4f9a708f66	fix empty segments in plotly (#4177 ) * fix empty segment case * fix failure on 1.6	2022-04-08 16:39:37 +02:00
t-bltg	4b73b8b5d5	Update docs build (#4175 )	2022-04-05 20:08:31 +02:00
t-bltg	99ad317590	1.27.5	2022-04-05 16:27:46 +02:00
github-actions[bot]	90975d95f8	Update precompile_*.jl file [skip ci] (#4173 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2022-04-05 16:27:15 +02:00
t-bltg	f0a1ef8a0c	Update gaston.jl	2022-04-05 15:26:17 +02:00
t-bltg	49aee2d204	Update unicodeplots.jl	2022-04-05 15:02:56 +02:00
t-bltg	02351a45b4	`UnicodePlots`: rework `png` output (#4171 )	2022-04-05 14:56:47 +02:00
Simon Christ	e691a42b90	add docs to scale, rotate	2022-04-05 14:52:51 +02:00
Simon Christ	8a584ceab4	add/ rearrange docstrings	2022-04-05 13:43:19 +02:00
t-bltg	cc1bd28ccd	Disable warnings on experimental backends (#4169 )	2022-04-05 00:52:49 +02:00
t-bltg	4446a63135	Update docs CI (font)	2022-04-05 00:15:39 +02:00
github-actions[bot]	412a8993ad	Update precompile_*.jl file [skip ci] (#4167 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2022-04-05 00:03:07 +02:00
Fons van der Plas	d9fb8b8ef3	Remove `Main.Plots` dependency (#4168 )	2022-04-04 23:36:52 +02:00
github-actions[bot]	37eb1db8d2	Update precompile_*.jl file [skip ci] (#4165 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-04-04 18:14:58 +02:00
t-bltg	dc3e3176f2	`UnicodePlots`: fix internal change	2022-04-04 18:10:58 +02:00
github-actions[bot]	2cd3331f30	Update precompile_*.jl file [skip ci] (#4163 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-04-01 11:22:07 +02:00
github-actions[bot]	db932d62f6	CompatHelper: bump compat for PlotThemes to 3, (keep existing compat) (#4162 ) Co-authored-by: CompatHelper Julia <compathelper_noreply@julialang.org>	2022-04-01 11:17:47 +02:00
Simon Christ	caf4d1857c	1.27.4	2022-03-30 16:35:47 +02:00
github-actions[bot]	bbde8ad1b1	Update precompile_*.jl file [skip ci] (#4154 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-30 15:43:45 +02:00
Simon Christ	d3449331c9	remove Shape from _pgfplotsx_marker	2022-03-30 15:38:11 +02:00
Ian Butterworth	eb746d1641	Sort supported args (#4156 ) * sort supported args * Update src/args.jl * sort all supported* functions Co-authored-by: Simon Christ <SimonChrist@gmx.de>	2022-03-29 17:42:23 +02:00
Steve Leung	a33c0205b2	Restored plotly hover functionality for plots with multidimensional data (#4159 ) * Restored hover functionality for plots with multidimensional data * Renamed plotly_hover!() to plotly_adjust_hover_label!() * Updated contributors list * Update src/backends/plotly.jl [skip ci] Co-authored-by: t-bltg <tf.bltg@gmail.com> Co-authored-by: Simon Christ <SimonChrist@gmx.de> Co-authored-by: t-bltg <tf.bltg@gmail.com>	2022-03-29 17:42:01 +02:00
Simon Christ	65ab68c3b5	fix legends for arrows (#4161 ) * fix legends for arrows * Apply suggestions from code review [skip ci] Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> * raise tolerance on windows * Update test/runtests.jl [skip ci] Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2022-03-29 17:41:25 +02:00
t-bltg	0f4a0c7154	fix examples	2022-03-27 12:09:54 +02:00
t-bltg	02d08beb1e	improve coverage (#4155 )	2022-03-27 01:42:05 +01:00
Simon Christ	d3817796a4	1.27.3	2022-03-25 17:41:01 +01:00
Simon Christ	dbe81dabd5	fix #4151 (#4153 ) * letter and Set the consts * use julia-code-style-suggesters * remove superfluous name * edit by copy of code-style-suggesters * delete stuff * remove using * Apply suggestions from code review Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	2022-03-25 17:39:54 +01:00
t-bltg	5c2cc926a6	`docs`: more verbosity	2022-03-24 13:13:38 +01:00
t-bltg	bcc66caf7d	1.27.2 [skip ci]	2022-03-23 20:07:36 +01:00
t-bltg	0686461686	UnicodePlots: `png` output (#4149 )	2022-03-23 20:06:57 +01:00
github-actions[bot]	5c4fbc5e1a	Update precompile_*.jl file [skip ci] (#4143 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-22 10:35:19 +01:00
Simon Christ	5872bdefc4	1.27.1	2022-03-17 14:02:50 +01:00
Simon Christ	a4849da775	format [skip ci]	2022-03-17 12:07:54 +01:00
Simon Christ	afe24f46bc	fix example 25	2022-03-17 12:04:47 +01:00
Simon Christ	79638b7789	Update examples.jl	2022-03-17 09:12:02 +01:00
github-actions[bot]	e82e95c8e3	Update precompile_*.jl file [skip ci] (#4140 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-17 09:05:56 +01:00
Simon Christ	843226bfe1	Revert "annotations over marksers in pgfplotsx backend (#3957 )" (#4142 ) This reverts commit 06bc99ef68dca50fd3f91cadff0b5d210ad3fdbf.	2022-03-17 09:05:29 +01:00
Simon Christ	317bfc918a	1.27.0	2022-03-11 20:52:22 +01:00
Simon Christ	4665f5caab	fix compat check	2022-03-11 20:51:43 +01:00
Simon Christ	1520705fa7	add z_order (#4139 ) * add z_order * format * add missing , * fix testss * this time for real * format [skip ci]	2022-03-11 15:57:06 +01:00
Simon Christ	b60cf3cc53	1.26.1 [skip ci]	2022-03-11 11:35:22 +01:00
Simon Christ	092fb67017	Actually check if the loaded backend version mets the compat entries (#4137 ) * implement checking backend compat * format * handle backends without compat entry * get version for julia 1.6	2022-03-11 10:49:40 +01:00
github-actions[bot]	4ebadb7612	Update precompile_*.jl file [skip ci] (#4132 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-07 11:23:57 +01:00
Simon Christ	fcd3246e4a	Update .zenodo.json	2022-03-04 13:36:14 +01:00
Simon Christ	5f858fe6f6	1.26.0	2022-03-02 09:45:32 +01:00
github-actions[bot]	8a4aea1fc7	Update precompile_*.jl file [skip ci] (#4126 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-02 09:44:48 +01:00
Simon Christ	3483799cfc	add compat entries (#4122 )	2022-03-01 16:36:41 +01:00
Simon Christ	a5f52be5c2	1.25.12	2022-03-01 15:38:29 +01:00
t-bltg	2b7e304c7e	revert constant legend box (#4117 )	2022-03-01 14:53:45 +01:00
github-actions[bot]	6c77801835	Update precompile_*.jl file [skip ci] (#4124 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-03-01 14:28:27 +01:00
Simon Christ	b34f8b87c1	check loaded_modules instead of Main for warnings about StatsPlots recipes (#4123 ) * check loaded_modules instead of Main * format	2022-03-01 09:23:10 +01:00
github-actions[bot]	5130da5a40	Update precompile_*.jl file [skip ci] (#4121 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-02-26 18:26:28 +01:00
Simon Christ	95fd48ed9b	Bbs/legendfontx (#4119 ) * revert legendfont being determant * format * fix precompiles	2022-02-26 17:26:14 +01:00
Simon Christ	e31d056820	1.25.11	2022-02-20 14:43:34 +01:00
github-actions[bot]	afe85207e1	Update precompile_*.jl file [skip ci] (#4110 ) Co-authored-by: BeastyBlacksmith <BeastyBlacksmith@users.noreply.github.com>	2022-02-20 14:42:57 +01:00
Simon Christ	204b2178d0	better line (#4085 )	2022-02-18 21:13:16 +01:00
Simon Christ	51358717ee	add slicing of tuples of matrices for plotattributes (#4109 ) * add slicing of tuples of matrices * remove dot * format files	2022-02-18 21:12:44 +01:00
github-actions[bot]	ed9f0bcab3	Update precompile_*.jl file [skip ci] (#4101 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2022-02-18 13:55:22 +01:00
t-bltg	d342672dd2	Allow `color` on txt io (#4102 )	2022-02-17 22:33:09 +01:00
github-actions[bot]	64d275e7cb	CompatHelper: bump compat for NaNMath to 1 (#4104 ) Co-authored-by: CompatHelper Julia <compathelper_noreply@julialang.org>	2022-02-17 15:27:00 +01:00
t-bltg	a919fe59d3	Center `:image` axes ticks (#4088 )	2022-02-16 22:05:50 +01:00