1.28.1

* To fix #4183.

* Providing my information according to #3503.

.github/workflows/SnoopCompile.yml

@@ -1,9 +1,11 @@
+# NOTE: this file should be named 'SnoopCompile.yml', cf github.com/aminya/CompileBot.jl/blob/master/src/CompileBot.jl#L57
+
 name: SnoopCompile
 
 on:
   push:
     branches:
-    #  - 'master'  # NOTE: to run the bot only on pushes to master
+      - master  # NOTE: to run the bot only on pushes to master
 
 defaults:
   run:
@@ -14,14 +16,18 @@ 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}}
     strategy:
       fail-fast: false
       matrix:
         version:   # NOTE: the versions below should match those in your botconfig
-          - '1'
+          - '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
           - ubuntu-latest
         arch:
@@ -31,13 +37,22 @@ 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: |
-          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();'
-
+          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()'
 
       # TESTCMD
       - name: Default TESTCMD
@@ -70,10 +85,8 @@ jobs:
 
       - name: CompileBot postprocess
         run: |
-          ls artifact
-          ls
-          if ! grep -m1 -q 'format' artifact/src/precompile_includer.jl; then sed -i '1 i\#! format: off' artifact/src/precompile_includer.jl; fi
-          julia -e 'using Pkg; Pkg.add( PackageSpec(name = "CompileBot", version = "1") ); using CompileBot; CompileBot.postprocess();'
+          if ! grep -m1 -q 'format: off' artifact/src/precompile_includer.jl; then sed -i '1 i\#! format: off' artifact/src/precompile_includer.jl; fi
+          julia -e 'using Pkg; Pkg.add(PackageSpec(name="CompileBot", version="1")); using CompileBot; CompileBot.postprocess()'
 
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v3
@@ -86,7 +99,6 @@ jobs:
             no changelog
           branch: "Test_SnoopCompile_AutoPR_${{ github.ref }}"
 
-
   Skip:
     if: "contains(github.event.head_commit.message, '[skip ci]')"
     runs-on: ubuntu-latest

.github/workflows/TagBot.yml

@@ -12,3 +12,4 @@ jobs:
       - uses: JuliaRegistries/TagBot@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          ssh: ${{ secrets.TAGBOT_KEY }}

.github/workflows/benchmark.yml

@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@latest
         with:
-          version: 1
+          version: '1.7'
 
       # Setup
       - name: Ubuntu TESTCMD

.github/workflows/ci.yml

@@ -2,6 +2,8 @@ name: ci
 
 on:
   push:
+    branches:
+      - master
   pull_request:
 
 defaults:
@@ -13,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 }}
@@ -22,8 +24,8 @@ jobs:
       fail-fast: false
       matrix:
         version:
-          - '1'
-          - 'nightly'
+          - '1.6' # LTS
+          - '1.7' # latest stable
         os:
           - ubuntu-latest
           - windows-latest
@@ -31,9 +33,11 @@ jobs:
         arch:
           - x64
           # - x86
+        include:
+          - version: 'nightly'
+            os: ubuntu-latest
 
     steps:
-
       # Setup environment
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@latest
@@ -51,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
@@ -78,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
 

.github/workflows/docs.yml

@@ -1,6 +1,7 @@
 name: docs
 
 on:
+ workflow_dispatch:
  push:
   branches:
     - master
@@ -8,7 +9,7 @@ on:
  
 jobs:
   Build_docs:
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
         with:
@@ -20,37 +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
-        env: 
+            ${{runner.os}}-test-${{env.cache-name}}-
+            ${{runner.os}}-test-
+            ${{runner.os}}-
+      - name: Build documentation
+        env:
           PYTHON: ""
-          DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
-        run: |
-          export JULIA_DEBUG=Documenter
-          export PLOTDOCS_ANSICOLOR=true
-          export GKSwstype=nul  # Plots.jl/issues/3664
-          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' 
+          DOCUMENTER_KEY: ${{secrets.DOCUMENTER_KEY}}
+          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+        run: bash docs/ci_build.sh

.github/workflows/format.yml.disabled

@@ -1,22 +0,0 @@
-name: format
-
-on:
-  pull_request:
-
-jobs:
-  JuliaFormatter:
-    if: "!contains(github.event.head_commit.message, '[skip ci]')"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: julia-actions/setup-julia@latest
-        with:
-          version: 1
-
-      # Check format
-      - name: Install JuliaFormatter and format
-        run: |
-          git diff --name-only --exit-code
-          julia -e 'using Pkg; pkg"add JuliaFormatter CSTParser#master"'
-          julia -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
-          git diff --exit-code

.github/workflows/format_check.yml

@@ -0,0 +1,54 @@
+name: format
+
+on:
+  pull_request:
+  push:
+    branches:
+      - 'master'
+
+jobs:
+  code-style:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@v1
+      - name: Install dependencies
+        run: |
+          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: |
+          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

.github/workflows/format_pr.yml

@@ -1,19 +1,19 @@
-name: format-pr
+name: format
 
 on:
   schedule:
-    - cron: '0 0 * * SUN'
+    - cron: '0 0 1 * *'
 
 jobs:
-  build:
+  pr:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install JuliaFormatter and format
         run: |
-          julia  -e 'using Pkg; pkg"add JuliaFormatter"'
-          julia  -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
+          julia -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          julia -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
           git diff --exit-code
 
       - name: Create Pull Request

.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"
         },
         {
@@ -702,6 +704,18 @@
             "affiliation": "Alogus Research Corporation",
             "name": "Lee Phillips",
             "type": "Other"
+        },
+        {
+            "name": "Tom Gillam",
+            "type": "Other"
+        },
+        {
+            "name": "Steve Leung",
+            "type": "Other"
+        },
+        {
+            "name": "Xu Zhi-Yuan",
+            "type": "Other"
         }
     ],
     "upload_type": "software"

NEWS.md

@@ -3,7 +3,7 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-## (current master)
+## NOTE: this file is deprecated, see the [TagBot](https://github.com/marketplace/actions/julia-tagbot) auto-generated changelogs instead
 
 ## 0.28.3
 - support generalized array interface

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.24.4"
+version = "1.28.1"
 
 [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"
@@ -31,44 +32,54 @@ Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
-UnicodeFun = "1cfade01-22cf-5700-b092-accc4b62d6e1"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+UnicodeFun = "1cfade01-22cf-5700-b092-accc4b62d6e1"
+Unzip = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d"
 
 [compat]
 Contour = "0.5"
 FFMPEG = "0.2 - 0.4"
 FixedPointNumbers = "0.6 - 0.8"
-GR = "0.62.1"
+GR = "0.64"
 GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
 Measures = "0.3"
-NaNMath = "0.3"
-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.3.5, 0.4"
+RecipesPipeline = "0.5"
 Reexport = "0.2, 1.0"
 Requires = "1"
 Scratch = "1"
 Showoff = "0.3.1, 1.0"
 StatsBase = "0.32 - 0.33"
 UnicodeFun = "0.4"
-UnicodePlots = "2.4"
-julia = "1.5"
+UnicodePlots = "2.10"
+Unzip = "0.1"
+julia = "1.6"
 
 [extras]
 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"
@@ -79,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"]

README.md

@@ -10,18 +10,18 @@
 [gitter-url]: https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
 [docs-img]: https://img.shields.io/badge/docs-stable-blue.svg
-[docs-url]: https://docs.juliaplots.org/latest/
+[docs-url]: https://docs.juliaplots.org/stable/
 
 [![][gh-ci-img]][gh-ci-url]
 [![][pkgeval-img]][pkgeval-url]
 [![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://julialang.zulipchat.com/#narrow/stream/236493-plots)
 [![][docs-img]][docs-url]
 [![Codecov](https://codecov.io/gh/JuliaPlots/Plots.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaPlots/Plots.jl)
+[![Plots Downloads](https://shields.io/endpoint?url=https://pkgs.genieframework.com/api/v1/badge/Plots)](https://pkgs.genieframework.com?packages=Plots)
 
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4725317.svg)](https://doi.org/10.5281/zenodo.4725317)
 This is the DOI for all Versions, please follow the link to get the DOI for a specific version.
 
-
 #### Created by Tom Breloff (@tbreloff)
 
 #### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)

deps/SnoopCompile/precompile/1.6/precompile_Plots.jl

@@ -0,0 +1,439 @@
+# Use
+#    @warnpcfail precompile(args...)
+# if you want to be warned when a precompile directive fails
+macro warnpcfail(ex::Expr)
+    modl = __module__
+    file = __source__.file === nothing ? "?" : String(__source__.file)
+    line = __source__.line
+    quote
+        $(esc(ex)) || @warn """precompile directive
+     $($(Expr(:quote, ex)))
+ failed. Please report an issue in $($modl) (after checking for duplicates) or remove this directive.""" _file=$file _line=$line
+    end
+end
+
+
+const __bodyfunction__ = Dict{Method,Any}()
+
+# Find keyword "body functions" (the function that contains the body
+# as written by the developer, called after all missing keyword-arguments
+# have been assigned values), in a manner that doesn't depend on
+# gensymmed names.
+# `mnokw` is the method that gets called when you invoke it without
+# supplying any keywords.
+function __lookup_kwbody__(mnokw::Method)
+    function getsym(arg)
+        isa(arg, Symbol) && return arg
+        @assert isa(arg, GlobalRef)
+        return arg.name
+    end
+
+    f = get(__bodyfunction__, mnokw, nothing)
+    if f === nothing
+        fmod = mnokw.module
+        # The lowered code for `mnokw` should look like
+        #   %1 = mkw(kwvalues..., #self#, args...)
+        #        return %1
+        # where `mkw` is the name of the "active" keyword body-function.
+        ast = Base.uncompressed_ast(mnokw)
+        if isa(ast, Core.CodeInfo) && length(ast.code) >= 2
+            callexpr = ast.code[end-1]
+            if isa(callexpr, Expr) && callexpr.head == :call
+                fsym = callexpr.args[1]
+                if isa(fsym, Symbol)
+                    f = getfield(fmod, fsym)
+                elseif isa(fsym, GlobalRef)
+                    if fsym.mod === Core && fsym.name === :_apply
+                        f = getfield(mnokw.module, getsym(callexpr.args[2]))
+                    elseif fsym.mod === Core && fsym.name === :_apply_iterate
+                        f = getfield(mnokw.module, getsym(callexpr.args[3]))
+                    else
+                        f = getfield(fsym.mod, fsym.name)
+                    end
+                else
+                    f = missing
+                end
+            else
+                f = missing
+            end
+        else
+            f = missing
+        end
+        __bodyfunction__[mnokw] = f
+    end
+    return f
+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{(: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{(: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{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(font)),NamedTuple{(:family, :pointsize, :valign, :halign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(: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}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{GRBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{PlotlyBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Irrational{:π}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Float64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{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!),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!)})
+    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}}, 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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector{T} where T}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :title, :xlabel, :ylabel, :zlabel, :legend, :margin, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, String, String, String, String, Symbol, AbsoluteLength, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill_z, :alpha, :label, :bar_width, :seriestype), Tuple{StepRange{Int64, Int64}, Vector{Float64}, String, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :legend, :seriestype), Tuple{String, Symbol, Symbol}},typeof(plot),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{Matrix{Any}, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside), Tuple{Int64, Matrix{PlotUtils.ContinuousColorGradient}, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{Matrix{Any}, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{Matrix{Any}, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xguide, :yguide, :xguidefonthalign, :yguidefontvalign, :xguideposition, :yguideposition, :ymirror, :xmirror, :legend, :seriestype), Tuple{Int64, String, String, Matrix{Symbol}, Matrix{Symbol}, Symbol, Matrix{Symbol}, Matrix{Bool}, Matrix{Bool}, Bool, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{Matrix{Any}, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Vector{Tuple{Int64, Real}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector{T} where T},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Int64,Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :markersize, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Matrix{Symbol}, Int64, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :seriestype, :label), Tuple{Symbol, Symbol, String}},typeof(plot),UnitRange{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64, Symbol}},typeof(plot),Vector{ComplexF64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m), Tuple{Symbol, Int64}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Matrix{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
+    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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{OHLC}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype), Tuple{String, Float64, Symbol}},typeof(plot),Vector{String},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xflip, :yflip, :zflip, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xmirror, :ymirror, :zmirror, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(: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})
+    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{:steppre}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{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),Base.OneTo{Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
+    Base.precompile(Tuple{typeof(_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(_plot!),Plot,Any,Any})
+    Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
+    Base.precompile(Tuple{typeof(_preprocess_binlike),DefaultsDict,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(_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_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})
+    Base.precompile(Tuple{typeof(axis_limits),Subplot{PlotlyBackend},Symbol,Bool,Bool})
+    Base.precompile(Tuple{typeof(backend),PlotlyBackend})
+    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
+    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
+    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
+    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
+    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})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,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_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_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}}})
+    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_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),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})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
+    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
+    Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
+    Base.precompile(Tuple{typeof(plot!),Any})
+    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})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},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}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Float64},Float64,Int64,Int64,Float64,Vararg{Float64, N} where N})
+    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(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})
+    Base.precompile(Tuple{typeof(title!),AbstractString})
+    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, N} where N})
+    Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
+    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_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)
+        precompile(fbody, (Any,typeof(plot!),Any,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot!, (Any,Vararg{Any, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot!),Any,Vararg{Any, N} where N,))
+    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)
+        precompile(fbody, (Any,typeof(plot),Any,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(plot, (Any,Vararg{Any, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(plot),Any,Vararg{Any, N} where N,))
+    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)
+        precompile(fbody, (Any,typeof(title!),AbstractString,))
+    end
+end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
+    if !ismissing(fbody)
+        precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
+    end
+end
+end

deps/SnoopCompile/precompile/1.7/precompile_Plots.jl

@@ -66,25 +66,34 @@ end
 
 function _precompile_()
     ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(: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{(:grid,), Tuple{Bool}},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{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
     Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
@@ -94,10 +103,18 @@ 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(lens!)),Any,typeof(lens!),Any,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :label, :seriestype), Tuple{Float64, String, Symbol}},typeof(plot!),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Vector{Int64},Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
@@ -117,7 +134,9 @@ 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!)})
@@ -125,6 +144,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:annotations, :leg), Tuple{Tuple{Int64, Float64, PlotText}, Bool}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:arrow,), Tuple{Int64}},typeof(plot),Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:aspect_ratio, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{String},Vector{String},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bar_width, :alpha, :color, :fillto, :label, :seriestype), Tuple{Float64, Float64, Vector{Symbol}, StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, String, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:bins, :weights, :seriestype), Tuple{Symbol, Vector{Int64}, Symbol}},typeof(plot),Vector{Float64}})
@@ -135,6 +155,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :legend, :seriestype), Tuple{String, Symbol, Symbol}},typeof(plot),Vector{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{Matrix{Any}, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
@@ -171,6 +192,8 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},UnitRange{Int64},Matrix{Int64}})
     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}, 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{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
@@ -189,9 +212,11 @@ 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}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{<:GeometryBasics.Point}})
     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{:barhist}},Any,Any,Any})
@@ -199,12 +224,15 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hspan}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:spy}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
     Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
@@ -212,8 +240,13 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{GRBackend},Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_axis_args!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
@@ -221,18 +254,19 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{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{Tuple{Float64, Float64, Float64}},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(_plot!),Plot,Any,Any})
     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}})
@@ -247,9 +281,12 @@ function _precompile_()
     Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
     Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
+    Base.precompile(Tuple{typeof(fakedata),TaskLocalRNG,Int64,Vararg{Int64}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(get_series_color),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
+    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}})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any}})
@@ -263,36 +300,43 @@ 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}, Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Nothing,Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
     Base.precompile(Tuple{typeof(gr_get_3d_axis_angle),Vector{Float64},Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
+    Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     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,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Symbol})
     Base.precompile(Tuple{typeof(heatmap_edges),UnitRange{Int64},Symbol})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
-    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
     Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
+    Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64, Int64}})
     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})
@@ -300,14 +344,18 @@ 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}})
     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})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
+    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
@@ -320,49 +368,82 @@ function _precompile_()
     Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Tuple{Int64, Int64},Symbol})
     Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
     Base.precompile(Tuple{typeof(quiver_using_arrows),DefaultsDict})
     Base.precompile(Tuple{typeof(resetfontsizes)})
     Base.precompile(Tuple{typeof(scalefontsizes),Float64})
     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(slice_arg),Matrix{RGBA{Float64}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},Int64})
     Base.precompile(Tuple{typeof(spy),Any})
     Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
     Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any}})
     Base.precompile(Tuple{typeof(title!),AbstractString})
-    Base.precompile(Tuple{typeof(unzip),Vector{GeometryBasics.Point2{Float64}}})
-    Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Float64, Float64, Float64}}})
-    Base.precompile(Tuple{typeof(unzip),Vector{Tuple{Vector{Float64}, Vector{Float64}}}})
-    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
     Base.precompile(Tuple{typeof(vline!),Any})
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any}})
+    Base.precompile(Tuple{typeof(xgrid!),Plot{PlotlyBackend},Symbol,Vararg{Any}})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
-    isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#124")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#124")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
-    isdefined(Plots, Symbol("#add_major_or_minor_segments#125")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#125")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64, Float64}},Float64,Bool})
-    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(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
+    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!, (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

deps/SnoopCompile/precompile/1.8/precompile_Plots.jl

@@ -0,0 +1,282 @@
+# Use
+#    @warnpcfail precompile(args...)
+# if you want to be warned when a precompile directive fails
+macro warnpcfail(ex::Expr)
+    modl = __module__
+    file = __source__.file === nothing ? "?" : String(__source__.file)
+    line = __source__.line
+    quote
+        $(esc(ex)) || @warn """precompile directive
+     $($(Expr(:quote, ex)))
+ failed. Please report an issue in $($modl) (after checking for duplicates) or remove this directive.""" _file=$file _line=$line
+    end
+end
+
+
+function _precompile_()
+    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    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}},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{(: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{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),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}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:annotation,), Tuple{Vector{Tuple{Int64, Float64, Tuple{String, Any, Any, Any}}}}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:c, :lw, :label), Tuple{Symbol, Int64, String}},typeof(plot!),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:layout, :margin), Tuple{Matrix{Any}, AbsoluteLength}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Bool}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{GRBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:line, :seriestype), Tuple{Tuple{Int64, Symbol, Float64, Matrix{Symbol}}, Symbol}},typeof(plot!),Plot{PlotlyBackend},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Function,Float64,Irrational{:π}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:lw, :color), Tuple{Int64, Symbol}},typeof(plot!),Plot{GRBackend},Function,Float64,Vararg{Any}})
+    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}, 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!),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!),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{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{(: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{(: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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:color, :line, :marker), Tuple{Matrix{Symbol}, Tuple{Symbol, Int64}, Tuple{Matrix{Symbol}, Int64, Float64, Stroke}}},typeof(plot),Vector{Vector}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:connections, :title, :xlabel, :ylabel, :zlabel, :legend, :margin, :seriestype), Tuple{Tuple{Vector{Int64}, Vector{Int64}, Vector{Int64}}, String, String, String, String, Symbol, AbsoluteLength, Symbol}},typeof(plot),Vector{Int64},Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill, :seriestype), Tuple{Bool, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:fill_z, :alpha, :label, :bar_width, :seriestype), Tuple{StepRange{Int64, Int64}, Vector{Float64}, String, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks, :seriestype), Tuple{Matrix{Symbol}, Matrix{String}, Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}}, Int64, String, Int64, UnitRange{Int64}, Symbol}},typeof(plot),Vector{Vector{Float64}},Vector{Vector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:grid, :title), Tuple{Tuple{Symbol, Symbol, Symbol, Int64, Float64}, String}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :legend, :seriestype), Tuple{String, Symbol, Symbol}},typeof(plot),Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Float64})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{Matrix{Any}, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :link), Tuple{Int64, Symbol}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :palette, :bg_inside), Tuple{Int64, Matrix{PlotUtils.ContinuousColorGradient}, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :t, :leg, :ticks, :border), Tuple{Matrix{Any}, Matrix{Symbol}, Bool, Nothing, Symbol}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :title, :titlelocation, :left_margin, :bottom_margin, :xrotation), Tuple{Matrix{Any}, Matrix{String}, Symbol, Matrix{AbsoluteLength}, AbsoluteLength, Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xguide, :yguide, :xguidefonthalign, :yguidefontvalign, :xguideposition, :yguideposition, :ymirror, :xmirror, :legend, :seriestype), Tuple{Int64, String, String, Matrix{Symbol}, Matrix{Symbol}, Symbol, Matrix{Symbol}, Matrix{Bool}, Matrix{Bool}, Bool, Matrix{Symbol}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :xlims), Tuple{Matrix{Any}, Tuple{Int64, Float64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout,), Tuple{Tuple{Int64, Int64}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:legend,), Tuple{Symbol}},typeof(plot),Vector{Tuple{Int64, Real}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :lab, :ms), Tuple{Tuple{Matrix{Symbol}, Int64}, Matrix{String}, Int64}},typeof(plot),Vector{Vector},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :label, :legendtitle), Tuple{Tuple{Int64, Matrix{Symbol}}, Matrix{String}, String}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :leg, :fill), Tuple{Int64, Bool, Tuple{Int64, Symbol}}},typeof(plot),Function,Function,Int64,Vararg{Any}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line, :marker, :bg, :fg, :xlim, :ylim, :leg), Tuple{Tuple{Int64, Symbol, Symbol}, Tuple{Shape{Float64, Float64}, Int64, RGBA{Float64}}, Symbol, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Bool}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:line_z, :linewidth, :legend), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64}, Int64, Bool}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:m, :markersize, :lab, :bg, :xlim, :ylim, :seriestype), Tuple{Matrix{Symbol}, Int64, Matrix{String}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker,), Tuple{Bool}},typeof(plot),Vector{Union{Missing, Int64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:marker_z, :color, :legend, :seriestype), Tuple{typeof(+), Symbol, Bool, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :markersize, :marker_z, :line_z, :linewidth), Tuple{Matrix{Symbol}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}, Matrix{Int64}}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:markershape, :seriestype, :label), Tuple{Symbol, Symbol, String}},typeof(plot),UnitRange{Int64},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :seriestype), Tuple{Int64, Symbol}},typeof(plot),Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio, :seriestype), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64, Symbol}},typeof(plot),Vector{ComplexF64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:proj, :m), Tuple{Symbol, Int64}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},UnitRange{Int64},Matrix{Int64}})
+    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{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{(: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}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot),Vector{OHLC}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:st, :xlabel, :ylabel, :zlabel), Tuple{Symbol, String, String, String}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :l, :seriestype), Tuple{String, Float64, Symbol}},typeof(plot),Vector{String},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xflip, :yflip, :zflip, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :xmirror, :ymirror, :zmirror, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, Bool, Bool, Bool, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title, :zlabel, :grid, :ylabel, :minorgrid, :xlabel, :seriestype), Tuple{String, String, Bool, String, Bool, String, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Function})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{GRBackend},Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:title,), Tuple{Matrix{String}}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:xaxis, :background_color, :leg), Tuple{Tuple{String, Tuple{Int64, Int64}, StepRange{Int64, Int64}, Symbol}, RGB{Float64}, Bool}},typeof(plot),Matrix{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(: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}})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bar}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:bins2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:histogram2d}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:hspan}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vspan}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:xerror}},Any,Any,Any})
+    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Vector{ComplexF64}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.add_series!),Plot{PlotlyBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{GRBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.plot_setup!),Plot{PlotlyBackend},Dict{Symbol, Any},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.preprocess_attributes!),Plot{GRBackend},DefaultsDict})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{GRBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_sliced_series_attributes!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.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(_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(_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(_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_periphery),Subplot{GRBackend},Vector{Any}})
+    Base.precompile(Tuple{typeof(_update_subplot_periphery),Subplot{PlotlyBackend},Vector{Any}})
+    Base.precompile(Tuple{typeof(annotate!),AbstractVector{<:Tuple}})
+    Base.precompile(Tuple{typeof(axis_limits),Subplot{GRBackend},Symbol,Bool,Bool})
+    Base.precompile(Tuple{typeof(axis_limits),Subplot{PlotlyBackend},Symbol,Bool,Bool})
+    Base.precompile(Tuple{typeof(backend),PlotlyBackend})
+    Base.precompile(Tuple{typeof(bbox),AbsoluteLength,AbsoluteLength,AbsoluteLength,AbsoluteLength})
+    Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
+    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
+    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}})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any}})
+    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any}})
+    Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any}})
+    Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Int64, Int64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_display),Subplot{GRBackend},AbsoluteLength,AbsoluteLength,Vector{Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}, Int64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,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_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_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_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}}})
+    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_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),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})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
+    Base.precompile(Tuple{typeof(is_marker_supported),GRBackend,Vector{Symbol}})
+    Base.precompile(Tuple{typeof(layout_args),Matrix{Any}})
+    Base.precompile(Tuple{typeof(link_axes!),GridLayout,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),StepRange{Int64, Int64},Tuple{Int64, Int64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),UnitRange{Int64},Tuple{Float64, Float64},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
+    Base.precompile(Tuple{typeof(plot!),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},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(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})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Symbol, Int64, String},Font})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{GRBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText,Font})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,PlotText})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol},Font})
+    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Int64, Symbol, Symbol}})
+    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},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
+    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(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(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})
+    Base.precompile(Tuple{typeof(update_child_bboxes!),GridLayout})
+    Base.precompile(Tuple{typeof(update_clims),Float64,Float64,SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true},typeof(ignorenan_extrema)})
+    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("#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

deps/SnoopCompile/snoop_bench.jl

@@ -1,8 +1,6 @@
-using CompileBot
+include("snoop_bot_config.jl")
 
 snoop_bench(
-    BotConfig(
-        "Plots",
-    ),
+    botconfig,
     joinpath(@__DIR__, "precompile_script.jl"),
 )

deps/SnoopCompile/snoop_bot.jl

@@ -1,8 +1,6 @@
-using CompileBot
+include("snoop_bot_config.jl")
 
 snoop_bot(
-    BotConfig(
-        "Plots",
-    ),
+    botconfig,
     joinpath(@__DIR__, "precompile_script.jl"),
 )

deps/SnoopCompile/snoop_bot_config.jl

@@ -0,0 +1,7 @@
+using CompileBot
+
+botconfig = BotConfig(
+    "Plots",
+    version = ["1.6", "1.7", "1.8", "nightly"],  # <<< keep these versions in sync with .github/workflows/SnoopCompile.yml
+    # else_version = "nightly",
+)

src/Plots.jl

@@ -1,25 +1,39 @@
 module Plots
 
+using Pkg
+
 if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@optlevel"))
     @eval Base.Experimental.@optlevel 1
 end
+if isdefined(Base, :Experimental) && isdefined(Base.Experimental, Symbol("@max_methods"))
+    @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
 
 import GeometryBasics
-using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
+using Dates, Printf, Statistics, Base64, LinearAlgebra, Random, Unzip
 using SparseArrays
 
 using FFMPEG
@@ -196,7 +210,6 @@ import RecipesPipeline:
     pop_kw!,
     scale_func,
     inverse_scale_func,
-    unzip,
     dateformatter,
     datetimeformatter,
     timeformatter

src/arg_desc.jl

@@ -52,6 +52,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)",

src/args.jl

@@ -399,6 +399,7 @@ 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)
     :extra_kwargs => Dict(),
 )
 
@@ -1058,10 +1059,14 @@ end
 # update the defaults globally
 
 """
-`default(key)` returns the current default value for that key
-`default(key, value)` sets the current default value for that key
-`default(; kw...)` will set the current default value for each key/value pair
-`default(plotattributes, key)` returns the key from  plotattributes if it exists, otherwise `default(key)`
+`default(key)` returns the current default value for that key.
+
+`default(key, value)` sets the current default value for that key.
+
+`default(; kw...)` will set the current default value for each key/value pair.
+
+`default(plotattributes, key)` returns the key from plotattributes if it exists, otherwise `default(key)`.
+
 """
 function default(k::Symbol)
     k = get(_keyAliases, k, k)
@@ -1343,7 +1348,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
@@ -1364,7 +1374,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
@@ -1483,7 +1497,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)
@@ -1571,7 +1586,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\`"
         )
@@ -1584,6 +1603,8 @@ end
 const _already_warned = Dict{Symbol,Set{Symbol}}()
 const _to_warn = Set{Symbol}()
 
+should_warn_on_unsupported(::AbstractBackend) = _plot_defaults[:warn_on_unsupported]
+
 function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
     empty!(_to_warn)
     bend = backend_name(pkg)
@@ -1601,11 +1622,11 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
     end
 
     if !isempty(_to_warn) &&
-       get(plotattributes, :warn_on_unsupported, _plot_defaults[:warn_on_unsupported])
+       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))"
+                "Keyword argument $k not supported with $pkg.  Choose from: $(join(supported_attrs(pkg), ", "))"
             )
         end
     end
@@ -1617,7 +1638,7 @@ end
 # _markershape_supported(pkg::AbstractBackend, shapes::AVec) = all([_markershape_supported(pkg, shape) for shape in shapes])
 
 function warn_on_unsupported(pkg::AbstractBackend, plotattributes)
-    if !get(plotattributes, :warn_on_unsupported, _plot_defaults[:warn_on_unsupported])
+    if !get(plotattributes, :warn_on_unsupported, should_warn_on_unsupported(pkg))
         return
     end
     if !is_seriestype_supported(pkg, plotattributes[:seriestype])
@@ -1638,13 +1659,13 @@ function warn_on_unsupported(pkg::AbstractBackend, plotattributes)
 end
 
 function warn_on_unsupported_scales(pkg::AbstractBackend, plotattributes::AKW)
-    if !get(plotattributes, :warn_on_unsupported, _plot_defaults[:warn_on_unsupported])
+    if !get(plotattributes, :warn_on_unsupported, should_warn_on_unsupported(pkg))
         return
     end
     for k in (:xscale, :yscale, :zscale, :scale)
         if haskey(plotattributes, k)
             v = plotattributes[k]
-            if !is_scale_supported(pkg, v)
+            if !all(is_scale_supported.(Ref(pkg), v))
                 @warn(
                     "scale $v is unsupported with $pkg.  Choose from: $(supported_scales(pkg))"
                 )
@@ -1742,15 +1763,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
@@ -1949,25 +1972,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))
-    )
-    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) :
-                default(plotattributes_in, lk)
-        ) for k in (:family, :pointsize, :valign, :halign, :rotation, :color)
-    )
-    sp.attr[:legend_font] = font(; merge(match_attr, f_attr)...)
-end
-
 function _update_axis(
     plt::Plot,
     sp::Subplot,
@@ -2053,7 +2057,7 @@ function _update_subplot_args(
 )
     anns = RecipesPipeline.pop_kw!(sp.attr, :annotations)
 
-    # # grab those args which apply to this subplot
+    # grab those args which apply to this subplot
     for k in keys(_subplot_defaults)
         slice_arg!(plotattributes_in, sp.attr, k, subplot_index, remove_pair)
     end

src/axes.jl

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

src/backends.jl

@@ -240,6 +240,7 @@ const _base_supported_args = [
     :discrete_values,
     :projection,
     :show_empty_bins,
+    :z_order,
 ]
 
 function merge_with_base_supported(v::AVec)
@@ -284,7 +285,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 +301,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 +348,7 @@ const _gr_attr = merge_with_base_supported([
     :fillrange,
     :fillcolor,
     :fillalpha,
+    :fillstyle,
     :bins,
     :layout,
     :title,
@@ -423,16 +437,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,
@@ -914,7 +918,7 @@ const _unicodeplots_attr = merge_with_base_supported([
     :annotations,
     :bins,
     :guide,
-    # :grid,
+    :grid,
     :label,
     :layout,
     :legend,
@@ -923,20 +927,32 @@ const _unicodeplots_attr = merge_with_base_supported([
     :linecolor,
     :linestyle,
     :markershape,
+    :quiver,
+    :arrow,
     :seriesalpha,
     :seriescolor,
     :scale,
+    :flip,
     :title,
+    # :marker_z,
+    :line_z,
 ])
 const _unicodeplots_seriestype = [
     :path,
+    :path3d,
     :scatter,
+    :scatter3d,
     :straightline,
     # :bar,
     :shape,
     :histogram2d,
     :heatmap,
+    :contour,
+    # :contour3d,
     :spy,
+    :surface,
+    :wireframe,
+    :mesh3d,
 ]
 const _unicodeplots_style = [:auto, :solid]
 const _unicodeplots_marker = [
@@ -969,9 +985,6 @@ const _unicodeplots_marker = [
 ]
 const _unicodeplots_scale = [:identity, :ln, :log2, :log10]
 
-# Additional constants
-const _canvas_type = Ref(:auto)
-
 # ------------------------------------------------------------------------------
 # hdf5
 
@@ -1308,7 +1321,6 @@ const _pgfplotsx_marker = [
     :pentagon,
     :hline,
     :vline,
-    Shape,
 ]
 const _pgfplotsx_scale = [:identity, :ln, :log2, :log10]
 is_marker_supported(::PGFPlotsXBackend, shape::Shape) = true

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

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])

src/backends/gr.jl

@@ -413,7 +413,7 @@ function gr_set_font(
             gr_font_family[family] >= 200 ? 3 : GR.TEXT_PRECISION_STRING,
         )
     end
-    gr_set_textcolor(color)
+    gr_set_textcolor(plot_color(color))
     GR.settextalign(gr_halign(halign), gr_valign(valign))
 end
 

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
 

src/backends/pgfplotsx.jl

@@ -146,7 +146,7 @@ function (pgfx_plot::PGFPlotsXPlot)(plt::Plot{PGFPlotsXBackend})
                 "point meta max" => get_clims(sp)[2],
                 "point meta min" => get_clims(sp)[1],
                 "legend cell align" => "left",
-                "legend columns" => pgfx_legend_col(sp[:legend_position]),
+                "legend columns" => pgfx_legend_col(sp[:legend_column]),
                 "title" => sp[:title],
                 "title style" => PGFPlotsX.Options(
                     pgfx_get_title_pos(title_loc)...,
@@ -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
@@ -1316,7 +1315,10 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
     end
 
     # grid on or off
-    push!(opt, "$(letter)majorgrids" => axis[:grid] && framestyle != :none ? "true" : "false")
+    push!(
+        opt,
+        "$(letter)majorgrids" => axis[:grid] && framestyle != :none ? "true" : "false",
+    )
 
     # limits
     lims =
@@ -1344,7 +1346,8 @@ function pgfx_axis!(opt::PGFPlotsX.Options, sp::Subplot, letter)
                 push!(opt, string(letter, "ticklabels") => join(tick_labels))
             end
         elseif axis[:showaxis]
-            tick_labels = ispolar(sp) && letter == :x ? [ticks[2][3:end]..., "0", "45"] : ticks[2]
+            tick_labels =
+                ispolar(sp) && letter == :x ? [ticks[2][3:end]..., "0", "45"] : ticks[2]
             is_log_scale && (tick_labels = wrap_power_labels(tick_labels))
             if axis[:formatter] in (:scientific, :auto) && tick_labels isa Vector{String}
                 tick_labels = string.("\$", convert_sci_unicode.(tick_labels), "\$")

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
@@ -940,7 +940,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
             plotattributes_out_fillrange[:showlegend] = false
             # if fillrange is provided as real or tuple of real, expand to array
             if typeof(series[:fillrange]) <: Real
-                series[:fillrange] = fill(series[:fillrange], length(rng))
+                plotattributes_out[:fillrange] = fill(series[:fillrange], length(rng))
             elseif typeof(series[:fillrange]) <: Tuple
                 f1 =
                     typeof(series[:fillrange][1]) <: Real ?
@@ -948,7 +948,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
                 f2 =
                     typeof(series[:fillrange][2]) <: Real ?
                     fill(series[:fillrange][2], length(rng)) : series[:fillrange][2][rng]
-                series[:fillrange] = (f1, f2)
+                plotattributes_out[:fillrange] = (f1, f2)
             end
             if isa(series[:fillrange], AbstractVector)
                 plotattributes_out_fillrange[:y] = series[:fillrange][rng]
@@ -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,18 +1020,23 @@ 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
 function plotly_series(plt::Plot)
+    if isempty(plt.series_list)
+        return KW[]
+    end
     reduce(vcat, plotly_series(plt, series) for series in plt.series_list)
 end
 
@@ -1079,10 +1085,10 @@ function plotly_html_body(plt, style = nothing)
         requirejs_prefix = """
             requirejs.config({
                 paths: {
-                    Plotly2: '$(plotly_no_ext)'
+                    Plotly: '$(plotly_no_ext)'
                 }
             });
-            require(['Plotly2'], function (Plotly2) {
+            require(['Plotly'], function (Plotly) {
         """
         requirejs_suffix = "});"
     end
@@ -1101,7 +1107,7 @@ end
 
 function js_body(plt::Plot, uuid)
     js = """
-        Plotly2.newPlot('$(uuid)', $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
+        Plotly.newPlot('$(uuid)', $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
     """
 end
 

src/backends/pyplot.jl

@@ -1725,7 +1725,12 @@ function _update_plot_object(plt::Plot{PyPlotBackend})
                 _cbar_width - 1mm,
                 height(sp.bbox) - 4mm,
             )
-            pcts = bbox_to_pcts(cb_bbox, figw, figh)
+            pcts = get(
+                sp[:extra_kwargs],
+                "3d_colorbar_axis",
+                bbox_to_pcts(cb_bbox, figw, figh),
+            )
+
             sp.attr[:cbar_ax]."set_position"(pcts)
         end
     end

src/backends/unicodeplots.jl

@@ -1,60 +1,113 @@
 # https://github.com/JuliaPlots/UnicodePlots.jl
 
-# don't warn on unsupported... there's just too many warnings!!
-warn_on_unsupported_args(::UnicodePlotsBackend, plotattributes) = nothing
-
-# ------------------------------------------------------------------------------------------
 const _canvas_map = (
-    ascii = UnicodePlots.AsciiCanvas,
-    block = UnicodePlots.BlockCanvas,
     braille = UnicodePlots.BrailleCanvas,
     density = UnicodePlots.DensityCanvas,
-    dot = UnicodePlots.DotCanvas,
     heatmap = UnicodePlots.HeatmapCanvas,
     lookup = UnicodePlots.LookupCanvas,
+    ascii = UnicodePlots.AsciiCanvas,
+    block = UnicodePlots.BlockCanvas,
+    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[]
+
+    has_layout = prod(size(plt.layout)) > 1
     for sp in plt.subplots
+        sp_kw = sp[:extra_kwargs]
         xaxis = sp[:xaxis]
         yaxis = sp[:yaxis]
         xlim = collect(axis_limits(sp, :x))
         ylim = collect(axis_limits(sp, :y))
+        zlim = collect(axis_limits(sp, :z))
+        F = float(eltype(xlim))
 
-        # we set x/y to have a single point,
+        # We set x/y to have a single point,
         # since we need to create the plot with some data.
-        # since this point is at the bottom left corner of the plot,
-        # it shouldn't actually be shown
-        x = Float64[xlim[1]]
-        y = Float64[ylim[1]]
+        # Since this point is at the bottom left corner of the plot,
+        # it should be hidden by consecutive plotting commands.
+        x = Vector{F}(xlim)
+        y = Vector{F}(ylim)
+        z = Vector{F}(zlim)
 
         # create a plot window with xlim/ylim set,
         # but the X/Y vectors are outside the bounds
-        canvas_type = if (ct = _canvas_type[]) == :auto
+        canvas = if (up_c = get(sp_kw, :canvas, :auto)) === :auto
             isijulia() ? :ascii : :braille
         else
-            ct
+            up_c
         end
 
+        border = if (up_b = get(sp_kw, :border, :auto)) === :auto
+            isijulia() ? :ascii : :solid
+        else
+            up_b
+        end
+
+        # blank plots will not be shown
+        width = has_layout && isempty(series_list(sp)) ? 0 : get(sp_kw, :width, up_width)
+        height = get(sp_kw, :height, up_height)
+
+        plot_3d = is3d(sp)
+        blend = get(sp_kw, :blend, true)
+        grid = xaxis[:grid] && yaxis[:grid]
+        quiver = contour = false
+        for series in series_list(sp)
+            st = series[:seriestype]
+            blend &= get(series[:extra_kwargs], :blend, true)
+            quiver |= series[:arrow] isa Arrow  # post-pipeline detection (:quiver -> :path)
+            contour |= st === :contour
+            if st === :histogram2d
+                xlim = ylim = (0, 0)
+            elseif st === :spy || st === :heatmap
+                width = height = 0
+                grid = false
+            end
+        end
+        grid &= !(quiver || contour)
+        blend &= !(quiver || contour)
+
+        plot_3d && (xlim = ylim = (0, 0))  # determined using projection
+        azimuth, elevation = sp[:camera]  # PyPlot: azimuth = -60 & elevation = 30
+        projection = plot_3d ? get(sp_kw, :projection, :orthographic) : nothing
+
         kw = (
             compact = true,
             title = texmath2unicode(sp[:title]),
             xlabel = texmath2unicode(xaxis[:guide]),
             ylabel = texmath2unicode(yaxis[:guide]),
+            grid = grid,
+            blend = blend,
+            height = height,
+            width = width,
             xscale = xaxis[:scale],
             yscale = yaxis[:scale],
-            border = isijulia() ? :ascii : :solid,
+            border = border,
             xlim = xlim,
             ylim = ylim,
+            # 3d
+            projection = projection,
+            elevation = elevation,
+            azimuth = azimuth,
+            zoom = get(sp_kw, :zoom, 1),
+            up = get(sp_kw, :up, :z),
         )
 
-        o = UnicodePlots.Plot(x, y, _canvas_map[canvas_type]; kw...)
+        o = UnicodePlots.Plot(x, y, plot_3d ? z : nothing, _canvas_map[canvas]; kw...)
         for series in series_list(sp)
-            o = addUnicodeSeries!(sp, o, kw, series, sp[:legend_position] != :none)
+            o = addUnicodeSeries!(
+                sp,
+                o,
+                kw,
+                series,
+                sp[:legend_position] !== :none,
+                plot_3d,
+            )
         end
 
         for ann in sp[:annotations]
@@ -79,6 +132,11 @@ up_color(col::RGBA) =
     (c = convert(ARGB32, col); map(Int, (red(c).i, green(c).i, blue(c).i)))
 up_color(col) = :auto
 
+function up_cmap(series)
+    rng = range(0, 1, length = length(UnicodePlots.COLOR_MAP_DATA[:viridis]))
+    [(red(c), green(c), blue(c)) for c in get(get_colorgradient(series), rng)]
+end
+
 # add a single series
 function addUnicodeSeries!(
     sp::Subplot{UnicodePlotsBackend},
@@ -86,45 +144,81 @@ function addUnicodeSeries!(
     kw,
     series,
     addlegend::Bool,
+    plot_3d::Bool,
 )
     st = series[:seriestype]
+    se_kw = series[:extra_kwargs]
 
     # get the series data and label
-    x, y = if st == :straightline
+    x, y = if st === :straightline
         straightline_data(series)
-    elseif st == :shape
+    elseif st === :shape
         shape_data(series)
     else
-        float(series[:x]), float(series[:y])
+        series[:x], series[:y]
+    end
+
+    if ispolar(sp) || ispolar(series)
+        return UnicodePlots.polarplot(x, y)
     end
 
     # special handling (src/interface)
-    if st == :histogram2d
-        kw[:xlim][:] .= kw[:ylim][:] .= 0
+    fix_ar = get(se_kw, :fix_ar, true)
+    if st === :histogram2d
         return UnicodePlots.densityplot(x, y; kw...)
-    elseif st == :heatmap
-        rng = range(0, 1, length = length(UnicodePlots.COLOR_MAP_DATA[:viridis]))
-        cmap = [(red(c), green(c), blue(c)) for c in get(get_colorgradient(series), rng)]
-        return UnicodePlots.heatmap(
-            series[:z].surf;
-            zlabel = sp[:colorbar_title],
-            colormap = cmap,
+    elseif st === :spy
+        return UnicodePlots.spy(Array(series[:z]); fix_ar = fix_ar, kw...)
+    elseif st in (:contour, :heatmap)  # 2D
+        colormap = get(se_kw, :colormap, :none)
+        kw = (
             kw...,
+            zlabel = sp[:colorbar_title],
+            colormap = colormap === :none ? up_cmap(series) : colormap,
+            colorbar = hascolorbar(sp),
+        )
+        if st === :contour
+            isfilledcontour(series) &&
+                @warn "Plots(UnicodePlots): filled contour is not implemented"
+            return UnicodePlots.contourplot(
+                x,
+                y,
+                Array(series[:z]);
+                kw...,
+                levels = series[:levels],
+            )
+        elseif st === :heatmap
+            return UnicodePlots.heatmap(Array(series[:z]); fix_ar = fix_ar, kw...)
+        end
+    elseif st in (:surface, :wireframe)  # 3D
+        colormap = get(se_kw, :colormap, :none)
+        lines = get(se_kw, :lines, st === :wireframe)
+        zscale = get(se_kw, :zscale, :identity)
+        kw = (
+            kw...,
+            zlabel = sp[:colorbar_title],
+            colormap = colormap === :none ? up_cmap(series) : colormap,
+            colorbar = hascolorbar(sp),
+            color = st === :wireframe ? up_color(get_linecolor(series, 1)) : nothing,
+            zscale = zscale,
+            lines = lines,
+        )
+        return UnicodePlots.surfaceplot(x, y, Array(series[:z]); kw...)
+    elseif st === :mesh3d
+        return UnicodePlots.lineplot!(
+            up,
+            mesh3d_triangles(x, y, series[:z], series[:connections])...,
         )
-    elseif st == :spy
-        return UnicodePlots.spy(series[:z].surf; kw...)
     end
 
-    series_kw = (;)
-
     # now use the ! functions to add to the plot
-    if st in (:path, :straightline, :shape)
+    if st in (:path, :path3d, :straightline, :shape, :mesh3d)
         func = UnicodePlots.lineplot!
-    elseif st == :scatter || series[:markershape] != :none
+        series_kw = (; head_tail = series[:arrow] isa Arrow ? series[:arrow].side : nothing)
+    elseif st in (:scatter, :scatter3d) || series[:markershape] !== :none
         func = UnicodePlots.scatterplot!
         series_kw = (; marker = series[:markershape])
     else
-        error("Series type $st not supported by UnicodePlots")
+        error("Plots(UnicodePlots): series type $st not supported")
     end
 
     label = addlegend ? series[:label] : ""
@@ -135,7 +229,8 @@ function addUnicodeSeries!(
         up = func(
             up,
             x[rng],
-            y[rng];
+            y[rng],
+            plot_3d ? series[:z][rng] : nothing;
             color = up_color(lc),
             name = n == 1 ? label : "",
             series_kw...,
@@ -154,98 +249,125 @@ function addUnicodeSeries!(
         )
     end
 
-    return up
+    up
 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)
-        run(`import -window $(ENV["WINDOWID"]) $fn`)
-        return
+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
     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)
-    lines_colored = Array{Union{Nothing,Vector{String}}}(undef, nr, nc)
-    lines_uncolored = copy(lines_colored)
-    l_max = zeros(Int, nr)
-    w_max = zeros(Int, nc)
-    buf = IOBuffer()
-    cbuf = IOContext(buf, :color => true)
-    re_col = r"\x1B\[[0-9;]*[a-zA-Z]"
-    sps = 0
-    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 "UnicodePlots: complex nested layout is currently unsupported !"
-            else
-                if get(l.attr, :blank, false)
-                    lines_colored[r, c] = lines_uncolored[r, c] = nothing
-                else
-                    sp = plt.o[sps += 1]
-                    show(cbuf, sp)
-                    colored = String(take!(buf))
-                    uncolored = replace(colored, re_col => "")
-                    lines_colored[r, c] = lc = split(colored, "\n")
-                    lines_uncolored[r, c] = lu = split(uncolored, "\n")
-                    lmax = max(length(lc), lmax)
-                    w_max[c] = max(maximum(length.(lu)), w_max[c])
-                end
-            end
+    if nr == 1 && nc == 1  # fast path
+        n = length(plt.o)
+        for (i, p) in enumerate(plt.o)
+            show(io, p)
+            i < n && println(io)
         end
-        l_max[r] = lmax
-    end
-    empty = String[' '^w for w in w_max]
-    for r in 1:nr
-        for n in 1:l_max[r]
+    else
+        have_color = Base.get_have_color()
+        buf = IOContext(PipeBuffer(), :color => have_color)
+        lines_colored = Array{Union{Nothing,Vector{String}}}(undef, nr, nc)
+        lines_uncolored = have_color ? similar(lines_colored) : lines_colored
+        l_max = zeros(Int, nr)
+        w_max = zeros(Int, nc)
+        sps = 0
+        for r in 1:nr
+            lmax = 0
             for c in 1:nc
-                pre = c == 1 ? '\0' : ' '
-                lc = lines_colored[r, c]
-                if lc === nothing || length(lc) < n
-                    print(io, pre, empty[c])
+                if (l = plt.layout[r, c]) isa GridLayout && size(l) != (1, 1)
+                    error(
+                        "Plots(UnicodePlots): complex nested layout is currently unsupported",
+                    )
                 else
-                    lu = lines_uncolored[r, c]
-                    print(io, pre, lc[n], ' '^(w_max[c] - length(lu[n])))
+                    if get(l.attr, :blank, false)
+                        lines_colored[r, c] = lines_uncolored[r, c] = nothing
+                    else
+                        sp = plt.o[sps += 1]
+                        show(buf, sp)
+                        colored = read(buf, String)
+                        lines_colored[r, c] = lu = lc = split(colored, '\n')
+                        if have_color
+                            uncolored = UnicodePlots.no_ansi_escape(colored)
+                            lines_uncolored[r, c] = lu = split(uncolored, '\n')
+                        end
+                        lmax = max(length(lc), lmax)
+                        w_max[c] = max(maximum(length.(lu)), w_max[c])
+                    end
                 end
             end
-            println(io)
+            l_max[r] = lmax
+        end
+        empty = String[' '^w for w in w_max]
+        for r in 1:nr
+            for n in 1:l_max[r]
+                for c in 1:nc
+                    pre = c == 1 ? '\0' : ' '
+                    lc = lines_colored[r, c]
+                    if lc === nothing || length(lc) < n
+                        print(io, pre, empty[c])
+                    else
+                        lu = lines_uncolored[r, c]
+                        print(io, pre, lc[n], ' '^(w_max[c] - length(lu[n])))
+                    end
+                end
+                n < l_max[r] && println(io)
+            end
+            r < nr && println(io)
         end
-        r < nr && println(io)
     end
     nothing
 end
 
+# we only support MIME"text/plain", hence display(...) falls back to plain-text on stdout
 function _display(plt::Plot{UnicodePlotsBackend})
-    unicodeplots_rebuild(plt)
-    map(display, plt.o)
-    nothing
+    show(stdout, plt)
+    println(stdout)
 end

src/components.jl

@@ -43,13 +43,7 @@ vertices(shape::Shape) = collect(zip(shape.x, shape.y))
 "return the vertex points from a Shape or Segments object"
 coords(shape::Shape) = shape.x, shape.y
 
-#coords(shapes::AVec{Shape}) = unzip(map(coords, shapes))
-function coords(shapes::AVec{<:Shape})
-    c = map(coords, shapes)
-    x = [q[1] for q in c]
-    y = [q[2] for q in c]
-    x, y
-end
+coords(shapes::AVec{<:Shape}) = unzip(map(coords, shapes))
 
 "get an array of tuples of points on a circle with radius `r`"
 partialcircle(start_θ, end_θ, n = 20, r = 1) =
@@ -165,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)
@@ -178,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

src/consts.jl

@@ -41,27 +41,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 =
+    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

src/examples.jl

@@ -849,7 +849,6 @@ const _examples = PlotExample[
         [
             quote
                 begin
-                    using Plots
                     default(
                         titlefont = (20, "times"),
                         legendfontsize = 18,
@@ -962,9 +961,9 @@ const _examples = PlotExample[
         """
         Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
         You can also specify the connections using the connections keyword.
-        The connections can be specified in two ways: Either as a tuple of vectors where each vector 
-        contains the 0-based indices of one point of a triangle, such that elements at the same 
-        position of these vectors form a triangle. Or as a vector of NTuple{3,Ints} where each element 
+        The connections can be specified in two ways: Either as a tuple of vectors where each vector
+        contains the 0-based indices of one point of a triangle, such that elements at the same
+        position of these vectors form a triangle. Or as a vector of NTuple{3,Ints} where each element
         contains the 1-based indices of the three points of a triangle.
         """,
         [
@@ -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)
@@ -1235,7 +1231,7 @@ const _examples = PlotExample[
     PlotExample( # 56
         "Bar plot customizations",
         """
-        Width of bars may be specified as `bar_width`. 
+        Width of bars may be specified as `bar_width`.
         The bars' baseline may be specified as `fillto`.
         Each may be scalar, or a vector spcifying one value per bar.
         """,
@@ -1264,14 +1260,45 @@ const _examples = PlotExample[
             ),
         ],
     ),
+    PlotExample( # 57
+        "Vertical and horizonal spans",
+        """
+        `vspan` and `hspan` can be used to shade horizontal and vertical ranges.
+        """,
+        [:(
+            begin
+                hspan([1, 2, 3, 4]; label = "hspan", legend = :topleft)
+                vspan!([2, 3]; alpha = 0.5, label = "vspan")
+                plot!([0, 2, 3, 5], [-1, 3, 2, 6]; c = :black, lw = 2, label = "line")
+            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, 51, 55, 56],
+    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 50, 51, 55, 56],
     :pgfplotsx => [
         2,  # animation
         6,  # images
@@ -1289,22 +1316,17 @@ _backend_skips = Dict(
         6,  # embedded images unsupported
         16,  # nested layout unsupported
         21,  # custom markers unsupported
-        22,  # contours unsupported
-        24,  # 3D 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
         43,  # heatmap with DateTime
         45,  # error bars
-        47,  # mesh3D unsupported
         49,  # polar heatmap
-        50,  # 3D surface unsupported
         51,  # embedded images unsupported
-        52,  # 3D quiver unsupported
-        55,  # 3D unsupported
+        55,  # mirror unsupported, resolution too low
         56,  # barplots
     ],
     :gaston => [
@@ -1330,11 +1352,8 @@ function test_examples(pkgname::Symbol, idx::Int; debug = false, disp = true)
     Base.eval(m, :(using Plots))
     map(exprs -> Base.eval(m, exprs), _examples[idx].exprs)
 
-    plt = current()
-    if disp
-        gui(plt)
-    end
-    plt
+    disp && Base.eval(m, :(gui(current())))
+    current()
 end
 
 # generate all plots and create a dict mapping idx --> plt

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

src/init.jl

@@ -89,7 +89,6 @@ function __init__()
     @require IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" begin
         if IJulia.inited
             _init_ijulia_plotting()
-
             IJulia.display_dict(plt::Plot) = _ijulia_display_dict(plt)
         end
     end

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)

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)
@@ -196,6 +194,7 @@ Base.show(io::IO, m::MIME"text/plain", plt::Plot) = show(io, plt)
 # for writing to io streams... first prepare, then callback
 for mime in (
     "text/html",
+    "text/latex",
     "image/png",
     "image/eps",
     "image/svg+xml",
@@ -216,6 +215,8 @@ for mime in (
     end
 end
 
+Base.showable(::MIME"text/html", plt::Plot{UnicodePlotsBackend}) = false  # Pluto
+
 Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
     showjuno(io, MIME("text/html"), plt)
 

src/pipeline.jl

@@ -69,7 +69,7 @@ function _preprocess_userrecipe(kw::AKW)
     _add_markershape(kw)
 
     # map marker_z if it's a Function
-    if isa(get(kw, :marker_z, nothing), Function)
+    if isa(get(kw, :marker_z, default(:marker_z)), Function)
         # TODO: should this take y and/or z as arguments?
         kw[:marker_z] =
             isa(kw[:z], Nothing) ? map(kw[:marker_z], kw[:x], kw[:y]) :
@@ -77,16 +77,12 @@ function _preprocess_userrecipe(kw::AKW)
     end
 
     # map line_z if it's a Function
-    if isa(get(kw, :line_z, nothing), Function)
+    if isa(get(kw, :line_z, default(:line_z)), Function)
         kw[:line_z] =
             isa(kw[:z], Nothing) ? map(kw[:line_z], kw[:x], kw[:y]) :
             map(kw[:line_z], kw[:x], kw[:y], kw[:z])
     end
 
-    # convert a ribbon into a fillrange
-    if get(kw, :ribbon, nothing) !== nothing
-        make_fillrange_from_ribbon(kw)
-    end
     return
 end
 
@@ -154,6 +150,22 @@ function RecipesPipeline.process_sliced_series_attributes!(plt::Plots.Plot, kw_l
             kw_list[ind - 1] = tmp
         end
     end
+
+    for kw in kw_list
+        rib = get(kw, :ribbon, default(:ribbon))
+        fr = get(kw, :fillrange, default(:fillrange))
+        # map ribbon if it's a Function
+        if rib isa Function
+            kw[:ribbon] = map(rib, kw[:x])
+        end
+        # convert a ribbon into a fillrange
+        if rib !== nothing
+            make_fillrange_from_ribbon(kw)
+            # map fillrange if it's a Function
+        elseif fr !== nothing && fr isa Function
+            kw[:fillrange] = map(fr, kw[:x])
+        end
+    end
     return nothing
 end
 
@@ -263,7 +275,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?
@@ -277,27 +288,38 @@ end
 
 function _add_plot_title!(plt)
     plot_title = plt[:plot_title]
+    plot_titleindex = nothing
+
     if plot_title != ""
-        the_layout = plt.layout
-        vspan = plt[:plot_titlevspan]
-        plt.layout = grid(2, 1, heights = (vspan, 1 - vspan))
-        plt.layout.grid[1, 1] = subplot = Subplot(plt.backend, parent = plt.layout[1, 1])
-        plt.layout.grid[2, 1] = the_layout
-        subplot.plt = plt
+        # make new subplot for plot title
+        if plt[:plot_titleindex] == 0
+            the_layout = plt.layout
+            vspan = plt[:plot_titlevspan]
+            plt.layout = grid(2, 1, heights = (vspan, 1 - vspan))
+            plt.layout.grid[1, 1] =
+                subplot = Subplot(plt.backend, parent = plt.layout[1, 1])
+            plt.layout.grid[2, 1] = the_layout
+            subplot.plt = plt
+
+            top = plt.backend isa PyPlotBackend ? nothing : 0mm
+            bot = 0mm
+            plt[:force_minpad] = nothing, top, nothing, bot
+            subplot[:subplot_index] = last(plt.subplots)[:subplot_index] + 1
+            plt[:plot_titleindex] = subplot[:subplot_index]
+            subplot[:framestyle] = :none
+            subplot[:margin] = 0px
+            push!(plt.subplots, subplot)
+        end
+
         # propagate arguments plt[:plot_titleXXX] --> subplot[:titleXXX]
+        plot_titleindex = plt[:plot_titleindex]
+        subplot = plt.subplots[plot_titleindex]
         for sym in filter(x -> startswith(string(x), "plot_title"), keys(_plot_defaults))
             subplot[Symbol(string(sym)[(length("plot_") + 1):end])] = plt[sym]
         end
-        top = plt.backend isa PyPlotBackend ? nothing : 0mm
-        bot = 0mm
-        plt[:force_minpad] = nothing, top, nothing, bot
-        subplot[:subplot_index] = last(plt.subplots)[:subplot_index] + 1
-        plt[:plot_titleindex] = subplot[:subplot_index]
-        subplot[:framestyle] = :none
-        subplot[:margin] = 0px
-        push!(plt.subplots, subplot)
     end
-    return nothing
+
+    return plot_titleindex
 end
 
 ## Series recipes
@@ -405,7 +427,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

src/plot.jl

@@ -163,11 +163,11 @@ function plot!(plt1::Plot, plt2::Plot, plts_tail::Plot...; kw...)
             cmdidx += 1
         end
     end
-    _add_plot_title!(plt)
+    ttl_idx = _add_plot_title!(plt)
 
     # first apply any args for the subplots
     for (idx, sp) in enumerate(plt.subplots)
-        _update_subplot_args(plt, sp, plotattributes, idx, false)
+        _update_subplot_args(plt, sp, idx == ttl_idx ? KW() : plotattributes, idx, false)
     end
 
     # finish up
@@ -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

src/precompile_includer.jl

@@ -1,10 +1,10 @@
 #! format: off
-should_precompile = true
+should_precompile =     true
 
 
 # Don't edit the following! Instead change the script for `snoop_bot`.
 ismultios = false
-ismultiversion = false
+ismultiversion = true
 # precompile_enclosure
 @static if !should_precompile
     # nothing
@@ -14,4 +14,27 @@ elseif !ismultios && !ismultiversion
         _precompile_()
     end
 else
+    @static if v"1.6.0-DEV" <= VERSION <= v"1.6.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.6/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.6/precompile_Plots.jl")
+        _precompile_()
+    end
+elseif v"1.7.0-DEV" <= VERSION <= v"1.7.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.7/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.7/precompile_Plots.jl")
+        _precompile_()
+    end
+elseif v"1.8.0-DEV" <= VERSION <= v"1.8.9" 
+    @static if isfile(joinpath(@__DIR__, "../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl"))
+        include("../deps/SnoopCompile/precompile//1.8/precompile_Plots.jl")
+        _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
+
 end # precompile_enclosure

src/recipes.jl

@@ -795,7 +795,7 @@ function _auto_binning_nbins(
     elseif mode == :fd  # Freedman–Diaconis rule
         _cl(_span(v) / (2 * _iqr(v) / nd))
     elseif mode == :wand
-        _cl(wand_edges(v))  # this makes this function not type stable, but the type instability does not propagate
+        wand_edges(v)  # this makes this function not type stable, but the type instability does not propagate
     else
         error("Unknown auto-binning mode $mode")
     end
@@ -1037,6 +1037,8 @@ export lens!
         throw(ArgumentError("Inset bounding box needs to in relative coordinates."))
     end
     sp = plt.subplots[sp_index]
+    xscale = sp[:xaxis][:scale]
+    yscale = sp[:yaxis][:scale]
     xl1, xl2 = xlims(sp)
     bbx1 = xl1 + left(inset_bbox).value * (xl2 - xl1)
     bbx2 = bbx1 + width(inset_bbox).value * (xl2 - xl1)
@@ -1046,8 +1048,8 @@ export lens!
     bbx = bbx1 + width(inset_bbox).value * (xl2 - xl1) / 2 * (sp[:xaxis][:flip] ? -1 : 1)
     bby = bby1 + height(inset_bbox).value * (yl2 - yl1) / 2 * (sp[:yaxis][:flip] ? -1 : 1)
     lens_index = last(plt.subplots)[:subplot_index] + 1
-    x1, x2 = plotattributes[:x]
-    y1, y2 = plotattributes[:y]
+    x1, x2 = RecipesPipeline.inverse_scale_func(xscale).(plotattributes[:x])
+    y1, y2 = RecipesPipeline.inverse_scale_func(yscale).(plotattributes[:y])
     backup = copy(plotattributes)
     empty!(plotattributes)
 
@@ -1072,8 +1074,8 @@ export lens!
         @series begin
             primary := false
             subplot := sp_index
-            x := [xi_mag, xi_lens]
-            y := [yi_mag, yi_lens]
+            x := RecipesPipeline.scale_func(xscale).([xi_mag, xi_lens])
+            y := RecipesPipeline.scale_func(yscale).([yi_mag, yi_lens])
             ()
         end
     end
@@ -1081,8 +1083,8 @@ export lens!
     @series begin
         primary := false
         subplot := sp_index
-        x := [x1, x1, x2, x2, x1]
-        y := [y1, y2, y2, y1, y1]
+        x := RecipesPipeline.scale_func(xscale).([x1, x1, x2, x2, x1])
+        y := RecipesPipeline.scale_func(yscale).([y1, y2, y2, y1, y1])
         ()
     end
     # add subplot
@@ -1091,8 +1093,8 @@ export lens!
             plotattributes = merge(backup, copy(series.plotattributes))
             subplot := lens_index
             primary := false
-            xlims := (x1, x2)
-            ylims := (y1, y2)
+            xlims := RecipesPipeline.scale_func(xscale).((x1, x2))
+            ylims := RecipesPipeline.scale_func(yscale).((y1, y2))
             ()
         end
     end
@@ -1380,7 +1382,8 @@ function clamp_greys!(mat::AMat{<:Gray})
 end
 
 @recipe function f(mat::AMat{<:Gray})
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))
+
     if is_seriestype_supported(:image)
         seriestype := :image
         yflip --> true
@@ -1398,7 +1401,7 @@ end
 
 # images - colors
 @recipe function f(mat::AMat{T}) where {T<:Colorant}
-    n, m = axes(mat)
+    n, m = map(a -> range(0.5, stop = a.stop + 0.5), axes(mat))
 
     if is_seriestype_supported(:image)
         seriestype := :image
@@ -1622,7 +1625,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 +1669,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)

src/shorthands.jl

@@ -348,10 +348,10 @@ Make a box and whisker plot.
 
 # Keyword arguments
 - `notch`: Bool. Notch the box plot? (false)
-- `range`: Real. Values more than range*IQR below the first quartile
-           or above the third quartile are shown as outliers (1.5)
+- `whisker_range`: Real. Whiskers extend `whisker_range`*IQR below the first quartile
+           and above the third quartile. Values outside this range are shown as outliers (1.5)
 - `outliers`: Bool. Show outliers? (true)
-- `whisker_width`: Real or Symbol. Length of whiskers (:match)
+- `whisker_width`: Real or Symbol. Length of whiskers; the options are `:match` to match the box width, `:half`, or a number to indicate the total length. (:half)
 
 # Example
 ```julia-repl
@@ -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

src/utils.jl

@@ -215,20 +215,12 @@ makevec(v::T) where {T} = T[v]
 maketuple(x::Real) = (x, x)
 maketuple(x::Tuple{T,S}) where {T,S} = x
 
-for i in 2:4
-    @eval begin
-        RecipesPipeline.unzip(
-            v::Union{AVec{<:NTuple{$i,T} where {T}},AVec{<:GeometryBasics.Point{$i}}},
-        ) = $(Expr(:tuple, (:([t[$j] for t in v]) for j in 1:i)...))
-    end
-end
-
-RecipesPipeline.unzip(
-    ::Union{AVec{<:GeometryBasics.Point{N}},AVec{<:NTuple{N,T} where {T}}},
-) where {N} = error("$N-dimensional unzip not implemented.")
-
-RecipesPipeline.unzip(::Union{AVec{<:GeometryBasics.Point},AVec{<:Tuple}}) =
-    error("Can't unzip points of different dimensions.")
+RecipesPipeline.unzip(v) = unzip(v)
+RecipesPipeline.unzip(points::AbstractVector{<:GeometryBasics.Point}) =
+    unzip(Tuple.(points))
+RecipesPipeline.unzip(points::AbstractVector{GeometryBasics.Point{N,T}}) where {N,T} =
+    isbitstype(T) && sizeof(T) > 0 ? unzip(reinterpret(NTuple{N,T}, points)) :
+    unzip(Tuple.(points))
 
 # given 2-element lims and a vector of data x, widen lims to account for the extrema of x
 function _expand_limits(lims, x)
@@ -385,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
@@ -442,9 +433,9 @@ end
 
 #turn tuple of fillranges to one path
 function concatenate_fillrange(x, y::Tuple)
-    rib1, rib2 = first(y), last(y)
-    yline = vcat(rib1, (rib2)[end:-1:1])
-    xline = vcat(x, x[end:-1:1])
+    rib1, rib2 = collect(first(y)), collect(last(y)) # collect needed until https://github.com/JuliaLang/julia/pull/37629 is merged
+    yline = vcat(rib1, reverse(rib2))
+    xline = vcat(x, reverse(x))
     return xline, yline
 end
 
@@ -994,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],

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
 

test/runtests.jl

@@ -37,18 +37,297 @@ end
     Plots.use_local_dependencies[] = temp
 end
 
-include("test_defaults.jl")
-include("test_pipeline.jl")
-include("test_axes.jl")
-include("test_contours.jl")
-include("test_axis_letter.jl")
-include("test_components.jl")
-include("test_shorthands.jl")
-include("integration_dates.jl")
-include("test_recipes.jl")
-include("test_hdf5plots.jl")
-include("test_pgfplotsx.jl")
-include("test_plotly.jl")
+@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",
+    "test_layouts.jl",
+    "test_contours.jl",
+    "test_axis_letter.jl",
+    "test_components.jl",
+    "test_shorthands.jl",
+    "integration_dates.jl",
+    "test_recipes.jl",
+    "test_hdf5plots.jl",
+    "test_pgfplotsx.jl",
+    "test_plotly.jl",
+    "test_animations.jl",
+)
+    @testset "$fn" begin
+        include(fn)
+    end
+end
 
 reference_dir(args...) =
     joinpath(homedir(), ".julia", "dev", "PlotReferenceImages", args...)
@@ -84,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
 
@@ -109,103 +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)
+@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
-        @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.unzip(z)...)), z)
-        @test isequal(collect(zip(Plots.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)²",
-    )
 end
 
 @testset "Backends" begin
@@ -219,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
@@ -264,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

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

test/test_args.jl

@@ -0,0 +1,18 @@
+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

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

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__()
@@ -12,6 +12,14 @@ end
 empty!(PLOTS_DEFAULTS)
 Plots.__init__()
 
+@testset "default" begin
+    default(fillrange = 0)
+    @test Plots._series_defaults[:fillrange] == 0
+    pl = plot(1:5)
+    @test pl[1][1][:fillrange] == 0
+    default()
+end
+
 @testset "Legend defaults" begin
     p = plot()
     @test p[1][:legend_font_family] == "sans-serif"
@@ -68,6 +76,11 @@ end # testset
     @test p[1][:legend_background_color] == RGBA{Float64}(0.0, 1.0, 1.0, 1.0)
     @test p[1][:legend_foreground_color] == RGBA{Float64}(0.0, 0.5019607843137255, 0.0, 1.0)
 
+    #remember settings
+    plot(legend_font_pointsize = 20)
+    sp = plot!(label = "R")[1]
+    @test Plots.legendfont(sp).pointsize == 20
+
     #setting whole font
     sp = plot(
         1:5,
@@ -80,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

test/test_layouts.jl

@@ -0,0 +1,98 @@
+using Plots, Test
+
+@testset "Subplot sclicing" begin
+    pl = @test_nowarn plot(
+        rand(4, 8),
+        layout = 4,
+        yscale = [:identity :identity :log10 :log10],
+    )
+    @test pl[1][:yaxis][:scale] == :identity
+    @test pl[2][:yaxis][:scale] == :identity
+    @test pl[3][:yaxis][:scale] == :log10
+    @test pl[4][:yaxis][:scale] == :log10
+end
+
+@testset "Plot title" begin
+    pl = plot(rand(4, 8), layout = 4, plot_title = "My title")
+    @test pl[:plot_title] == "My title"
+    @test pl[:plot_titleindex] == 5
+
+    plot!(pl)
+    @test pl[:plot_title] == "My title"
+    @test pl[:plot_titleindex] == 5
+
+    plot!(pl, plot_title = "My new title")
+    @test pl[:plot_title] == "My new title"
+    @test pl[:plot_titleindex] == 5
+end
+
+@testset "Plots.jl/issues/4083" begin
+    p = plot(plot(1:2), plot(1:2); border = :grid, plot_title = "abc")
+    @test p[1][:framestyle] === :grid
+    @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

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

test/test_pipeline.jl

@@ -17,3 +17,22 @@ end
     @test all(RecipesPipeline.get_axis_limits(p1, :x) .== x)
     @test all(RecipesPipeline.get_axis_limits(p2, :x) .== x)
 end
+
+@testset "Slicing" begin
+    @test plot(1:5, fillrange = 0)[1][1][:fillrange] == 0
+    data4 = rand(4, 4)
+    mat = reshape(1:8, 2, 4)
+    for i in axes(data4, 1)
+        for attribute in (:fillrange, :ribbon)
+            @test plot(data4; NamedTuple{tuple(attribute)}(0)...)[1][i][attribute] == 0
+            @test plot(data4; NamedTuple{tuple(attribute)}(Ref([1, 2]))...)[1][i][attribute] ==
+                  [1.0, 2.0]
+            @test plot(data4; NamedTuple{tuple(attribute)}(Ref([1 2]))...)[1][i][attribute] ==
+                  (iseven(i) ? 2 : 1)
+            @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

test/test_plotly.jl

@@ -7,6 +7,7 @@ using Plots, Test
 
         p = plot(rand(10))
         @test isa(p, Plots.Plot) == true
+        @test_nowarn Plots.plotly_series(plot())
     end
 
     @testset "Contours" begin
@@ -54,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

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