minor bump [skip ci]

Merge pull request #2799 from isentropic/fixedlayouts
layouts fixed
2020-06-29 23:06:12 +02:00 · 2020-06-29 18:22:53 +02:00 · 2020-06-29 18:21:57 +02:00 · 2020-06-27 14:15:50 +02:00 · 2020-06-27 13:08:22 +02:00 · 2020-06-27 12:56:59 +02:00
59 changed files with 8714 additions and 4658 deletions
@@ -0,0 +1,32 @@
+---
+name: Bug report
+about: Create a bug report
+title: "[BUG]"
+labels: bug
+assignees: ''
+
+---
+
+<!-- Please search existing issues to avoid duplicates. -->
+
+## Details
+
+
+### Backends
+
+This bug occurs on ( insert `x` below )
+
+Backend      | yes | no  | untested
+-------------|-----|-----|---------
+gr (default) |     |     |
+pyplot       |     |     |
+plotly       |     |     |
+plotlyjs     |     |     |
+pgfplotsx    |     |     |
+inspectdr    |     |     |
+
+### Versions
+
+Plots.jl version:
+Backend  version (`]st -m`):
+Output of `versioninfo()`:
@@ -0,0 +1,10 @@
+---
+name: Feature request
+about: Suggest a feature or enhancement
+title: "[FR]"
+labels: feature request
+assignees: ''
+
+---
+
+Please search existing issues to avoid duplicates.
@@ -0,0 +1,24 @@
+name: CompatHelper
+
+on:
+  schedule:
+    - cron: '00 * * * *'
+
+jobs:
+  CompatHelper:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: [1.2.0]
+        julia-arch: [x86]
+        os: [ubuntu-latest]
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia-version }}
+      - name: Pkg.add("CompatHelper")
+        run: julia -e 'using Pkg; Pkg.add("CompatHelper")'
+      - name: CompatHelper.main()
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: julia -e 'using CompatHelper; CompatHelper.main()'
@@ -0,0 +1,11 @@
+name: TagBot
+on:
+  schedule:
+    - cron: 0 * * * *
+jobs:
+  TagBot:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,117 @@
+name: ci
+
+on:
+  push:
+  pull_request:
+
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  CI:
+    if: "!contains(github.event.head_commit.message, '[skip ci]')"
+    env:
+      GKS_ENCODING: "utf8"
+
+    name: Julia ${{ matrix.julia_version }} - ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    continue-on-error: ${{ matrix.allow-failure }}
+    strategy:
+      fail-fast: false
+      matrix:
+        julia_version:
+          - '1.3'
+          # - '1' (is included automatically)
+          - 'nightly'
+        os:
+          - ubuntu-latest
+          - windows-latest
+          - macos-latest
+        arch:
+          - x64
+          # - x86
+        allow-failure: [false]
+        include:
+          ## allow failures on nightly
+          - version: 'nightly'
+            os: ubuntu-latest
+            arch: x64
+            allow-failure: true
+          - version: 'nightly'
+            os: macOS-latest
+            arch: x64
+            allow-failure: true
+          - version: 'nightly'
+            os: windows-latest
+            arch: x64
+            allow-failure: true
+          ## allow failures for julia 1.3 windows (test_images work but differ)
+          - version: '1.3'
+            os: windows-latest
+            arch: x64
+            allow-failure: true
+        ## if we want to run tests on x86:
+        #   - version: 'nightly'
+        #     os: ubuntu-latest
+        #     arch: x86
+        #     allow-failure: true
+        #   - version: 'nightly'
+        #     os: windows-latest
+        #     arch: x86
+        #     allow-failure: true
+        # exclude:
+        #   - os: macOS-latest
+        #     arch: x86
+    steps:
+
+      # Setup environment
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia_version }}
+      - name: Cache artifacts
+        uses: actions/cache@v1
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+
+      ## 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 ::set-env name=TESTCMD::"julia"
+      - name: Ubuntu TESTCMD
+        if: startsWith(matrix.os,'ubuntu')
+        run: echo ::set-env name=TESTCMD::"xvfb-run julia"
+
+      # Julia Deoendencies
+      - name: Install Julia dependencies
+        uses: julia-actions/julia-buildpkg@latest
+
+      # Run tests
+      - name: Run Graphical test
+        run:  $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
+
+      - name: Codecov
+        uses: julia-actions/julia-uploadcodecov@latest
+        env:
+          CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+
+  Skip:
+    if: "contains(github.event.head_commit.message, '[skip ci]')"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Skip CI 🚫
+        run: echo skip ci
@@ -4,6 +4,9 @@
 .DS_Store
 examples/.ipynb_checkpoints/*
 examples/meetup/.ipynb_checkpoints/*
-deps/plotly-latest.min.js
+deps/plotly-*
 deps/build.log
 deps/deps.jl
+Manifest.toml
+dev/
+test/tmpplotsave.hdf5
@@ -1,60 +0,0 @@
-# Documentation: http://docs.travis-ci.com/user/languages/julia/
-language: julia
-os:
-  - linux
-  # - osx
-julia:
-  # - 1.0
-  - nightly
-# matrix:
-#   allow_failures:
-#     - julia: nightly
-
-# # before install:
-# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi
-# #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew install wkhtmltopdf; fi
-
-# ref: http://askubuntu.com/a/556672 for the wkhtmltopdf apt repository info
-
-sudo: required
-before_install:
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then pwd ; fi
-  - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then ./test/install_wkhtmltoimage.sh ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo add-apt-repository -y ppa:pov/wkhtmltopdf  ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get -qq update                      ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  sudo apt-get install -y wkhtmltopdf          ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltopdf -V                               ; fi
-#   - if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then  wkhtmltoimage -V                             ; fi
-#   echo 'exec xvfb-run -a -s "-screen 0 640x480x16" wkhtmltopdf "$@"' | sudo tee /usr/local/bin/wkhtmltopdf.sh >/dev/null
-# sudo chmod a+x /usr/local/bin/wkhtmltopdf.sh
-
-# # borrowed from Blink.jl's travis file
-# matrix:
-#   include:
-#     - os: linux
-#       julia: 0.4
-#       env: TESTCMD="xvfb-run julia"
-#     - os: osx
-#       julia: 0.4
-#       env: TESTCMD="julia"
-
-
-
-notifications:
-  email: true
-# uncomment the following lines to override the default test script
-# script:
- # - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
- # - julia -e 'import Pkg; Pkg.add(Pkg.PackageSpec(path=pwd())); Pkg.build("Plots")'
- # - julia test/travis_commands.jl
- # - julia -e 'Pkg.clone("ImageMagick"); Pkg.build("ImageMagick")'
- # - julia -e 'Pkg.clone("GR"); Pkg.build("GR")'
- # # - julia -e 'Pkg.clone("https://github.com/tbreloff/ImageMagick.jl.git"); Pkg.checkout("ImageMagick","tb_write"); Pkg.build("ImageMagick")'
- # - julia -e 'Pkg.clone("https://github.com/tbreloff/ExamplePlots.jl.git");'
- # # - julia -e 'Pkg.clone("https://github.com/JunoLab/Blink.jl.git"); Pkg.build("Blink"); import Blink; Blink.AtomShell.install()'
- # # - julia -e 'Pkg.clone("https://github.com/spencerlyon2/PlotlyJS.jl.git")'
- # - julia -e 'ENV["PYTHON"] = ""; Pkg.add("PyPlot"); Pkg.build("PyPlot")'
- #
- # # - $TESTCMD -e 'Pkg.test("Plots"; coverage=false)'
- # - julia -e 'Pkg.test("Plots"; coverage=false)'
- # # - julia -e 'cd(Pkg.dir("Plots")); Pkg.add("Coverage"); using Coverage; Coveralls.submit(process_folder()); Codecov.submit(process_folder())'
@@ -3,14 +3,115 @@

 #### notes on release changes, ongoing development, and future planned work

- Minor version 0.17 is the last one to support Julia 0.6!!
- Minor version 0.11 is the last one to support Julia 0.5!!
-	- Critical bugfixes only
-    - `backports` branch is for Julia 0.5
-
---
 ## (current master)

+## 0.28.3
+- support generalized array interface
+- save to pdf, svg and eps in plotlyjs
+- fix for clims in line_z
+- optimize heatmap logic in gr
+
+## 0.26.3
+- fix `vline` with dates
+- fix PyPlot logscale bug
+- avoid annotation clipping for PyPlot
+- allow plotting of Any vectors and 3D plotting again in convertToAnyVector
+- specify legend title font in GR and PyPlot
+- delete `pushtomaster.sh`
+- use `=== nothing`
+
+## 0.26.2
+- improve empty animation build error
+- fix GR axis flip for heatmaps and images
+- fix ribbons specified as tuples
+- add Char recipe
+- fix Plotly plots with single-element series
+- rewrite PlotlyJS backend
+
+## 0.26.1
+- handle `Char`s as input data
+- fix html saving for Plotly
+- expand ~ in paths on UNIX systems
+- convertToAnyVector clean-up
+- fix color_palette grouping issue
+
+## 0.26.0
+- use FFMPEG.jl
+- add missing method for convertToAnyVector
+
+## 0.25.3
+- add areaplot
+- allow missing in z_color arguments
+- more general tuple recipe
+- stephist logscale improvements
+
+## 0.25.2
+- improvements to handle missings
+- pyplot: allow setting the color gradient for z values
+- document :colorbar_entry
+- limit number of automatic bins
+- fix ENV['PLOTS_DEFAULT_BACKEND']
+- don't let aspect_ratio impact subplot size
+- implement arrowstyle for GR
+- fix bug in plotly_convert_to_datetime
+- improve missing support
+- gr: polar heatmaps
+- make sure show returns nothing
+
+## 0.25.1
+- fix gr_display
+
+## 0.25.0
+- Replace StaticArrays with GeometryTypes
+- Contour fixes for GR
+
+## 0.24.0
+- Update to the new PyCall and PyPlot API
+- fix drawing of ticks
+- fix y label position with GR
+
+## 0.23.2
+- pyplot fixes
+- Add option :tex_output_standalone to set the 'include_preamble' argument in the PGFPlots backend.
+- fix ticks
+- support plotly json mime
+- fix image axis limits
+- default to radius 0 at center for polar plots
+
+## 0.23.1
+- slightly faster load time
+- fixed errant MethodError
+- fix bar plots with unicodeplots
+- better colorbars for contour
+- add volume seriestype for GR
+- fix passing a tuple to custom ticks
+- add vline to pgfplots
+- add tex output for pyplot
+- better 3d axis labels for GR
+
+## 0.23.0
+- compatible with StatPlots -> StatsPlots name shift
+- fix histograms for vectors with NaN and Inf
+- change gif behaviour (remove cache-busting)
+- improved docstrings for shorthands functions
+- fix font rotation for pyplot
+- fix greyscale images for pyplot
+- clamp greyscale images with values outside 0,1
+- support keyword argument for font options
+- allow vector of markers for pyplot scatter
+
+## 0.22.5
+- improve behaviour of plotlyjs backend
+
+## 0.22.4
+- Add support for discrete contourf plots with GR
+
+## 0.22.3
+- Fix the `showtheme` function
+
+## 0.22.2
+- Allow annotations to accept a Tuple instead of the result of a text call (making it possible to specify font characteristics in recipes). E.g. `annotations = (2, 4, ("test", :right, 8, :red))` is the same as `annotations = (2, 4, text("test", :right, 8, :red))`
+
 ## 0.22.1
 - push PlotsDisplay just after REPLDisplay

@@ -0,0 +1,75 @@
+name = "Plots"
+uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
+author = ["Tom Breloff (@tbreloff)"]
+version = "1.5.0"
+
+[deps]
+Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
+Contour = "d38c429a-6771-53c6-b99e-75d170b6e991"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+FFMPEG = "c87230d0-a227-11e9-1b43-d7ebe4e7570a"
+FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
+GR = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71"
+GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
+GeometryTypes = "4d00f742-c7ba-57c2-abde-4428a4b178cb"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Measures = "442fdcdd-2543-5da2-b0f3-8c86c306513e"
+NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
+PlotThemes = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a"
+PlotUtils = "995b91a9-d308-5afd-9ec6-746e21dbc043"
+Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7"
+REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
+RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01"
+RecipesPipeline = "01d81517-befc-4cb6-b9ec-a95719d0359c"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
+Showoff = "992d4aef-0814-514b-bc4d-f2e9a6c4116f"
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91"
+UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
+
+[compat]
+Contour = "0.5"
+FFMPEG = "0.2, 0.3"
+FixedPointNumbers = "0.6, 0.7, 0.8"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50"
+GeometryBasics = "0.2"
+GeometryTypes = "0.7, 0.8"
+JSON = "0.21"
+Measures = "0.3"
+NaNMath = "0.3"
+PGFPlotsX = "1.2.0"
+PlotThemes = "2"
+PlotUtils = "1"
+RecipesBase = "1"
+RecipesPipeline = "0.1.7"
+Reexport = "0.2"
+Requires = "1"
+Showoff = "0.3.1"
+StableRNGs = "0.1.1"
+StatsBase = "0.32, 0.33"
+julia = "1.3"
+
+[extras]
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+Gtk = "4c0ca9eb-093a-5379-98c5-f87ac0bbbf44"
+HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f"
+ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
+Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+LibGit2 = "76f85450-5226-5b5a-8eaa-529ad045b433"
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925"
+RDatasets = "ce6b1742-4840-55fa-b093-852dadbb1d8b"
+StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
+StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
+VisualRegressionTests = "34922c18-7c2a-561c-bac1-01e79b2c4c92"
+
+[targets]
+test = ["Distributions", "FileIO", "Gtk", "ImageMagick", "Images", "LibGit2", "OffsetArrays", "PGFPlotsX", "HDF5", "RDatasets", "StableRNGs", "StaticArrays", "StatsPlots", "Test", "UnicodePlots", "VisualRegressionTests"]
@@ -1,17 +1,26 @@
 # Plots

-[![Build Status](https://travis-ci.org/JuliaPlots/Plots.jl.svg?branch=master)](https://travis-ci.org/JuliaPlots/Plots.jl)
-[![Build status](https://ci.appveyor.com/api/projects/status/github/juliaplots/plots.jl?branch=master&svg=true)](https://ci.appveyor.com/project/mkborregaard/plots-jl)
-[![Join the chat at https://gitter.im/tbreloff/Plots.jl](https://badges.gitter.im/tbreloff/Plots.jl.svg)](https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-<a href="http://docs.juliaplots.org/latest/" target="_blank"><img src="https://img.shields.io/badge/docs-latest-blue.svg" alt="Latest documentation"></a>
-<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.3.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.3) -->
-<!-- [![Plots](http://pkg.julialang.org/badges/Plots_0.4.svg)](http://pkg.julialang.org/?pkg=Plots&ver=0.4) -->
-<!-- [![Coverage Status](https://coveralls.io/repos/tbreloff/Plots.jl/badge.svg?branch=master)](https://coveralls.io/r/tbreloff/Plots.jl?branch=master) -->
-<!-- [![codecov.io](http://codecov.io/github/tbreloff/Plots.jl/coverage.svg?branch=master)](http://codecov.io/github/tbreloff/Plots.jl?branch=master) -->
+[gh-ci-img]: https://github.com/JuliaPlots/Plots.jl/workflows/ci/badge.svg?branch=master
+[gh-ci-url]: https://github.com/JuliaPlots/Plots.jl/actions?query=workflow%3Aci
+
+[pkgeval-img]: https://juliaci.github.io/NanosoldierReports/pkgeval_badges/P/Plots.svg
+[pkgeval-url]: https://juliaci.github.io/NanosoldierReports/pkgeval_badges/report.html
+
+[gitter-img]: https://badges.gitter.im/tbreloff/Plots.jl.svg
+[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]: http://docs.juliaplots.org/latest/
+
+[![][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)

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

-#### Maintained by the [JuliaPlot members](https://github.com/orgs/JuliaPlots/people)
+#### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)

 Plots is a plotting API and toolset.  My goals with the package are:

@@ -1,16 +0,0 @@
-julia 1.0
-
-RecipesBase 0.6.0
-PlotUtils 0.4.1
-PlotThemes 0.1.3
-Reexport
-StaticArrays 0.5
-FixedPointNumbers 0.3
-Measures
-Showoff
-StatsBase 0.14.0
-JSON
-NaNMath
-Requires
-Contour
-GR 0.37.0
@@ -1,43 +0,0 @@
-environment:
-  matrix:
-  # - julia_version: 0.7
-  - julia_version: 1
-  - julia_version: nightly
-
-platform:
-  - x86 # 32-bit
-  - x64 # 64-bit
-
-# # Uncomment the following lines to allow failures on nightly julia
-# # (tests will run but not make your overall status red)
-matrix:
-  allow_failures:
-  - julia_version: nightly
-
-branches:
-  only:
-    - master
-    - /release-.*/
-
-notifications:
-  - provider: Email
-    on_build_success: false
-    on_build_failure: false
-    on_build_status_changed: false
-
-install:
-  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
-
-build_script:
-  - echo "%JL_BUILD_SCRIPT%"
-  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
-
-test_script:
-  - echo "%JL_TEST_SCRIPT%"
-  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
-
-# # Uncomment to support code coverage upload. Should only be enabled for packages
-# # which would have coverage gaps without running on Windows
-# on_success:
-#   - echo "%JL_CODECOV_SCRIPT%"
-#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"
@@ -0,0 +1,10 @@
+ignore:
+  - "src/backends/inspectdr.jl"
+  - "src/backends/orca.jl"
+  - "src/backends/pgfplots.jl"
+  - "src/backends/plotly.jl"
+  - "src/backends/plotlyjs.jl"
+  - "src/backends/pyplot.jl"
+  - "src/backends/web.jl"
+  - "src/fileio.jl"
+  - "src/ijulia.jl"
@@ -1,12 +1,12 @@

-#TODO: download https://cdn.plot.ly/plotly-latest.min.js to deps/ if it doesn't exist
+#TODO: download https://cdn.plot.ly/plotly-1.54.2.min.js to deps/ if it doesn't exist
 file_path = ""
 if get(ENV, "PLOTS_HOST_DEPENDENCY_LOCAL", "false") == "true"
    global file_path
-    local_fn = joinpath(dirname(@__FILE__), "plotly-latest.min.js")
+    local_fn = joinpath(dirname(@__FILE__), "plotly-1.54.2.min.js")
    if !isfile(local_fn)
-        @info("Cannot find deps/plotly-latest.min.js... downloading latest version.")
-        download("https://cdn.plot.ly/plotly-latest.min.js", local_fn)
+        @info("Cannot find deps/plotly-1.54.2.min.js... downloading latest version.")
+        download("https://cdn.plot.ly/plotly-1.54.2.min.js", local_fn)
        isfile(local_fn) && (file_path = local_fn)
    else
        file_path = local_fn
@@ -0,0 +1,55 @@
+# To figure out what should be precompiled, run this script, then move
+# precompile_Plots.jl in precompiles_path (see below) to src/precompile.jl
+
+# This script works by using SnoopCompile to log compilations that take place
+# while running the examples on the GR backend. So SnoopCompile must be
+# installed, and StatsPlots, RDatasets, and FileIO are also required for
+# certain examples.
+
+# If precompilation fails with an UndefVarError for a module, probably what is
+# happening is that the module appears in the precompile statements, but is
+# only visible to one of Plots' dependencies, and not Plots itself. Adding the
+# module to the blacklist below will remove these precompile statements.
+
+# Anonymous functions may appear in precompile statements as functions with
+# hashes in their name. Those of the form "#something##kw" have to do with
+# compiling functions with keyword arguments, and are named reproducibly, so
+# can be kept. Others generally will not work. Currently, SnoopCompile includes
+# some anonymous functions that not reproducible, but SnoopCompile PR #30
+# (which looks about to be merged) will ensure that anonymous functions are
+# actually defined before attempting to precompile them. Alternatively, we can
+# keep only the keyword argument related anonymous functions by changing the
+# regex that SnoopCompile uses to detect anonymous functions to
+# r"#{1,2}[^\"#]+#{1,2}\d+" (see anonrex in SnoopCompile.jl). To exclude all
+# precompile statements involving anonymous functions, "#" can also be added to
+# the blacklist below.
+
+using SnoopCompile
+
+project_flag = string("--project=", joinpath(homedir(), ".julia", "dev", "Plots"))
+log_path = joinpath(tempdir(), "compiles.log")
+precompiles_path = joinpath(tempdir(), "precompile")
+
+# run examples with GR backend, logging what needs to be compiled
+SnoopCompile.@snoopc project_flag log_path begin
+    using Plots
+    Plots.test_examples(:gr)
+    Plots.test_examples(:plotly, skip = Plots._backend_skips[:plotly])
+end
+
+# precompile calls containing the following strings are dropped
+blacklist = [
+    # functions defined in examples
+    "PlotExampleModule",
+    # the following are not visible to Plots, only its dependencies
+    "CategoricalArrays",
+    "FixedPointNumbers",
+    "OffsetArrays",
+    "SparseArrays",
+    "StaticArrays",
+    r"#{1,2}[^\"#]+#{1,2}\d+",
+]
+
+data = SnoopCompile.read(log_path)
+pc = SnoopCompile.parcel(reverse!(data[2]), blacklist=blacklist)
+SnoopCompile.write(precompiles_path, pc)
@@ -1,4 +0,0 @@
-git checkout master
-git merge --ff-only dev
-git push origin master
-git checkout dev
@@ -1,15 +1,21 @@
 module Plots

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

 using Reexport

-import StaticArrays
+import GeometryTypes, GeometryBasics
 using Dates, Printf, Statistics, Base64, LinearAlgebra, Random
-import SparseArrays: findnz
+import SparseArrays: AbstractSparseMatrix, findnz
+
+using FFMPEG

@reexport using RecipesBase
-import RecipesBase: plot, plot!, animate
+import RecipesBase: plot, plot!, animate, is_explicit
 using Base.Meta
@reexport using PlotUtils
@reexport using PlotThemes
@@ -102,6 +108,7 @@ export
    gif,
    mov,
    mp4,
+    webm,
    animate,
    @animate,
    @gif,
@@ -117,7 +124,11 @@ export
    center,
    BezierCurve,

-    plotattr
+    plotattr,
+    scalefontsize,
+    scalefontsizes,
+    resetfontsizes
+

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

@@ -161,6 +172,26 @@ using .PlotMeasures
 import .PlotMeasures: Length, AbsoluteLength, Measure, width, height
 # ---------------------------------------------------------

+import RecipesPipeline
+import RecipesPipeline: SliceIt,
+    DefaultsDict,
+    Formatted,
+    AbstractSurface,
+    Surface,
+    Volume,
+    is3d,
+    is_surface,
+    needs_3d_axes,
+    group_as_matrix, # for StatsPlots
+    reset_kw!,
+    pop_kw!,
+    scale_func,
+    inverse_scale_func,
+    unzip,
+    dateformatter,
+    datetimeformatter,
+    timeformatter
+
 include("types.jl")
 include("utils.jl")
 include("components.jl")
@@ -169,7 +200,6 @@ include("args.jl")
 include("themes.jl")
 include("plot.jl")
 include("pipeline.jl")
-include("series.jl")
 include("layouts.jl")
 include("subplots.jl")
 include("recipes.jl")
@@ -187,7 +217,7 @@ include("backends/plotly.jl")
 include("backends/gr.jl")
 include("backends/web.jl")

-include("shorthands.jl") 
+include("shorthands.jl")

 let PlotOrSubplot = Union{Plot, Subplot}
    global title!(plt::PlotOrSubplot, s::AbstractString; kw...)                  = plot!(plt; title = s, kw...)
@@ -220,4 +250,7 @@ end

 const CURRENT_BACKEND = CurrentBackend(:none)

+include("precompile.jl")
+_precompile_()
+
 end # module
@@ -24,6 +24,7 @@ end
 giffn() = (isijulia() ? "tmp.gif" : tempname()*".gif")
 movfn() = (isijulia() ? "tmp.mov" : tempname()*".mov")
 mp4fn() = (isijulia() ? "tmp.mp4" : tempname()*".mp4")
+webmfn() = (isijulia() ? "tmp.webm" : tempname()*".webm")

 mutable struct FrameIterator
    itr
@@ -60,31 +61,44 @@ end

 file_extension(fn) = Base.Filesystem.splitext(fn)[2][2:end]

-gif(anim::Animation, fn = giffn(); kw...) = buildanimation(anim.dir, fn; kw...)
-mov(anim::Animation, fn = movfn(); kw...) = buildanimation(anim.dir, fn, false; kw...)
-mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim.dir, fn, false; kw...)
+gif(anim::Animation, fn = giffn(); kw...) = buildanimation(anim, fn; kw...)
+mov(anim::Animation, fn = movfn(); kw...) = buildanimation(anim, fn, false; kw...)
+mp4(anim::Animation, fn = mp4fn(); kw...) = buildanimation(anim, fn, false; kw...)
+webm(anim::Animation, fn = webmfn(); kw...) = buildanimation(anim, fn, false; kw...)

+ffmpeg_framerate(fps) = "$fps"
+ffmpeg_framerate(fps::Rational) = "$(fps.num)/$(fps.den)"

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

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

    show_msg && @info("Saved animation to ", fn)
@@ -96,13 +110,27 @@ end
 # write out html to view the gif
 function Base.show(io::IO, ::MIME"text/html", agif::AnimatedGif)
    ext = file_extension(agif.filename)
-    write(io, if ext == "gif"
-        "<img src=\"$(relpath(agif.filename))\" />"
-    elseif ext in ("mov", "mp4")
-        "<video controls><source src=\"$(relpath(agif.filename)) type=\"video/$ext\"></video>"
+    if ext == "gif"
+        html = "<img src=\"data:image/gif;base64," * base64encode(read(agif.filename)) * "\" />"
+    elseif ext in ("mov", "mp4","webm")
+        mimetype = ext == "mov" ? "video/quicktime" : "video/$ext"
+        html = "<video controls><source src=\"data:$mimetype;base64," *
+               base64encode(read(agif.filename)) *
+               "\" type = \"$mimetype\"></video>"
    else
        error("Cannot show animation with extension $ext: $agif")
-    end)
+    end
+
+    write(io, html)
+    return nothing
+end
+
+
+# Only gifs can be shown via image/gif
+Base.showable(::MIME"image/gif", agif::AnimatedGif) = file_extension(agif.filename) == "gif"
+
+function Base.show(io::IO, ::MIME"image/gif", agif::AnimatedGif)
+    open(fio-> write(io, fio), agif.filename)
 end


@@ -141,16 +169,16 @@ function _animate(forloop::Expr, args...; callgif = false)
    error("Unsupported animate filter: $args")
  end

-  push!(block.args, :(if $filterexpr; frame($animsym); end))
+  push!(block.args, :(if $filterexpr; Plots.frame($animsym); end))
  push!(block.args, :(global $countersym += 1))

  # add a final call to `gif(anim)`?
-  retval = callgif ? :(gif($animsym)) : animsym
+  retval = callgif ? :(Plots.gif($animsym)) : animsym

  # full expression:
  esc(quote
    $freqassert             # if filtering, check frequency is an Integer > 0
-    $animsym = Animation()  # init animation object
+    $animsym = Plots.Animation()  # init animation object
    global $countersym = 1         # init iteration counter
    $forloop                # for loop, saving a frame after each iteration
    $retval                 # return the animation object, or the gif
@@ -42,6 +42,7 @@ const _arg_desc = KW(
 :arrow             	=> "nothing (no arrows), Bool (if true, default arrows), Arrow object, or arg(s) that could be style or head length/widths.  Defines arrowheads that should be displayed at the end of path line segments (just before a NaN and the last non-NaN point).  Used in quiverplot, streamplot, or similar.",
 :normalize         	=> "Bool or Symbol. Histogram normalization mode. Possible values are: false/:none (no normalization, default), true/:pdf (normalize to a discrete Probability Density Function, where the total area of the bins is 1), :probability (bin heights sum to 1) and :density (the area of each bin, rather than the height, is equal to the counts - useful for uneven bin sizes).",
 :weights           	=> "AbstractVector. Used in histogram types for weighted counts.",
+:show_empty_bins    => "Bool. Whether empty bins in a 2D histogram are colored as 0 (true), or transparent (the default).",
 :contours          	=> "Bool. Add contours to the side-grids of 3D plots?  Used in surface/wireframe.",
 :contour_labels         => "Bool. Show labels at the contour lines?",
 :match_dimensions  	=> "Bool. For heatmap types... should the first dimension of a matrix (rows) correspond to the first dimension of the plot (x-axis)?  The default is false, which matches the behavior of Matplotlib, Plotly, and others.  Note: when passing a function for z, the function should still map `(x,y) -> z`.",
@@ -49,6 +50,7 @@ const _arg_desc = KW(
 :series_annotations     => "AbstractVector of String or PlotText.  These are annotations which are mapped to data points/positions.",
 :primary                => "Bool.  Does this count as a 'real series'?  For example, you could have a path (primary), and a scatter (secondary) as 2 separate series, maybe with different data (see sticks recipe for an example).  The secondary series will get the same color, etc as the primary.",
 :hover 	        	=> "nothing or vector of strings. Text to display when hovering over each data point.",
+:colorbar_entry   => "Bool.  Include this series in the color bar?  Set to `false` to exclude.",

 # plot args
 :plot_title               => "String. Title for the whole plot (not the subplots) (Note: Not currently implemented)",
@@ -63,16 +65,18 @@ const _arg_desc = KW(
 :link                     => "Symbol.  How/whether to link axis limits between subplots. Values: `:none`, `:x` (x axes are linked by columns), `:y` (y axes are linked by rows), `:both` (x and y are linked), `:all` (every subplot is linked together regardless of layout position).",
 :overwrite_figure         => "Bool.  Should we reuse the same GUI window/figure when plotting (true) or open a new one (false).",
 :html_output_format       => "Symbol.  When writing html output, what is the format?  `:png` and `:svg` are currently supported.",
+:tex_output_standalone    => "Bool. When writing tex output, should the source include a preamble for a standalone document class.",
 :inset_subplots           => "nothing or vector of 2-tuple (parent,bbox).  optionally pass a vector of (parent,bbox) tuples which are the parent layout and the relative bounding box of inset subplots",
 :dpi 			  => "Number.  Dots Per Inch of output figures",
 :thickness_scaling        => "Number. Scale for the thickness of all line elements like lines, borders, axes, grid lines, ... defaults to 1.",
 :display_type             => "Symbol (`:auto`, `:gui`, or `:inline`).  When supported, `display` will either open a GUI window or plot inline.",
-:extra_kwargs 	          => "KW (Dict{Symbol,Any}).  Pass a map of extra keyword args which may be specific to a backend.",
+:extra_kwargs 	          => "Either one of (`:plot`, `:subplot`, `:series`) to specify for which element extra keyword args are collected or a KW (Dict{Symbol,Any}) to pass a map of extra keyword args which may be specific to a backend. Default: `:series`.\n Example: `pgfplotsx(); scatter(1:5, extra_kwargs=Dict(:subplot=>Dict(\"axis line shift\" => \"10pt\"))`",
 :fontfamily               => "String or Symbol.  Default font family for title, legend entries, tick labels and guides",
+:warn_on_unsupported      => "Bool. Warn on unsupported attributes, series types and marker shapes",

 # subplot args
 :title                    => "String. Subplot title.",
-:title_location           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
+:titlelocation           => "Symbol. Position of subplot title. Values: `:left`, `:center`, `:right`",
 :titlefontfamily          => "String or Symbol. Font family of subplot title.",
 :titlefontsize            => "Integer. Font pointsize of subplot title.",
 :titlefonthalign          => "Symbol. Font horizontal alignment of subplot title: :hcenter, :left, :right or :center",
@@ -86,16 +90,24 @@ const _arg_desc = KW(
 :foreground_color_legend  => "Color Type or `:match` (matches `:foreground_color_subplot`).  Foreground color of the legend.",
 :foreground_color_title   => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of subplot title.",
 :color_palette            => "Vector of colors (cycle through) or color gradient (generate list from gradient) or `:auto` (generate a color list using `Colors.distiguishable_colors` and custom seed colors chosen to contrast with the background).  The color palette is a color list from which series colors are automatically chosen.",
-:legend                   => "Bool (show the legend?) or Symbol (legend position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:inside`, `:legend`, `:topright`, `:topleft`, `:bottomleft`, `:bottomright` (note: only some may be supported in each backend)",
+:legend                   => "Bool (show the legend?) or (x,y) tuple or Symbol (legend position). Bottom left corner of legend is placed at (x,y).  Symbol values: `:none`; `:best`; `:inline`; `:inside`; `:legend`; any valid combination of `:(outer ?)(top/bottom ?)(right/left ?)`, i.e.: `:top`, `:topright`, `:outerleft`, `:outerbottomright` ... (note: only some may be supported in each backend)",
 :legendfontfamily         => "String or Symbol. Font family of legend entries.",
 :legendfontsize           => "Integer. Font pointsize of legend entries.",
 :legendfonthalign         => "Symbol. Font horizontal alignment of legend entries: :hcenter, :left, :right or :center",
 :legendfontvalign         => "Symbol. Font vertical alignment of legend entries: :vcenter, :top, :bottom or :center",
 :legendfontrotation       => "Real. Font rotation of legend entries",
 :legendfontcolor          => "Color Type. Font color of legend entries",
+:legendtitle              => "String. Legend title.",
+:legendtitlefontfamily    => "String or Symbol. Font family of the legend title.",
+:legendtitlefontsize           => "Integer. Font pointsize the legend title.",
+:legendtitlefonthalign         => "Symbol. Font horizontal alignment of the legend title: :hcenter, :left, :right or :center",
+:legendtitlefontvalign         => "Symbol. Font vertical alignment of the legend title: :vcenter, :top, :bottom or :center",
+:legendtitlefontrotation       => "Real. Font rotation of the legend title",
+:legendtitlefontcolor          => "Color Type. Font color of the legend title",
 :colorbar                 => "Bool (show the colorbar?) or Symbol (colorbar position).  Symbol values: `:none`, `:best`, `:right`, `:left`, `:top`, `:bottom`, `:legend` (matches legend value) (note: only some may be supported in each backend)",
-:clims 					  => "`:auto` or NTuple{2,Number}.  Fixes the limits of the colorbar.",
+:clims 					  => "`:auto`, NTuple{2,Number}, or a function that takes series data in and returns NTuple{2,Number}.  Fixes the limits of the colorbar.",
 :legendfont               => "Font. Font of legend items.",
+:legendtitlefont          => "Font. Font of the legend title.",
 :annotations              => "(x,y,text) tuple(s).  Can be a single tuple or a list of them.  Text can be String or PlotText (created with `text(args...)`)  Add one-off text annotations at the x,y coordinates.",
 :projection               => "Symbol or String.  '3d' or 'polar'",
 :aspect_ratio             => "Symbol (:equal) or Number. Plot area is resized so that 1 y-unit is the same size as `aspect_ratio` x-units.",
@@ -149,4 +161,5 @@ const _arg_desc = KW(
 :tick_direction           => "Symbol.  Direction of the ticks. `:in` or `:out`",
 :showaxis                 => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
 :widen                    => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
+:draw_arrow               => "Bool. Draw arrow at the end of the axis.",
 )
@@ -7,29 +7,20 @@
 # -------------------------------------------------------------------------

 function Axis(sp::Subplot, letter::Symbol, args...; kw...)
-    # init with values from _plot_defaults
-    plotattributes = KW(
+    explicit = KW(
        :letter => letter,
-        # :extrema => (Inf, -Inf),
        :extrema => Extrema(),
        :discrete_map => Dict(),   # map discrete values to discrete indices
        :continuous_values => zeros(0),
+        :discrete_values => [],
        :use_minor => false,
        :show => true,  # show or hide the axis? (useful for linked subplots)
    )

-    # get defaults from letter version, unless match
-    for (k,v) in _axis_defaults
-        lk = Symbol(letter, k)
-        lv = _axis_defaults_byletter[lk]
-        plotattributes[k] = (lv == :match ? v : lv)
-    end
-
-    # merge!(plotattributes, _axis_defaults)
-    plotattributes[:discrete_values] = []
+    attr = DefaultsDict(explicit, _axis_defaults_byletter[letter])

    # update the defaults
-    attr!(Axis([sp], plotattributes), args...; kw...)
+    attr!(Axis([sp], attr), args...; kw...)
 end

 function get_axis(sp::Subplot, letter::Symbol)
@@ -41,10 +32,9 @@ function get_axis(sp::Subplot, letter::Symbol)
    end::Axis
 end

-function process_axis_arg!(plotattributes::KW, arg, letter = "")
+function process_axis_arg!(plotattributes::AKW, arg, letter = "")
    T = typeof(arg)
    arg = get(_scaleAliases, arg, arg)
-
    if typeof(arg) <: Font
        plotattributes[Symbol(letter,:tickfont)] = arg
        plotattributes[Symbol(letter,:guidefont)] = arg
@@ -67,7 +57,7 @@ function process_axis_arg!(plotattributes::KW, arg, letter = "")
    elseif T <: AVec
        plotattributes[Symbol(letter,:ticks)] = arg

-    elseif arg == nothing
+    elseif arg === nothing
        plotattributes[Symbol(letter,:ticks)] = []

    elseif T <: Bool || arg in _allShowaxisArgs
@@ -93,6 +83,9 @@ function attr!(axis::Axis, args...; kw...)
        process_axis_arg!(plotattributes, arg)
    end

+    # then preprocess keyword arguments
+    RecipesPipeline.preprocess_attributes!(KW(kw))
+
    # then override for any keywords... only those keywords that already exists in plotattributes
    for (k,v) in kw
        if haskey(plotattributes, k)
@@ -117,47 +110,25 @@ end

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

-Base.show(io::IO, axis::Axis) = dumpdict(axis.plotattributes, "Axis", true)
+Base.show(io::IO, axis::Axis) = dumpdict(io, axis.plotattributes, "Axis", true)
 # Base.getindex(axis::Axis, k::Symbol) = getindex(axis.plotattributes, k)
 Base.setindex!(axis::Axis, v, ks::Symbol...) = setindex!(axis.plotattributes, v, ks...)
 Base.haskey(axis::Axis, k::Symbol) = haskey(axis.plotattributes, k)
 ignorenan_extrema(axis::Axis) = (ex = axis[:extrema]; (ex.emin, ex.emax))

-
-const _scale_funcs = Dict{Symbol,Function}(
-    :log10 => log10,
-    :log2 => log2,
-    :ln => log,
-)
-const _inv_scale_funcs = Dict{Symbol,Function}(
-    :log10 => exp10,
-    :log2 => exp2,
-    :ln => exp,
-)
-
-# const _label_func = Dict{Symbol,Function}(
-#     :log10 => x -> "10^$x",
-#     :log2 => x -> "2^$x",
-#     :ln => x -> "e^$x",
-# )
-
 const _label_func = Dict{Symbol,Function}(
    :log10 => x -> "10^$x",
    :log2 => x -> "2^$x",
    :ln => x -> "e^$x",
 )
-
-
-scalefunc(scale::Symbol) = x -> get(_scale_funcs, scale, identity)(Float64(x))
-invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float64(x))
 labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)

-function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
-    amin,amax = axis_limits(axis)
+function optimal_ticks_and_labels(sp::Subplot, axis::Axis, ticks = nothing)
+    amin, amax = axis_limits(sp, axis[:letter])

    # scale the limits
    scale = axis[:scale]
-    sf = scalefunc(scale)
+    sf = RecipesPipeline.scale_func(scale)

    # If the axis input was a Date or DateTime use a special logic to find
    # "round" Date(Time)s as ticks
@@ -166,8 +137,8 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
    # or DateTime) is chosen based on the time span between amin and amax
    # rather than on the input format
    # TODO: maybe: non-trivial scale (:ln, :log2, :log10) for date/datetime
-    if ticks == nothing && scale == :identity
-        if axis[:formatter] == dateformatter
+    if ticks === nothing && scale == :identity
+        if axis[:formatter] == RecipesPipeline.dateformatter
            # optimize_datetime_ticks returns ticks and labels(!) based on
            # integers/floats corresponding to the DateTime type. Thus, the axes
            # limits, which resulted from converting the Date type to integers,
@@ -178,13 +149,13 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
                k_min = 2, k_max = 4)
            # Now the ticks are converted back to floats corresponding to Dates.
            return ticks / 864e5, labels
-        elseif axis[:formatter] == datetimeformatter
+        elseif axis[:formatter] == RecipesPipeline.datetimeformatter
            return optimize_datetime_ticks(amin, amax; k_min = 2, k_max = 4)
        end
    end

    # get a list of well-laid-out ticks
-    if ticks == nothing
+    if ticks === nothing
        scaled_ticks = optimize_ticks(
            sf(amin),
            sf(amax);
@@ -202,22 +173,18 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
            # chosen  ticks is not too much bigger than amin - amax:
            strict_span = false,
        )
-        axis[:lims] = map(invscalefunc(scale), (viewmin, viewmax))
+        axis[:lims] = map(RecipesPipeline.inverse_scale_func(scale), (viewmin, viewmax))
    else
        scaled_ticks = map(sf, (filter(t -> amin <= t <= amax, ticks)))
    end
-    unscaled_ticks = map(invscalefunc(scale), scaled_ticks)
+    unscaled_ticks = map(RecipesPipeline.inverse_scale_func(scale), scaled_ticks)

    labels = if any(isfinite, unscaled_ticks)
        formatter = axis[:formatter]
-        if formatter == :auto
-            # the default behavior is to make strings of the scaled values and then apply the labelfunc
-            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :auto))
-        elseif formatter == :plain
-            # Leave the numbers in plain format
-            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :plain))
-        elseif formatter == :scientific
-            Showoff.showoff(unscaled_ticks, :scientific)
+        if formatter in (:auto, :plain, :scientific, :engineering)
+            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, formatter))
+        elseif formatter == :latex
+            map(x -> string("\$", replace(convert_sci_unicode(x), '×' => "\\times"), "\$"), Showoff.showoff(unscaled_ticks, :auto))
        else
            # there was an override for the formatter... use that on the unscaled ticks
            map(formatter, unscaled_ticks)
@@ -238,9 +205,9 @@ function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
 end

 # return (continuous_values, discrete_values) for the ticks on this axis
-function get_ticks(axis::Axis)
+function get_ticks(sp::Subplot, axis::Axis)
    ticks = _transform_ticks(axis[:ticks])
-    ticks in (nothing, false) && return nothing
+    ticks in (:none, nothing, false) && return nothing

    # treat :native ticks as :auto
    ticks = ticks == :native ? :auto : ticks
@@ -251,7 +218,7 @@ function get_ticks(axis::Axis)
            # discrete ticks...
            n = length(dvals)
            rng = if ticks == :auto
-                Int[round(Int,i) for i in range(1, stop=n, length=15)]
+                Int[round(Int,i) for i in range(1, stop=n, length=min(n,15))]
            else # if ticks == :all
                1:n
            end
@@ -261,7 +228,7 @@ function get_ticks(axis::Axis)
            (collect(0:pi/4:7pi/4), string.(0:45:315))
        else
            # compute optimal ticks and labels
-            optimal_ticks_and_labels(axis)
+            optimal_ticks_and_labels(sp, axis)
        end
    elseif typeof(ticks) <: Union{AVec, Int}
        if !isempty(dvals) && typeof(ticks) <: Int
@@ -269,7 +236,7 @@ function get_ticks(axis::Axis)
            axis[:continuous_values][rng], dvals[rng]
        else
            # override ticks, but get the labels
-            optimal_ticks_and_labels(axis, ticks)
+            optimal_ticks_and_labels(sp, axis, ticks)
        end
    elseif typeof(ticks) <: NTuple{2, Any}
        # assuming we're passed (ticks, labels)
@@ -286,16 +253,16 @@ _transform_ticks(ticks) = ticks
 _transform_ticks(ticks::AbstractArray{T}) where T <: Dates.TimeType = Dates.value.(ticks)
 _transform_ticks(ticks::NTuple{2, Any}) = (_transform_ticks(ticks[1]), ticks[2])

-function get_minor_ticks(axis,ticks)
-    axis[:minorticks] in (nothing, false) && !axis[:minorgrid] && return nothing
+function get_minor_ticks(sp, axis, ticks)
+    axis[:minorticks] in (:none, nothing, false) && !axis[:minorgrid] && return nothing
    ticks = ticks[1]
    length(ticks) < 2 && return nothing

-    amin, amax = axis_limits(axis)
+    amin, amax = axis_limits(sp, axis[:letter])
    #Add one phantom tick either side of the ticks to ensure minor ticks extend to the axis limits
    if length(ticks) > 2
        ratio = (ticks[3] - ticks[2])/(ticks[2] - ticks[1])
-    elseif axis[:scale] == :none
+    elseif axis[:scale] in (:none, :identity)
        ratio = 1
    else
        return nothing
@@ -309,7 +276,9 @@ function get_minor_ticks(axis,ticks)
    minorticks = typeof(ticks[1])[]
    for (i,hi) in enumerate(ticks[2:end])
        lo = ticks[i]
-        append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
+        if isfinite(lo) && isfinite(hi) && hi > lo
+            append!(minorticks,collect(lo + (hi-lo)/n :(hi-lo)/n: hi - (hi-lo)/2n))
+        end
    end
    minorticks[amin .<= minorticks .<= amax]
 end
@@ -357,7 +326,7 @@ function expand_extrema!(axis::Axis, v::AVec{N}) where N<:Number
 end


-function expand_extrema!(sp::Subplot, plotattributes::KW)
+function expand_extrema!(sp::Subplot, plotattributes::AKW)
    vert = isvertical(plotattributes)

    # first expand for the data
@@ -382,7 +351,7 @@ function expand_extrema!(sp::Subplot, plotattributes::KW)
                data = plotattributes[letter] = Surface(Matrix{Float64}(data.surf))
            end
            expand_extrema!(axis, data)
-        elseif data != nothing
+        elseif data !== nothing
            # TODO: need more here... gotta track the discrete reference value
            #       as well as any coord offset (think of boxplot shape coords... they all
            #       correspond to the same x-value)
@@ -399,10 +368,10 @@ function expand_extrema!(sp::Subplot, plotattributes::KW)

    # expand for fillrange
    fr = plotattributes[:fillrange]
-    if fr == nothing && plotattributes[:seriestype] == :bar
+    if fr === nothing && plotattributes[:seriestype] == :bar
        fr = 0.0
    end
-    if fr != nothing && !all3D(plotattributes)
+    if fr !== nothing && !RecipesPipeline.is3d(plotattributes)
        axis = sp.attr[vert ? :yaxis : :xaxis]
        if typeof(fr) <: Tuple
            for fri in fr
@@ -419,7 +388,7 @@ function expand_extrema!(sp::Subplot, plotattributes::KW)
        data = plotattributes[dsym]

        bw = plotattributes[:bar_width]
-        if bw == nothing
+        if bw === nothing
            bw = plotattributes[:bar_width] = _bar_width * ignorenan_minimum(filter(x->x>0,diff(sort(data))))
        end
        axis = sp.attr[Symbol(dsym, :axis)]
@@ -447,7 +416,7 @@ end

 # push the limits out slightly
 function widen(lmin, lmax, scale = :identity)
-    f, invf = scalefunc(scale), invscalefunc(scale)
+    f, invf = RecipesPipeline.scale_func(scale), RecipesPipeline.inverse_scale_func(scale)
    span = f(lmax) - f(lmin)
    # eps = NaNMath.max(1e-16, min(1e-2span, 1e-10))
    eps = NaNMath.max(1e-16, 0.03span)
@@ -479,16 +448,19 @@ function round_limits(amin,amax)
 end

 # using the axis extrema and limit overrides, return the min/max value for this axis
-function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis))
+function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(letter, :axis)]), consider_aspect = true)
+    axis = sp[Symbol(letter, :axis)]
    ex = axis[:extrema]
    amin, amax = ex.emin, ex.emax
    lims = axis[:lims]
-    if (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
-        if isfinite(lims[1])
-            amin = lims[1]
+    has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
+    if has_user_lims
+        lmin, lmax = lims
+        if lmin != :auto && isfinite(lmin)
+            amin = lmin
        end
-        if isfinite(lims[2])
-            amax = lims[2]
+        if lmax != :auto && isfinite(lmax)
+            amax = lmax
        end
    end
    if amax <= amin && isfinite(amin)
@@ -497,12 +469,12 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
    if !isfinite(amin) && !isfinite(amax)
        amin, amax = 0.0, 1.0
    end
-    if ispolar(axis.sps[1])
+    amin, amax = if ispolar(axis.sps[1])
        if axis[:letter] == :x
            amin, amax = 0, 2pi
        elseif lims == :auto
            #widen max radius so ticks dont overlap with theta axis
-            amin, amax + 0.1 * abs(amax - amin)
+            0, amax + 0.1 * abs(amax - amin)
        else
            amin, amax
        end
@@ -513,6 +485,32 @@ function axis_limits(axis::Axis, should_widen::Bool = default_should_widen(axis)
    else
        amin, amax
    end
+
+    if !has_user_lims && consider_aspect && letter in (:x, :y) && !(sp[:aspect_ratio] in (:none, :auto) || RecipesPipeline.is3d(:sp))
+        aspect_ratio = isa(sp[:aspect_ratio], Number) ? sp[:aspect_ratio] : 1
+        plot_ratio = height(plotarea(sp)) / width(plotarea(sp))
+        dist = amax - amin
+
+        if letter == :x
+            yamin, yamax = axis_limits(sp, :y, default_should_widen(sp[:yaxis]), false)
+            ydist = yamax - yamin
+            axis_ratio = aspect_ratio * ydist / dist
+            factor = axis_ratio / plot_ratio
+        else
+            xamin, xamax = axis_limits(sp, :x, default_should_widen(sp[:xaxis]), false)
+            xdist = xamax - xamin
+            axis_ratio = aspect_ratio * dist / xdist
+            factor = plot_ratio / axis_ratio
+        end
+
+        if factor > 1
+            center = (amin + amax) / 2
+            amin = center + factor * (amin - center)
+            amax = center + factor * (amax - center)
+        end
+    end
+
+    return amin, amax
 end

 # -------------------------------------------------------------------------
@@ -545,10 +543,10 @@ end

 # add the discrete value for each item.  return the continuous values and the indices
 function discrete_value!(axis::Axis, v::AVec)
-    n = length(v)
-    cvec = zeros(n)
-    discrete_indices = zeros(Int, n)
-    for i=1:n
+    n = eachindex(v)
+    cvec = zeros(axes(v))
+    discrete_indices = similar(Array{Int}, axes(v))
+    for i in n
        cvec[i], discrete_indices[i] = discrete_value!(axis, v[i])
    end
    cvec, discrete_indices
@@ -556,10 +554,10 @@ end

 # add the discrete value for each item.  return the continuous values and the indices
 function discrete_value!(axis::Axis, v::AMat)
-    n,m = size(v)
-    cmat = zeros(n,m)
-    discrete_indices = zeros(Int, n, m)
-    for i=1:n, j=1:m
+    n,m = axes(v)
+    cmat = zeros(axes(v))
+    discrete_indices = similar(Array{Int}, axes(v))
+    for i in n, j in m
        cmat[i,j], discrete_indices[i,j] = discrete_value!(axis, v[i,j])
    end
    cmat, discrete_indices
@@ -571,27 +569,15 @@ end

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

-function pie_labels(sp::Subplot, series::Series)
-    plotattributes = series.plotattributes
-    if haskey(plotattributes,:x_discrete_indices)
-        dvals = sp.attr[:xaxis].plotattributes[:discrete_values]
-        [dvals[idx] for idx in plotattributes[:x_discrete_indices]]
-    else
-        plotattributes[:x]
-    end
-end
-
-# -------------------------------------------------------------------------
-
 # compute the line segments which should be drawn for this axis
 function axis_drawing_info(sp::Subplot)
    xaxis, yaxis = sp[:xaxis], sp[:yaxis]
-    xmin, xmax = axis_limits(xaxis)
-    ymin, ymax = axis_limits(yaxis)
-    xticks = get_ticks(xaxis)
-    yticks = get_ticks(yaxis)
-    xminorticks = get_minor_ticks(xaxis,xticks)
-    yminorticks = get_minor_ticks(yaxis,yticks)
+    xmin, xmax = axis_limits(sp, :x)
+    ymin, ymax = axis_limits(sp, :y)
+    xticks = get_ticks(sp, xaxis)
+    yticks = get_ticks(sp, yaxis)
+    xminorticks = get_minor_ticks(sp, xaxis, xticks)
+    yminorticks = get_minor_ticks(sp, yaxis, yticks)
    xaxis_segs = Segments(2)
    yaxis_segs = Segments(2)
    xtick_segs = Segments(2)
@@ -605,126 +591,370 @@ function axis_drawing_info(sp::Subplot)

    if sp[:framestyle] != :none
        # xaxis
+        y1, y2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, ymin) : (ymin, ymax)
+        end
        if xaxis[:showaxis]
            if sp[:framestyle] != :grid
-                y1, y2 = if sp[:framestyle] in (:origin, :zerolines)
-                    0.0, 0.0
-                else
-                    xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, ymin) : (ymin, ymax)
-                end
                push!(xaxis_segs, (xmin, y1), (xmax, y1))
                # don't show the 0 tick label for the origin framestyle
-                if sp[:framestyle] == :origin && !(xticks in (nothing,false)) && length(xticks) > 1
+                if sp[:framestyle] == :origin && !(xticks in (:none, nothing, false)) && length(xticks) > 1
                    showticks = xticks[1] .!= 0
                    xticks = (xticks[1][showticks], xticks[2][showticks])
                end
            end
            sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2), (xmax, y2)) # top spine
        end
-        if !(xaxis[:ticks] in (nothing, false))
-            f = scalefunc(yaxis[:scale])
-            invf = invscalefunc(yaxis[:scale])
-            ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
-            t1 = invf(f(ymin) + 0.015 * (f(ymax) - f(ymin)) * ticks_in)
-            t2 = invf(f(ymax) - 0.015 * (f(ymax) - f(ymin)) * ticks_in)
-            t3 = invf(f(0) + 0.015 * (f(ymax) - f(ymin)) * ticks_in)
+        if !(xaxis[:ticks] in (:none, nothing, false))
+            f = RecipesPipeline.scale_func(yaxis[:scale])
+            invf = RecipesPipeline.inverse_scale_func(yaxis[:scale])
+            tick_start, tick_stop = if sp[:framestyle] == :origin
+                t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
+                (-t, t)
+            else
+                ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
+                t = invf(f(y1) + 0.012 * (f(y2) - f(y1)) * ticks_in)
+                (y1, t)
+            end

            for xtick in xticks[1]
                if xaxis[:showaxis]
-                    tick_start, tick_stop = if sp[:framestyle] == :origin
-                        (0, t3)
-                    else
-                        xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, t2) : (ymin, t1)
-                    end
                    push!(xtick_segs, (xtick, tick_start), (xtick, tick_stop)) # bottom tick
                end
-                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
                xaxis[:grid] && push!(xgrid_segs, (xtick, ymin), (xtick, ymax)) # vertical grid
            end
-        end
-        if !(xaxis[:minorticks] in (nothing, false)) || xaxis[:minorgrid]
-            f = scalefunc(yaxis[:scale])
-            invf = invscalefunc(yaxis[:scale])
-            ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
-            t1 = invf(f(ymin) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)
-            t2 = invf(f(ymax) - 0.01 * (f(ymax) - f(ymin)) * ticks_in)
-            t3 = invf(f(0) + 0.01 * (f(ymax) - f(ymin)) * ticks_in)

-            for xminortick in xminorticks
-                if xaxis[:showaxis]
-                    tick_start, tick_stop = if sp[:framestyle] == :origin
-                        (0, t3)
-                    else
-                        xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, t2) : (ymin, t1)
-                    end
-                    push!(xtick_segs, (xminortick, tick_start), (xminortick, tick_stop)) # bottom tick
+            if !(xaxis[:minorticks] in (:none, nothing, false)) || xaxis[:minorgrid]
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.006 * (f(ymax) - f(ymin)))
+                    (-t, t)
+                else
+                    t = invf(f(y1) + 0.006 * (f(y2) - f(y1)) * ticks_in)
+                    (y1, t)
+                end
+                for xtick in xminorticks
+                    if xaxis[:showaxis]
+                        push!(xtick_segs, (xtick, tick_start), (xtick, tick_stop)) # bottom tick
+                    end
+                    xaxis[:minorgrid] && push!(xminorgrid_segs, (xtick, ymin), (xtick, ymax)) # vertical grid
                end
-                # sp[:draw_axes_border] && push!(xaxis_segs, (xtick, ymax), (xtick, t2)) # top tick
-                xaxis[:minorgrid] && push!(xminorgrid_segs, (xminortick, ymin), (xminortick, ymax)) # vertical grid
            end
        end


        # yaxis
+        x1, x2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, xmin) : (xmin, xmax)
+        end
        if yaxis[:showaxis]
            if sp[:framestyle] != :grid
-                x1, x2 = if sp[:framestyle] in (:origin, :zerolines)
-                    0.0, 0.0
-                else
-                    xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, xmin) : (xmin, xmax)
-                end
                push!(yaxis_segs, (x1, ymin), (x1, ymax))
                # don't show the 0 tick label for the origin framestyle
-                if sp[:framestyle] == :origin && !(yticks in (nothing,false)) && length(yticks) > 1
+                if sp[:framestyle] == :origin && !(yticks in (:none, nothing,false)) && length(yticks) > 1
                    showticks = yticks[1] .!= 0
                    yticks = (yticks[1][showticks], yticks[2][showticks])
                end
            end
            sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin), (x2, ymax)) # right spine
        end
-        if !(yaxis[:ticks] in (nothing, false))
-            f = scalefunc(xaxis[:scale])
-            invf = invscalefunc(xaxis[:scale])
-            ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
-            t1 = invf(f(xmin) + 0.015 * (f(xmax) - f(xmin)) * ticks_in)
-            t2 = invf(f(xmax) - 0.015 * (f(xmax) - f(xmin)) * ticks_in)
-            t3 = invf(f(0) + 0.015 * (f(xmax) - f(xmin)) * ticks_in)
+        if !(yaxis[:ticks] in (:none, nothing, false))
+            f = RecipesPipeline.scale_func(xaxis[:scale])
+            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            tick_start, tick_stop = if sp[:framestyle] == :origin
+                t = invf(f(0) + 0.012 * (f(xmax) - f(xmin)))
+                (-t, t)
+            else
+                ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
+                t = invf(f(x1) + 0.012 * (f(x2) - f(x1)) * ticks_in)
+                (x1, t)
+            end

            for ytick in yticks[1]
                if yaxis[:showaxis]
-                    tick_start, tick_stop = if sp[:framestyle] == :origin
-                        (0, t3)
-                    else
-                        xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, t2) : (xmin, t1)
-                    end
                    push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
                end
-                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
                yaxis[:grid] && push!(ygrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
            end
-        end
-        if !(yaxis[:minorticks] in (nothing, false)) || yaxis[:minorgrid]
-            f = scalefunc(xaxis[:scale])
-            invf = invscalefunc(xaxis[:scale])
-            ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
-            t1 = invf(f(xmin) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)
-            t2 = invf(f(xmax) - 0.01 * (f(xmax) - f(xmin)) * ticks_in)
-            t3 = invf(f(0) + 0.01 * (f(xmax) - f(xmin)) * ticks_in)

-            for ytick in yminorticks
-                if yaxis[:showaxis]
-                    tick_start, tick_stop = if sp[:framestyle] == :origin
-                        (0, t3)
-                    else
-                        xor(yaxis[:mirror], xaxis[:flip]) ? (xmax, t2) : (xmin, t1)
-                    end
-                    push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
+            if !(yaxis[:minorticks] in (:none, nothing, false)) || yaxis[:minorgrid]
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.006 * (f(xmax) - f(xmin)))
+                    (-t, t)
+                else
+                    t = invf(f(x1) + 0.006 * (f(x2) - f(x1)) * ticks_in)
+                    (x1, t)
+                end
+                for ytick in yminorticks
+                    if yaxis[:showaxis]
+                        push!(ytick_segs, (tick_start, ytick), (tick_stop, ytick)) # left tick
+                    end
+                    yaxis[:minorgrid] && push!(yminorgrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
                end
-                # sp[:draw_axes_border] && push!(yaxis_segs, (xmax, ytick), (t2, ytick)) # right tick
-                yaxis[:minorgrid] && push!(yminorgrid_segs, (xmin, ytick), (xmax, ytick)) # horizontal grid
            end
        end
    end

    xticks, yticks, xaxis_segs, yaxis_segs, xtick_segs, ytick_segs, xgrid_segs, ygrid_segs, xminorgrid_segs, yminorgrid_segs, xborder_segs, yborder_segs
 end
+
+
+function axis_drawing_info_3d(sp::Subplot)
+    xaxis, yaxis, zaxis = sp[:xaxis], sp[:yaxis], sp[:zaxis]
+    xmin, xmax = axis_limits(sp, :x)
+    ymin, ymax = axis_limits(sp, :y)
+    zmin, zmax = axis_limits(sp, :z)
+    xticks = get_ticks(sp, xaxis)
+    yticks = get_ticks(sp, yaxis)
+    zticks = get_ticks(sp, zaxis)
+    xminorticks = get_minor_ticks(sp, xaxis, xticks)
+    yminorticks = get_minor_ticks(sp, yaxis, yticks)
+    zminorticks = get_minor_ticks(sp, zaxis, zticks)
+    xaxis_segs = Segments(3)
+    yaxis_segs = Segments(3)
+    zaxis_segs = Segments(3)
+    xtick_segs = Segments(3)
+    ytick_segs = Segments(3)
+    ztick_segs = Segments(3)
+    xgrid_segs = Segments(3)
+    ygrid_segs = Segments(3)
+    zgrid_segs = Segments(3)
+    xminorgrid_segs = Segments(3)
+    yminorgrid_segs = Segments(3)
+    zminorgrid_segs = Segments(3)
+    xborder_segs = Segments(3)
+    yborder_segs = Segments(3)
+    zborder_segs = Segments(3)
+
+    if sp[:framestyle] != :none
+
+        # xaxis
+        y1, y2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(xaxis[:mirror], yaxis[:flip]) ? (ymax, ymin) : (ymin, ymax)
+        end
+        z1, z2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(xaxis[:mirror], zaxis[:flip]) ? (zmax, zmin) : (zmin, zmax)
+        end
+        if xaxis[:showaxis]
+            if sp[:framestyle] != :grid
+                push!(xaxis_segs, (xmin, y1, z1), (xmax, y1, z1))
+                # don't show the 0 tick label for the origin framestyle
+                if sp[:framestyle] == :origin && !(xticks in (:none, nothing, false)) && length(xticks) > 1
+                    showticks = xticks[1] .!= 0
+                    xticks = (xticks[1][showticks], xticks[2][showticks])
+                end
+            end
+            sp[:framestyle] in (:semi, :box) && push!(xborder_segs, (xmin, y2, z2), (xmax, y2, z2)) # top spine
+        end
+        if !(xaxis[:ticks] in (:none, nothing, false))
+            f = RecipesPipeline.scale_func(yaxis[:scale])
+            invf = RecipesPipeline.inverse_scale_func(yaxis[:scale])
+            tick_start, tick_stop = if sp[:framestyle] == :origin
+                t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
+                (-t, t)
+            else
+                ticks_in = xaxis[:tick_direction] == :out ? -1 : 1
+                t = invf(f(y1) + 0.012 * (f(y2) - f(y1)) * ticks_in)
+                (y1, t)
+            end
+
+            for xtick in xticks[1]
+                if xaxis[:showaxis]
+                    push!(xtick_segs, (xtick, tick_start, z1), (xtick, tick_stop, z1)) # bottom tick
+                end
+                if xaxis[:grid]
+                    if sp[:framestyle] in (:origin, :zerolines)
+                        push!(xgrid_segs, (xtick, ymin, 0.0), (xtick, ymax, 0.0))
+                        push!(xgrid_segs, (xtick, 0.0, zmin), (xtick, 0.0, zmax))
+                    else
+                        push!(xgrid_segs, (xtick, y1, z1), (xtick, y2, z1))
+                        push!(xgrid_segs, (xtick, y2, z1), (xtick, y2, z2))
+                    end
+                end
+            end
+
+            if !(xaxis[:minorticks] in (:none, nothing, false)) || xaxis[:minorgrid]
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.006 * (f(ymax) - f(ymin)))
+                    (-t, t)
+                else
+                    t = invf(f(y1) + 0.006 * (f(y2) - f(y1)) * ticks_in)
+                    (y1, t)
+                end
+                for xtick in xminorticks
+                    if xaxis[:showaxis]
+                        push!(xtick_segs, (xtick, tick_start, z1), (xtick, tick_stop, z1)) # bottom tick
+                    end
+                    if xaxis[:minorgrid]
+                        if sp[:framestyle] in (:origin, :zerolines)
+                            push!(xminorgrid_segs, (xtick, ymin, 0.0), (xtick, ymax, 0.0))
+                            push!(xminorgrid_segs, (xtick, 0.0, zmin), (xtick, 0.0, zmax))
+                        else
+                            push!(xminorgrid_segs, (xtick, y1, z1), (xtick, y2, z1))
+                            push!(xminorgrid_segs, (xtick, y2, z1), (xtick, y2, z2))
+                        end
+                    end
+                end
+            end
+        end
+
+
+        # yaxis
+        x1, x2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(yaxis[:mirror], xaxis[:flip]) ? (xmin, xmax) : (xmax, xmin)
+        end
+        z1, z2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(yaxis[:mirror], zaxis[:flip]) ? (zmax, zmin) : (zmin, zmax)
+        end
+        if yaxis[:showaxis]
+            if sp[:framestyle] != :grid
+                push!(yaxis_segs, (x1, ymin, z1), (x1, ymax, z1))
+                # don't show the 0 tick label for the origin framestyle
+                if sp[:framestyle] == :origin && !(yticks in (:none, nothing,false)) && length(yticks) > 1
+                    showticks = yticks[1] .!= 0
+                    yticks = (yticks[1][showticks], yticks[2][showticks])
+                end
+            end
+            sp[:framestyle] in (:semi, :box) && push!(yborder_segs, (x2, ymin, z2), (x2, ymax, z2)) # right spine
+        end
+        if !(yaxis[:ticks] in (:none, nothing, false))
+            f = RecipesPipeline.scale_func(xaxis[:scale])
+            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            tick_start, tick_stop = if sp[:framestyle] == :origin
+                t = invf(f(0) + 0.012 * (f(xmax) - f(xmin)))
+                (-t, t)
+            else
+                ticks_in = yaxis[:tick_direction] == :out ? -1 : 1
+                t = invf(f(x1) + 0.012 * (f(x2) - f(x1)) * ticks_in)
+                (x1, t)
+            end
+
+            for ytick in yticks[1]
+                if yaxis[:showaxis]
+                    push!(ytick_segs, (tick_start, ytick, z1), (tick_stop, ytick, z1)) # left tick
+                end
+                if yaxis[:grid]
+                    if sp[:framestyle] in (:origin, :zerolines)
+                        push!(ygrid_segs, (xmin, ytick, 0.0), (xmax, ytick, 0.0))
+                        push!(ygrid_segs, (0.0, ytick, zmin), (0.0, ytick, zmax))
+                    else
+                        push!(ygrid_segs, (x1, ytick, z1), (x2, ytick, z1))
+                        push!(ygrid_segs, (x2, ytick, z1), (x2, ytick, z2))
+                    end
+                end
+            end
+
+            if !(yaxis[:minorticks] in (:none, nothing, false)) || yaxis[:minorgrid]
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.006 * (f(xmax) - f(xmin)))
+                    (-t, t)
+                else
+                    t = invf(f(x1) + 0.006 * (f(x2) - f(x1)) * ticks_in)
+                    (x1, t)
+                end
+                for ytick in yminorticks
+                    if yaxis[:showaxis]
+                        push!(ytick_segs, (tick_start, ytick, z1), (tick_stop, ytick, z1)) # left tick
+                    end
+                    if yaxis[:minorgrid]
+                        if sp[:framestyle] in (:origin, :zerolines)
+                            push!(yminorgrid_segs, (xmin, ytick, 0.0), (xmax, ytick, 0.0))
+                            push!(yminorgrid_segs, (0.0, ytick, zmin), (0.0, ytick, zmax))
+                        else
+                            push!(yminorgrid_segs, (x1, ytick, z1), (x2, ytick, z1))
+                            push!(yminorgrid_segs, (x2, ytick, z1), (x2, ytick, z2))
+                        end
+                    end
+                end
+            end
+        end
+
+
+        # zaxis
+        x1, x2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(zaxis[:mirror], xaxis[:flip]) ? (xmax, xmin) : (xmin, xmax)
+        end
+        y1, y2 = if sp[:framestyle] in (:origin, :zerolines)
+            0.0, 0.0
+        else
+            xor(zaxis[:mirror], yaxis[:flip]) ? (ymax, ymin) : (ymin, ymax)
+        end
+        if zaxis[:showaxis]
+            if sp[:framestyle] != :grid
+                push!(zaxis_segs, (x1, y1, zmin), (x1, y1, zmax))
+                # don't show the 0 tick label for the origin framestyle
+                if sp[:framestyle] == :origin && !(zticks in (:none, nothing,false)) && length(zticks) > 1
+                    showticks = zticks[1] .!= 0
+                    zticks = (zticks[1][showticks], zticks[2][showticks])
+                end
+            end
+            sp[:framestyle] in (:semi, :box) && push!(zborder_segs, (x2, y2, zmin), (x2, y2, zmax))
+        end
+        if !(zaxis[:ticks] in (:none, nothing, false))
+            f = RecipesPipeline.scale_func(xaxis[:scale])
+            invf = RecipesPipeline.inverse_scale_func(xaxis[:scale])
+            tick_start, tick_stop = if sp[:framestyle] == :origin
+                t = invf(f(0) + 0.012 * (f(ymax) - f(ymin)))
+                (-t, t)
+            else
+                ticks_in = zaxis[:tick_direction] == :out ? -1 : 1
+                t = invf(f(y1) + 0.012 * (f(y2) - f(y1)) * ticks_in)
+                (y1, t)
+            end
+
+            for ztick in zticks[1]
+                if zaxis[:showaxis]
+                    push!(ztick_segs, (x1, tick_start, ztick), (x1, tick_stop, ztick)) # left tick
+                end
+                if zaxis[:grid]
+                    if sp[:framestyle] in (:origin, :zerolines)
+                        push!(zgrid_segs, (xmin, 0.0, ztick), (xmax, 0.0, ztick))
+                        push!(ygrid_segs, (0.0, ymin, ztick), (0.0, ymax, ztick))
+                    else
+                        push!(ygrid_segs, (x1, y1, ztick), (x1, y2, ztick))
+                        push!(ygrid_segs, (x1, y2, ztick), (x2, y2, ztick))
+                    end
+                end
+            end
+
+            if !(zaxis[:minorticks] in (:none, nothing, false)) || zaxis[:minorgrid]
+                tick_start, tick_stop = if sp[:framestyle] == :origin
+                    t = invf(f(0) + 0.006 * (f(ymax) - f(ymin)))
+                    (-t, t)
+                else
+                    t = invf(f(y1) + 0.006 * (f(y2) - f(y1)) * ticks_in)
+                    (y1, t)
+                end
+                for ztick in zminorticks
+                    if zaxis[:showaxis]
+                        push!(ztick_segs, (x1, tick_start, ztick), (x1, tick_stop, ztick)) # left tick
+                    end
+                    if zaxis[:minorgrid]
+                        if sp[:framestyle] in (:origin, :zerolines)
+                            push!(zminorgrid_segs, (xmin, 0.0, ztick), (xmax, 0.0, ztick))
+                            push!(zminorgrid_segs, (0.0, ymin, ztick), (0.0, ymax, ztick))
+                        else
+                            push!(zminorgrid_segs, (x1, y1, ztick), (x1, y2, ztick))
+                            push!(zminorgrid_segs, (x1, y2, ztick), (x2, y2, ztick))
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    xticks, yticks, zticks, xaxis_segs, yaxis_segs, zaxis_segs, xtick_segs, ytick_segs, ztick_segs, xgrid_segs, ygrid_segs, zgrid_segs, xminorgrid_segs, yminorgrid_segs, zminorgrid_segs, xborder_segs, yborder_segs, zborder_segs
+end
@@ -1,5 +1,3 @@
-using Pkg
-
 struct NoBackend <: AbstractBackend end

 const _backendType = Dict{Symbol, DataType}(:none => NoBackend)
@@ -30,14 +28,13 @@ macro init_backend(s)
    esc(quote
        struct $T <: AbstractBackend end
        export $sym
-        $sym(; kw...) = (default(; kw...); backend($T()))
+        $sym(; kw...) = (default(; reset = false, kw...); backend($T()))
        backend_name(::$T) = Symbol($str)
        backend_package_name(pkg::$T) = backend_package_name(Symbol($str))
        push!(_backends, Symbol($str))
        _backendType[Symbol($str)] = $T
        _backendSymbol[$T] = Symbol($str)
        _backend_packages[Symbol($str)] = Symbol($package_str)
-        # include("backends/" * $str * ".jl")
    end)
 end

@@ -75,9 +72,9 @@ end
 text_size(lab::AbstractString, sz::Number, rot::Number = 0) = text_size(length(lab), sz, rot)

 # account for the size/length/rotation of tick labels
-function tick_padding(axis::Axis)
-    ticks = get_ticks(axis)
-    if ticks == nothing
+function tick_padding(sp::Subplot, axis::Axis)
+    ticks = get_ticks(sp, axis)
+    if ticks === nothing
        0mm
    else
        vals, labs = ticks
@@ -105,11 +102,11 @@ end
 # Set the (left, top, right, bottom) minimum padding around the plot area
 # to fit ticks, tick labels, guides, colorbars, etc.
 function _update_min_padding!(sp::Subplot)
-    # TODO: something different when `is3d(sp) == true`
-    leftpad   = tick_padding(sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
+    # TODO: something different when `RecipesPipeline.is3d(sp) == true`
+    leftpad   = tick_padding(sp, sp[:yaxis]) + sp[:left_margin]   + guide_padding(sp[:yaxis])
    toppad    = sp[:top_margin]    + title_padding(sp)
    rightpad  = sp[:right_margin]
-    bottompad = tick_padding(sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])
+    bottompad = tick_padding(sp, sp[:xaxis]) + sp[:bottom_margin] + guide_padding(sp[:xaxis])

    # switch them?
    if sp[:xaxis][:mirror]
@@ -143,12 +140,7 @@ function _pick_default_backend()
    if env_default != ""
        sym = Symbol(lowercase(env_default))
        if sym in _backends
-            if sym in _initialized_backends
-                backend(sym)
-            else
-                @warn("You have set `PLOTS_DEFAULT_BACKEND=$env_default` but `$(backend_package_name(sym))` is not loaded.")
-                _fallback_default_backend()
-            end
+            backend(sym)
        else
            @warn("You have set PLOTS_DEFAULT_BACKEND=$env_default but it is not a valid backend package.  Choose from:\n\t" *
                 join(sort(_backends), "\n\t"))
@@ -196,11 +188,15 @@ function backend(sym::Symbol)
    end
 end

-const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse, :glvisualize]
+const _deprecated_backends = [:qwt, :winston, :bokeh, :gadfly, :immerse, :glvisualize, :pgfplots]

 function warn_on_deprecated_backend(bsym::Symbol)
    if bsym in _deprecated_backends
-        @warn("Backend $bsym has been deprecated.")
+        if bsym == :pgfplots
+            @warn("Backend $bsym has been deprecated. Use pgfplotsx instead.")
+        else
+            @warn("Backend $bsym has been deprecated.")
+        end
    end
 end

@@ -217,7 +213,7 @@ const _base_supported_args = [
    :seriestype,
    :seriescolor, :seriesalpha,
    :smooth,
-    :xerror, :yerror,
+    :xerror, :yerror, :zerror,
    :subplot,
    :x, :y, :z,
    :show, :size,
@@ -234,7 +230,7 @@ const _base_supported_args = [
    :subplot_index,
    :discrete_values,
    :projection,
-
+    :show_empty_bins
 ]

 function merge_with_base_supported(v::AVec)
@@ -257,6 +253,7 @@ end
@init_backend PlotlyJS
@init_backend GR
@init_backend PGFPlots
+@init_backend PGFPlotsX
@init_backend InspectDR
@init_backend HDF5

@@ -301,9 +298,6 @@ end

 _initialize_backend(pkg::GRBackend) = nothing

-_initialize_backend(pkg::PlotlyBackend) = nothing
-
-
 # ------------------------------------------------------------------------------
 # gr

@@ -332,7 +326,7 @@ const _gr_attr = merge_with_base_supported([
    :guidefontfamily, :guidefontsize, :guidefonthalign, :guidefontvalign,
    :guidefontrotation, :guidefontcolor,
    :grid, :gridalpha, :gridstyle, :gridlinewidth,
-    :legend, :legendtitle, :colorbar, :colorbar_title,
+    :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
    :fill_z, :line_z, :marker_z, :levels,
    :ribbon, :quiver,
    :orientation,
@@ -349,10 +343,18 @@ const _gr_attr = merge_with_base_supported([
    :contour_labels,
 ])
 const _gr_seriestype = [
-    :path, :scatter, :straightline,
-    :heatmap, :pie, :image,
-    :contour, :path3d, :scatter3d, :surface, :wireframe,
-    :shape
+    :path,
+    :scatter,
+    :straightline,
+    :heatmap,
+    :image,
+    :contour,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :wireframe,
+    :volume,
+    :shape,
 ]
 const _gr_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
 const _gr_marker = _allMarkers
@@ -362,6 +364,16 @@ is_marker_supported(::GRBackend, shape::Shape) = true
 # ------------------------------------------------------------------------------
 # plotly

+function _initialize_backend(pkg::PlotlyBackend)
+    try
+        @eval Main begin
+            import ORCA
+        end
+    catch
+        @info "For saving to png with the Plotly backend ORCA has to be installed."
+    end
+end
+
 const _plotly_attr = merge_with_base_supported([
    :annotations,
    :background_color_legend, :background_color_inside, :background_color_outside,
@@ -376,7 +388,7 @@ const _plotly_attr = merge_with_base_supported([
    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha, :markerstrokestyle,
    :fillrange, :fillcolor, :fillalpha,
    :bins,
-    :title, :title_location,
+    :title, :titlelocation,
    :titlefontfamily, :titlefontsize, :titlefonthalign, :titlefontvalign,
    :titlefontcolor,
    :legendfontfamily, :legendfontsize, :legendfontcolor,
@@ -386,7 +398,7 @@ const _plotly_attr = merge_with_base_supported([
    :guide, :lims, :ticks, :scale, :flip, :rotation,
    :tickfont, :guidefont, :legendfont,
    :grid, :gridalpha, :gridlinewidth,
-    :legend, :colorbar, :colorbar_title,
+    :legend, :colorbar, :colorbar_title, :colorbar_entry,
    :marker_z, :fill_z, :line_z, :levels,
    :ribbon, :quiver,
    :orientation,
@@ -406,9 +418,17 @@ const _plotly_attr = merge_with_base_supported([
  ])

 const _plotly_seriestype = [
-    :path, :scatter, :pie, :heatmap,
-    :contour, :surface, :wireframe, :path3d, :scatter3d, :shape, :scattergl,
-    :straightline
+    :path,
+    :scatter,
+    :heatmap,
+    :contour,
+    :surface,
+    :wireframe,
+    :path3d,
+    :scatter3d,
+    :shape,
+    :scattergl,
+    :straightline,
 ]
 const _plotly_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _plotly_marker = [
@@ -417,6 +437,8 @@ const _plotly_marker = [
 ]
 const _plotly_scale = [:identity, :log10]

+defaultOutputFormat(plt::Plot{Plots.PlotlyBackend}) = "html"
+
 # ------------------------------------------------------------------------------
 # pgfplots

@@ -457,7 +479,7 @@ const _pgfplots_attr = merge_with_base_supported([
 ])
 const _pgfplots_seriestype = [:path, :path3d, :scatter, :steppre, :stepmid, :steppost, :histogram2d, :ysticks, :xsticks, :contour, :shape, :straightline,]
 const _pgfplots_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon, :hline] #vcat(_allMarkers, Shape)
+const _pgfplots_marker = [:none, :auto, :circle, :rect, :diamond, :utriangle, :dtriangle, :cross, :xcross, :star5, :pentagon, :hline, :vline] #vcat(_allMarkers, Shape)
 const _pgfplots_scale = [:identity, :ln, :log2, :log10]

 # ------------------------------------------------------------------------------
@@ -501,7 +523,7 @@ const _pyplot_attr = merge_with_base_supported([
    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
    :fillrange, :fillcolor, :fillalpha,
    :bins, :bar_width, :bar_edges, :bar_position,
-    :title, :title_location, :titlefont,
+    :title, :titlelocation, :titlefont,
    :window_title,
    :guide, :guide_position, :lims, :ticks, :scale, :flip, :rotation,
    :titlefontfamily, :titlefontsize, :titlefontcolor,
@@ -509,7 +531,7 @@ const _pyplot_attr = merge_with_base_supported([
    :tickfontfamily, :tickfontsize, :tickfontcolor,
    :guidefontfamily, :guidefontsize, :guidefontcolor,
    :grid, :gridalpha, :gridstyle, :gridlinewidth,
-    :legend, :legendtitle, :colorbar,
+    :legend, :legendtitle, :colorbar, :colorbar_title, :colorbar_entry,
    :marker_z, :line_z, :fill_z,
    :levels,
    :ribbon, :quiver, :arrow,
@@ -522,7 +544,6 @@ const _pyplot_attr = merge_with_base_supported([
    :clims,
    :inset_subplots,
    :dpi,
-    :colorbar_title,
    :stride,
    :framestyle,
    :tick_direction,
@@ -530,12 +551,22 @@ const _pyplot_attr = merge_with_base_supported([
    :contour_labels,
  ])
 const _pyplot_seriestype = [
-        :path, :steppre, :steppost, :shape, :straightline,
-        :scatter, :hexbin, #:histogram2d, :histogram,
-        # :bar,
-        :heatmap, :pie, :image,
-        :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
-    ]
+    :path,
+    :steppre,
+    :steppost,
+    :shape,
+    :straightline,
+    :scatter,
+    :hexbin,
+    :heatmap,
+    :image,
+    :contour,
+    :contour3d,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :wireframe,
+]
 const _pyplot_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _pyplot_marker = vcat(_allMarkers, :pixel)
 const _pyplot_scale = [:identity, :ln, :log2, :log10]
@@ -565,6 +596,9 @@ const _unicodeplots_style = [:auto, :solid]
 const _unicodeplots_marker = [:none, :auto, :circle]
 const _unicodeplots_scale = [:identity]

+# Additional constants
+const _canvas_type = Ref(:auto)
+
 # ------------------------------------------------------------------------------
 # hdf5

@@ -579,7 +613,7 @@ const _hdf5_attr = merge_with_base_supported([
    :markerstrokewidth, :markerstrokecolor, :markerstrokealpha,
    :fillrange, :fillcolor, :fillalpha,
    :bins, :bar_width, :bar_edges, :bar_position,
-    :title, :title_location, :titlefont,
+    :title, :titlelocation, :titlefont,
    :window_title,
    :guide, :lims, :ticks, :scale, :flip, :rotation,
    :tickfont, :guidefont, :legendfont,
@@ -599,16 +633,43 @@ const _hdf5_attr = merge_with_base_supported([
    :colorbar_title,
  ])
 const _hdf5_seriestype = [
-        :path, :steppre, :steppost, :shape, :straightline,
-        :scatter, :hexbin, #:histogram2d, :histogram,
-        # :bar,
-        :heatmap, :pie, :image,
-        :contour, :contour3d, :path3d, :scatter3d, :surface, :wireframe
-    ]
+    :path,
+    :steppre,
+    :steppost,
+    :shape,
+    :straightline,
+    :scatter,
+    :hexbin,
+    :heatmap,
+    :image,
+    :contour,
+    :contour3d,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :wireframe,
+]
 const _hdf5_style = [:auto, :solid, :dash, :dot, :dashdot]
 const _hdf5_marker = vcat(_allMarkers, :pixel)
 const _hdf5_scale = [:identity, :ln, :log2, :log10]

+# Additional constants
+#Dict has problems using "Types" as keys.  Initialize in "_initialize_backend":
+const HDF5PLOT_MAP_STR2TELEM = Dict{String, Type}()
+const HDF5PLOT_MAP_TELEM2STR = Dict{Type, String}()
+
+#Don't really like this global variable... Very hacky
+mutable struct HDF5Plot_PlotRef
+	ref::Union{Plot, Nothing}
+end
+const HDF5PLOT_PLOTREF = HDF5Plot_PlotRef(nothing)
+
+#Simple sub-structures that can just be written out using _hdf5plot_gwritefields:
+const HDF5PLOT_SIMPLESUBSTRUCT = Union{Font, BoundingBox,
+	GridLayout, RootLayout, ColorGradient, SeriesAnnotations, PlotText,
+	Shape,
+}
+
 # ------------------------------------------------------------------------------
 # inspectdr

@@ -626,7 +687,7 @@ const _inspectdr_attr = merge_with_base_supported([
    :markerstrokestyle, #Causes warning not to have it... what is this?
    :fillcolor, :fillalpha, #:fillrange,
 #    :bins, :bar_width, :bar_edges, :bar_position,
-    :title, :title_location,
+    :title, :titlelocation,
    :window_title,
    :guide, :lims, :scale, #:ticks, :flip, :rotation,
    :titlefontfamily, :titlefontsize, :titlefontcolor,
@@ -665,3 +726,139 @@ const _inspectdr_marker = Symbol[
 ]

 const _inspectdr_scale = [:identity, :ln, :log2, :log10]
+# ------------------------------------------------------------------------------
+# pgfplotsx
+
+const _pgfplotsx_attr = merge_with_base_supported([
+    :annotations,
+    :background_color_legend,
+    :background_color_inside,
+    :background_color_outside,
+    :foreground_color_legend,
+    :foreground_color_grid,
+    :foreground_color_axis,
+    :foreground_color_text,
+    :foreground_color_border,
+    :label,
+    :seriescolor,
+    :seriesalpha,
+    :linecolor,
+    :linestyle,
+    :linewidth,
+    :linealpha,
+    :markershape,
+    :markercolor,
+    :markersize,
+    :markeralpha,
+    :markerstrokewidth,
+    :markerstrokecolor,
+    :markerstrokealpha,
+    :fillrange,
+    :fillcolor,
+    :fillalpha,
+    :bins,
+    :layout,
+    :title,
+    :window_title,
+    :guide,
+    :lims,
+    :ticks,
+    :scale,
+    :flip,
+    :match_dimensions,
+    :titlefontfamily,
+    :titlefontsize,
+    :titlefonthalign,
+    :titlefontvalign,
+    :titlefontrotation,
+    :titlefontcolor,
+    :legendfontfamily,
+    :legendfontsize,
+    :legendfonthalign,
+    :legendfontvalign,
+    :legendfontrotation,
+    :legendfontcolor,
+    :tickfontfamily,
+    :tickfontsize,
+    :tickfonthalign,
+    :tickfontvalign,
+    :tickfontrotation,
+    :tickfontcolor,
+    :guidefontfamily,
+    :guidefontsize,
+    :guidefonthalign,
+    :guidefontvalign,
+    :guidefontrotation,
+    :guidefontcolor,
+    :grid,
+    :gridalpha,
+    :gridstyle,
+    :gridlinewidth,
+    :legend,
+    :legendtitle,
+    :colorbar,
+    :colorbar_title,
+    :colorbar_entry,
+    :fill_z,
+    :line_z,
+    :marker_z,
+    :levels,
+    :ribbon,
+    :quiver,
+    :orientation,
+    :overwrite_figure,
+    :polar,
+    :aspect_ratio,
+    :normalize,
+    :weights,
+    :inset_subplots,
+    :bar_width,
+    :arrow,
+    :framestyle,
+    :tick_direction,
+    :camera,
+    :contour_labels,
+])
+const _pgfplotsx_seriestype = [
+    :path,
+    :scatter,
+    :straightline,
+    :path3d,
+    :scatter3d,
+    :surface,
+    :wireframe,
+    :heatmap,
+    :contour,
+    :contour3d,
+    :quiver,
+    :shape,
+    :steppre,
+    :stepmid,
+    :steppost,
+    :ysticks,
+    :xsticks,
+]
+const _pgfplotsx_style = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
+const _pgfplotsx_marker = [
+    :none,
+    :auto,
+    :circle,
+    :rect,
+    :diamond,
+    :utriangle,
+    :dtriangle,
+    :ltriangle,
+    :rtriangle,
+    :cross,
+    :xcross,
+    :star5,
+    :pentagon,
+    :hline,
+    :vline,
+    Shape,
+]
+const _pgfplotsx_scale = [:identity, :ln, :log2, :log10]
+is_marker_supported(::PGFPlotsXBackend, shape::Shape) = true
+
+# additional constants
+const _pgfplotsx_series_ids = KW()
@@ -26,7 +26,8 @@ const _pgfplots_markers = KW(
    :star6 => "asterisk",
    :diamond => "diamond*",
    :pentagon => "pentagon*",
-    :hline => "-"
+    :hline => "-",
+    :vline => "|"
 )

 const _pgfplots_legend_pos = KW(
@@ -95,7 +96,7 @@ pgf_thickness_scaling(series) = pgf_thickness_scaling(series[:subplot])
 function pgf_fillstyle(plotattributes, i = 1)
    cstr,a = pgf_color(get_fillcolor(plotattributes, i))
    fa = get_fillalpha(plotattributes, i)
-    if fa != nothing
+    if fa !== nothing
        a = fa
    end
    "fill = $cstr, fill opacity=$a"
@@ -127,16 +128,18 @@ function pgf_marker(plotattributes, i = 1)
    shape = _cycle(plotattributes[:markershape], i)
    cstr, a = pgf_color(plot_color(get_markercolor(plotattributes, i), get_markeralpha(plotattributes, i)))
    cstr_stroke, a_stroke = pgf_color(plot_color(get_markerstrokecolor(plotattributes, i), get_markerstrokealpha(plotattributes, i)))
-    """
-    mark = $(get(_pgfplots_markers, shape, "*")),
-    mark size = $(pgf_thickness_scaling(plotattributes) * 0.5 * _cycle(plotattributes[:markersize], i)),
-    mark options = {
-        color = $cstr_stroke, draw opacity = $a_stroke,
-        fill = $cstr, fill opacity = $a,
-        line width = $(pgf_thickness_scaling(plotattributes) * _cycle(plotattributes[:markerstrokewidth], i)),
-        rotate = $(shape == :dtriangle ? 180 : 0),
-        $(get(_pgfplots_linestyles, _cycle(plotattributes[:markerstrokestyle], i), "solid"))
-    }"""
+    return string(
+        "mark = $(get(_pgfplots_markers, shape, "*")),\n",
+        "mark size = $(pgf_thickness_scaling(plotattributes) * 0.5 * _cycle(plotattributes[:markersize], i)),\n",
+        plotattributes[:seriestype] == :scatter ? "only marks,\n" : "",
+        "mark options = {
+            color = $cstr_stroke, draw opacity = $a_stroke,
+            fill = $cstr, fill opacity = $a,
+            line width = $(pgf_thickness_scaling(plotattributes) * _cycle(plotattributes[:markerstrokewidth], i)),
+            rotate = $(shape == :dtriangle ? 180 : 0),
+            $(get(_pgfplots_linestyles, _cycle(plotattributes[:markerstrokestyle], i), "solid"))
+        }"
+        )
 end

 function pgf_add_annotation!(o, x, y, val, thickness_scaling = 1)
@@ -163,25 +166,25 @@ function pgf_series(sp::Subplot, series::Series)
    # function args
    args = if st == :contour
        plotattributes[:z].surf, plotattributes[:x], plotattributes[:y]
-    elseif is3d(st)
+    elseif RecipesPipeline.is3d(st)
        plotattributes[:x], plotattributes[:y], plotattributes[:z]
    elseif st == :straightline
        straightline_data(series)
    elseif st == :shape
        shape_data(series)
    elseif ispolar(sp)
-        theta, r = filter_radial_data(plotattributes[:x], plotattributes[:y], axis_limits(sp[:yaxis]))
+        theta, r = plotattributes[:x], plotattributes[:y]
        rad2deg.(theta), r
    else
        plotattributes[:x], plotattributes[:y]
    end

    # PGFPlots can't handle non-Vector?
-    args = map(a -> if typeof(a) <: AbstractVector && typeof(a) != Vector
-            collect(a)
-        else
-            a
-        end, args)
+    # args = map(a -> if typeof(a) <: AbstractVector && typeof(a) != Vector
+    #         collect(a)
+    #     else
+    #         a
+    #     end, args)

    if st in (:contour, :histogram2d)
        style = []
@@ -215,12 +218,12 @@ function pgf_series(sp::Subplot, series::Series)

            # add to legend?
            if i == 1 && sp[:legend] != :none && should_add_to_legend(series)
-                if plotattributes[:fillrange] != nothing
+                if plotattributes[:fillrange] !== nothing
                    push!(style, "forget plot")
                    push!(series_collection, pgf_fill_legend_hack(plotattributes, args))
                else
                    kw[:legendentry] = plotattributes[:label]
-                    if st == :shape # || plotattributes[:fillrange] != nothing
+                    if st == :shape # || plotattributes[:fillrange] !== nothing
                        push!(style, "area legend")
                    end
                end
@@ -237,7 +240,7 @@ function pgf_series(sp::Subplot, series::Series)
            kw[:style] = join(style, ',')

            # add fillrange
-            if series[:fillrange] != nothing && st != :shape
+            if series[:fillrange] !== nothing && st != :shape
                push!(series_collection, pgf_fillrange_series(series, i, _cycle(series[:fillrange], rng), seg_args...))
            end

@@ -268,7 +271,7 @@ function pgf_fillrange_series(series, i, fillrange, args...)
        push!(style, _pgf_series_extrastyle[st])
    end
    kw[:style] = join(style, ',')
-    func = is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear
+    func = RecipesPipeline.is3d(series) ? PGFPlots.Linear3 : PGFPlots.Linear
    return func(pgf_fillrange_args(fillrange, args...)...; kw...)
 end

@@ -360,13 +363,13 @@ function pgf_axis(sp::Subplot, letter)
    # limits
    # TODO: support zlims
    if letter != :z
-        lims = ispolar(sp) && letter == :x ? rad2deg.(axis_limits(axis)) : axis_limits(axis)
+        lims = ispolar(sp) && letter == :x ? rad2deg.(axis_limits(sp, :x)) : axis_limits(sp, letter)
        kw[Symbol(letter,:min)] = lims[1]
        kw[Symbol(letter,:max)] = lims[2]
    end

    if !(axis[:ticks] in (nothing, false, :none, :native)) && framestyle != :none
-        ticks = get_ticks(axis)
+        ticks = get_ticks(sp, axis)
        #pgf plot ignores ticks with angle below 90 when xmin = 90 so shift values
        tick_values = ispolar(sp) && letter == :x ? [rad2deg.(ticks[1])[3:end]..., 360, 405] : ticks[1]
        push!(style, string(letter, "tick = {", join(tick_values,","), "}"))
@@ -398,8 +401,12 @@ function pgf_axis(sp::Subplot, letter)
    # framestyle
    if framestyle in (:axes, :origin)
        axispos = framestyle == :axes ? "left" : "middle"
-        # the * after lines disables the arrows at the axes
-        push!(style, string("axis lines* = ", axispos))
+        if axis[:draw_arrow]
+            push!(style, string("axis ", letter, " line = ", axispos))
+        else
+            # the * after line disables the arrow at the axis
+            push!(style, string("axis ", letter, " line* = ", axispos))
+        end
    end

    if framestyle == :zerolines
@@ -437,7 +444,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})

        # add to style/kw for each axis
        for letter in (:x, :y, :z)
-            if letter != :z || is3d(sp)
+            if letter != :z || RecipesPipeline.is3d(sp)
                axisstyle, axiskw = pgf_axis(sp, letter)
                append!(style, axisstyle)
                merge!(kw, axiskw)
@@ -463,7 +470,7 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
            push!(style, string("title style = {font = ", pgf_font(sp[:titlefontsize], pgf_thickness_scaling(sp)), ", color = ", cstr, ", draw opacity = ", α, ", rotate = ", sp[:titlefontrotation], "}"))
        end

-        if sp[:aspect_ratio] in (1, :equal)
+        if get_aspect_ratio(sp) in (1, :equal)
            kw[:axisEqual] = "true"
        end

@@ -471,13 +478,23 @@ function _update_plot_object(plt::Plot{PGFPlotsBackend})
        if haskey(_pgfplots_legend_pos, legpos)
            kw[:legendPos] = _pgfplots_legend_pos[legpos]
        end
-        cstr, a = pgf_color(plot_color(sp[:background_color_legend]))
-        push!(style, string("legend style = {", pgf_linestyle(pgf_thickness_scaling(sp), sp[:foreground_color_legend], 1.0, "solid"), ",", "fill = $cstr,", "font = ", pgf_font(sp[:legendfontsize], pgf_thickness_scaling(sp)), "}"))
+        cstr, bg_alpha = pgf_color(plot_color(sp[:background_color_legend]))
+        fg_alpha = alpha(plot_color(sp[:foreground_color_legend]))
+
+        push!(style, string(
+            "legend style = {",
+                pgf_linestyle(pgf_thickness_scaling(sp), sp[:foreground_color_legend], fg_alpha, "solid", ), ",",
+                "fill = $cstr,",
+                "fill opacity = $bg_alpha,",
+                "text opacity = $(alpha(plot_color(sp[:legendfontcolor]))),",
+                "font = ", pgf_font(sp[:legendfontsize], pgf_thickness_scaling(sp)),
+            "}",
+        ))

        if any(s[:seriestype] == :contour for s in series_list(sp))
            kw[:view] = "{0}{90}"
            kw[:colorbar] = !(sp[:colorbar] in (:none, :off, :hide, false))
-        elseif is3d(sp)
+        elseif RecipesPipeline.is3d(sp)
            azim, elev = sp[:camera]
            kw[:view] = "{$(azim)}{$(elev)}"
        end
@@ -563,7 +580,7 @@ end

 function _show(io::IO, mime::MIME"application/x-tex", plt::Plot{PGFPlotsBackend})
    fn = tempname()*".tex"
-    PGFPlots.save(fn, backend_object(plt), include_preamble=false)
+    PGFPlots.save(fn, backend_object(plt), include_preamble=plt.attr[:tex_output_standalone])
    write(io, read(open(fn), String))
 end

@@ -37,33 +37,6 @@ import FixedPointNumbers: N0f8 #In core Julia
 struct HDF5PlotNative; end #Indentifies a data element that can natively be handled by HDF5
 struct HDF5CTuple; end #Identifies a "complex" tuple structure

-mutable struct HDF5Plot_PlotRef
-	ref::Union{Plot, Nothing}
-end
-
-
-#==Useful constants
-===============================================================================#
-const _hdf5_nullable{T} = Union{T, Nothing}
-const _hdf5_plotroot = "plot"
-const _hdf5_dataroot = "data" #TODO: Eventually move data to different root (easier to locate)?
-const _hdf5plot_datatypeid = "TYPE" #Attribute identifying type
-const _hdf5plot_countid = "COUNT" #Attribute for storing count
-
-#Dict has problems using "Types" as keys.  Initialize in "_initialize_backend":
-const HDF5PLOT_MAP_STR2TELEM = Dict{String, Type}()
-const HDF5PLOT_MAP_TELEM2STR = Dict{Type, String}()
-
-#Don't really like this global variable... Very hacky
-const HDF5PLOT_PLOTREF = HDF5Plot_PlotRef(nothing)
-
-#Simple sub-structures that can just be written out using _hdf5plot_gwritefields:
-const HDF5PLOT_SIMPLESUBSTRUCT = Union{Font, BoundingBox,
-	GridLayout, RootLayout, ColorGradient, SeriesAnnotations, PlotText,
-	Shape,
-}
-
-
 #==
 ===============================================================================#
 is_marker_supported(::HDF5Backend, shape::Shape) = true
@@ -83,6 +56,7 @@ if length(HDF5PLOT_MAP_TELEM2STR) < 1
        "ARRAY" => Array, #Dict won't allow Array to be key in HDF5PLOT_MAP_TELEM2STR

        #Sub-structure types:
+        "DEFAULTSDICT" => DefaultsDict,
        "FONT" => Font,
        "BOUNDINGBOX" => BoundingBox,
        "GRIDLAYOUT" => GridLayout,
@@ -94,7 +68,7 @@ if length(HDF5PLOT_MAP_TELEM2STR) < 1
        "AXIS" => Axis,
        "SURFACE" => Surface,
        "SUBPLOT" => Subplot,
-        "NULLABLE" => _hdf5_nullable,
+        "NULLABLE" => Union{Nothing, T} where T,
    )
    merge!(HDF5PLOT_MAP_STR2TELEM, telem2str)
    merge!(HDF5PLOT_MAP_TELEM2STR, Dict{Type, String}(v=>k for (k,v) in HDF5PLOT_MAP_STR2TELEM))
@@ -104,12 +78,12 @@ end
 #==Helper functions
 ===============================================================================#

-_hdf5_plotelempath(subpath::String) = "$_hdf5_plotroot/$subpath"
-_hdf5_datapath(subpath::String) = "$_hdf5_dataroot/$subpath"
+_hdf5_plotelempath(subpath::String) = "plot/$subpath"
+_hdf5_datapath(subpath::String) = "data/$subpath"
 _hdf5_map_str2telem(k::String) = HDF5PLOT_MAP_STR2TELEM[k]
 _hdf5_map_str2telem(v::Vector) = HDF5PLOT_MAP_STR2TELEM[v[1]]

-function _hdf5_merge!(dest::Dict, src::Dict)
+function _hdf5_merge!(dest::AKW, src::AKW)
    for (k, v) in src
        if isa(v, Axis)
            _hdf5_merge!(dest[k].plotattributes, v.plotattributes)
@@ -200,38 +174,38 @@ end

 function _hdf5plot_writetype(grp, k::String, tstr::Array{String})
    d = HDF5.d_open(grp, k)
-    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+    HDF5.a_write(d, "TYPE", tstr)
 end
 function _hdf5plot_writetype(grp, k::String, T::Type)
    tstr = HDF5PLOT_MAP_TELEM2STR[T]
    d = HDF5.d_open(grp, k)
-    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+    HDF5.a_write(d, "TYPE", tstr)
 end
 function _hdf5plot_overwritetype(grp, k::String, T::Type)
    tstr = HDF5PLOT_MAP_TELEM2STR[T]
    d = HDF5.d_open(grp, k)
-    HDF5.a_delete(d, _hdf5plot_datatypeid)
-    HDF5.a_write(d, _hdf5plot_datatypeid, tstr)
+    HDF5.a_delete(d, "TYPE")
+    HDF5.a_write(d, "TYPE", tstr)
 end
 function _hdf5plot_writetype(grp, T::Type) #Write directly to group
    tstr = HDF5PLOT_MAP_TELEM2STR[T]
-    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+    HDF5.a_write(grp, "TYPE", tstr)
 end
 function _hdf5plot_overwritetype(grp, T::Type) #Write directly to group
    tstr = HDF5PLOT_MAP_TELEM2STR[T]
-    HDF5.a_delete(grp, _hdf5plot_datatypeid)
-    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+    HDF5.a_delete(grp, "TYPE")
+    HDF5.a_write(grp, "TYPE", tstr)
 end
 function _hdf5plot_writetype(grp, ::Type{Array{T}}) where T<:Any
    tstr = HDF5PLOT_MAP_TELEM2STR[Array] #ANY
-    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+    HDF5.a_write(grp, "TYPE", tstr)
 end
 function _hdf5plot_writetype(grp, ::Type{T}) where T<:BoundingBox
    tstr = HDF5PLOT_MAP_TELEM2STR[BoundingBox]
-    HDF5.a_write(grp, _hdf5plot_datatypeid, tstr)
+    HDF5.a_write(grp, "TYPE", tstr)
 end
 function _hdf5plot_writecount(grp, n::Int) #Write directly to group
-    HDF5.a_write(grp, _hdf5plot_countid, n)
+    HDF5.a_write(grp, "COUNT", n)
 end
 function _hdf5plot_gwritefields(grp, k::String, v)
    grp = HDF5.g_create(grp, k)
@@ -263,6 +237,15 @@ function _hdf5plot_gwrite(grp, k::String, v::Array{T}) where T<:Number #Default
    grp[k] = v
    _hdf5plot_writetype(grp, k, HDF5PlotNative)
 end
+function _hdf5plot_gwrite(grp, k::String, v::Dict)
+#=
+	tstr = string(Dict)
+	path = HDF5.name(grp) * "/" * k
+	@info("Type not supported: $tstr\npath: $path")
+=#
+	#No support for structures with Dicts different than KW (plotattributes)
+end
+
 #=
 function _hdf5plot_gwrite(grp, k::String, v::Array{Any})
 #    @show grp, k
@@ -295,7 +278,8 @@ function _hdf5plot_gwrite(grp, k::String, v::Tuple)
    end
    #NOTE: _hdf5plot_overwritetype overwrites "Array" type with "Tuple".
 end
-function _hdf5plot_gwrite(grp, k::String, plotattributes::Dict)
+function _hdf5plot_gwrite(grp, k::String, plotattributes::KW)
+	#NOTE: Can only write directly to group, not a subi-item
 #    @warn("Cannot write dict: $k=$plotattributes")
 end
 function _hdf5plot_gwrite(grp, k::String, v::AbstractRange)
@@ -361,7 +345,7 @@ function _hdf5plot_gwrite(grp, k::String, v::Surface)
 	_hdf5plot_writetype(grp, Surface)
 end
 # #TODO: "Properly" support Nullable using _hdf5plot_writetype?
-# function _hdf5plot_gwrite(grp, k::String, v::_hdf5_nullable)
+# function _hdf5plot_gwrite(grp, k::String, v::Union{Nothing, T} where T)
 #     if isnull(v)
 #         _hdf5plot_gwrite(grp, k, nothing)
 #     else
@@ -376,13 +360,22 @@ function _hdf5plot_gwrite(grp, k::String, v::Subplot)
    _hdf5plot_writetype(grp, Subplot)
    return
 end
-function _hdf5plot_write(grp, plotattributes::Dict)
+
+function _hdf5plot_write(grp, plotattributes::KW)
    for (k, v) in plotattributes
        kstr = string(k)
        _hdf5plot_gwrite(grp, kstr, v)
    end
    return
 end
+function _hdf5plot_write(grp, plotattributes::DefaultsDict)
+    for (k, v) in plotattributes
+        kstr = string(k)
+        _hdf5plot_gwrite(grp, kstr, v)
+    end
+	_hdf5plot_writetype(grp, DefaultsDict)
+end
+

 # Write main plot structures:
 # ----------------------------------------------------------------
@@ -428,7 +421,7 @@ hdf5plot_write(path::AbstractString) = hdf5plot_write(current(), path)
 ===============================================================================#

 function _hdf5plot_readcount(grp) #Read directly from group
-    return HDF5.a_read(grp, _hdf5plot_countid)
+    return HDF5.a_read(grp, "COUNT")
 end

 _hdf5plot_convert(T::Type{HDF5PlotNative}, v) = v
@@ -445,20 +438,14 @@ _hdf5plot_convert(T::Type{Extrema}, v) = Extrema(v[1], v[2])
 # Read data structures:
 # ----------------------------------------------------------------

-function _hdf5plot_read(grp, k::String, T::Type, dtid)
+function _hdf5plot_read(grp, k::String, T::Type)
    v = HDF5.d_read(grp, k)
    return _hdf5plot_convert(T, v)
 end
-function _hdf5plot_read(grp, k::String, T::Type{Length}, dtid::Vector)
-    v = HDF5.d_read(grp, k)
-    TU = Symbol(dtid[2])
-    T = typeof(v)
-    return Length{TU,T}(v)
-end

 # Read more complex data structures:
 # ----------------------------------------------------------------
-function _hdf5plot_read(grp, k::String, T::Type{Font}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{Font})
    grp = HDF5.g_open(grp, k)

    family = _hdf5plot_read(grp, "family")
@@ -469,7 +456,7 @@ function _hdf5plot_read(grp, k::String, T::Type{Font}, dtid)
    color = _hdf5plot_read(grp, "color")
    return Font(family, pointsize, halign, valign, rotation, color)
 end
-function _hdf5plot_read(grp, k::String, T::Type{Array}, dtid) #ANY
+function _hdf5plot_read(grp, k::String, T::Type{Array}) #ANY
    grp = HDF5.g_open(grp, k)
    sz = _hdf5plot_read(grp, "dim")
    if [0] == sz; return []; end
@@ -488,18 +475,18 @@ function _hdf5plot_read(grp, k::String, T::Type{Array}, dtid) #ANY
    result = [result[iter] for iter in eachindex(result)] #Potentially make more specific
    return reshape(result, sz)
 end
-function _hdf5plot_read(grp, k::String, T::Type{HDF5CTuple}, dtid)
-    v = _hdf5plot_read(grp, k, Array, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{HDF5CTuple})
+    v = _hdf5plot_read(grp, k, Array)
    return tuple(v...)
 end
-function _hdf5plot_read(grp, k::String, T::Type{PlotText}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{PlotText})
    grp = HDF5.g_open(grp, k)

    str = _hdf5plot_read(grp, "str")
    font = _hdf5plot_read(grp, "font")
    return PlotText(str, font)
 end
-function _hdf5plot_read(grp, k::String, T::Type{SeriesAnnotations}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{SeriesAnnotations})
    grp = HDF5.g_open(grp, k)

    strs = _hdf5plot_read(grp, "strs")
@@ -508,29 +495,29 @@ function _hdf5plot_read(grp, k::String, T::Type{SeriesAnnotations}, dtid)
    scalefactor = _hdf5plot_read(grp, "scalefactor")
    return SeriesAnnotations(strs, font, baseshape, scalefactor)
 end
-function _hdf5plot_read(grp, k::String, T::Type{Shape}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{Shape})
    grp = HDF5.g_open(grp, k)

    x = _hdf5plot_read(grp, "x")
    y = _hdf5plot_read(grp, "y")
    return Shape(x, y)
 end
-function _hdf5plot_read(grp, k::String, T::Type{ColorGradient}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{ColorGradient})
    grp = HDF5.g_open(grp, k)

    colors = _hdf5plot_read(grp, "colors")
    values = _hdf5plot_read(grp, "values")
    return ColorGradient(colors, values)
 end
-function _hdf5plot_read(grp, k::String, T::Type{BoundingBox}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{BoundingBox})
    grp = HDF5.g_open(grp, k)

    x0 = _hdf5plot_read(grp, "x0")
    a = _hdf5plot_read(grp, "a")
    return BoundingBox(x0, a)
 end
-_hdf5plot_read(grp, k::String, T::Type{RootLayout}, dtid) = RootLayout()
-function _hdf5plot_read(grp, k::String, T::Type{GridLayout}, dtid)
+_hdf5plot_read(grp, k::String, T::Type{RootLayout}) = RootLayout()
+function _hdf5plot_read(grp, k::String, T::Type{GridLayout})
    grp = HDF5.g_open(grp, k)

 #    parent = _hdf5plot_read(grp, "parent")
@@ -544,30 +531,44 @@ parent = RootLayout()

    return GridLayout(parent, minpad, bbox, grid, widths, heights, attr)
 end
-function _hdf5plot_read(grp, k::String, T::Type{Axis}, dtid)
-    grp = HDF5.g_open(grp, k)
-    kwlist = KW()
-    _hdf5plot_read(grp, kwlist)
-    return Axis([], kwlist)
+function _hdf5plot_read(grp, T::Type{DefaultsDict})
+    attr = DefaultsDict(KW(), _plot_defaults)
+    v = _hdf5plot_read(grp, attr)
+    return attr
 end
-function _hdf5plot_read(grp, k::String, T::Type{Surface}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{Axis})
+    grp = HDF5.g_open(grp, k)
+    plotattributes = DefaultsDict(KW(), _plot_defaults)
+    _hdf5plot_read(grp, plotattributes)
+    return Axis([], plotattributes)
+end
+function _hdf5plot_read(grp, k::String, T::Type{Surface})
    grp = HDF5.g_open(grp, k)
    data2d = _hdf5plot_read(grp, "data2d")
    return Surface(data2d)
 end
-function _hdf5plot_read(grp, k::String, T::Type{Subplot}, dtid)
+function _hdf5plot_read(grp, k::String, T::Type{Subplot})
    grp = HDF5.g_open(grp, k)
    idx = _hdf5plot_read(grp, "index")
    return HDF5PLOT_PLOTREF.ref.subplots[idx]
 end
+
+#Most types don't need dtid for read!!:
+_hdf5plot_read(grp, k::String, T::Type, dtid) = _hdf5plot_read(grp, k, T)
+function _hdf5plot_read(grp, k::String, T::Type{Length}, dtid::Vector)
+    v = HDF5.d_read(grp, k)
+    TU = Symbol(dtid[2])
+    T = typeof(v)
+    return Length{TU,T}(v)
+end
 function _hdf5plot_read(grp, k::String)
-    dtid = HDF5.a_read(grp[k], _hdf5plot_datatypeid)
+    dtid = HDF5.a_read(grp[k], "TYPE")
    T = _hdf5_map_str2telem(dtid) #expect exception
    return _hdf5plot_read(grp, k, T, dtid)
 end

 #Read in values in group to populate plotattributes:
-function _hdf5plot_read(grp, plotattributes::Dict)
+function _hdf5plot_readattr(grp, plotattributes::AbstractDict)
    gnames = names(grp)
    for k in gnames
        try
@@ -581,6 +582,8 @@ function _hdf5plot_read(grp, plotattributes::Dict)
    end
    return
 end
+_hdf5plot_read(grp, plotattributes::KW) = _hdf5plot_readattr(grp, plotattributes)
+_hdf5plot_read(grp, plotattributes::DefaultsDict) = _hdf5plot_readattr(grp, plotattributes)

 # Read main plot structures:
 # ----------------------------------------------------------------
@@ -593,17 +596,17 @@ function _hdf5plot_read(sp::Subplot, subpath::String, f)

    for i in 1:nseries
        grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/series_list/series$i"))
-        kwlist = KW()
-        _hdf5plot_read(grp, kwlist)
-        plot!(sp, kwlist[:x], kwlist[:y]) #Add data & create data structures
-        _hdf5_merge!(sp.series_list[end].plotattributes, kwlist)
+        seriesinfo = DefaultsDict(KW(), _plot_defaults)
+        _hdf5plot_read(grp, seriesinfo)
+        plot!(sp, seriesinfo[:x], seriesinfo[:y]) #Add data & create data structures
+        _hdf5_merge!(sp.series_list[end].plotattributes, seriesinfo)
    end

    #Perform after adding series... otherwise values get overwritten:
    grp = HDF5.g_open(f, _hdf5_plotelempath("$subpath/attr"))
-    kwlist = KW()
-    _hdf5plot_read(grp, kwlist)
-    _hdf5_merge!(sp.attr, kwlist)
+    attr = DefaultsDict(KW(), _plot_defaults)
+    _hdf5plot_read(grp, attr)
+    _hdf5_merge!(sp.attr, attr)

    return
 end
@@ -121,9 +121,9 @@ function _create_backend_figure(plt::Plot{InspectDRBackend})
    gplot = _inspectdr_getgui(plt.o)

    #:overwrite_figure: want to reuse current figure
-    if plt[:overwrite_figure] && mplot != nothing
+    if plt[:overwrite_figure] && mplot !== nothing
        mplot.subplots = [] #Reset
-        if gplot != nothing #Ensure still references current plot
+        if gplot !== nothing #Ensure still references current plot
            gplot.src = mplot
        end
    else #want new one:
@@ -294,8 +294,8 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})

        plot.xscale = _inspectdr_getscale(xaxis[:scale], false)
        strip.yscale = _inspectdr_getscale(yaxis[:scale], true)
-        xmin, xmax  = axis_limits(xaxis)
-        ymin, ymax  = axis_limits(yaxis)
+        xmin, xmax  = axis_limits(sp, :x)
+        ymin, ymax  = axis_limits(sp, :y)
        if ispolar(sp)
            #Plots.jl appears to give (xmin,xmax) ≜ (Θmin,Θmax) & (ymin,ymax) ≜ (rmin,rmax)
            rmax = NaNMath.max(abs(ymin), abs(ymax))
@@ -429,29 +429,23 @@ end

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

-const _inspectdr_mimeformats_dpi = Dict(
-    "image/png"               => "png"
-)
-const _inspectdr_mimeformats_nodpi = Dict(
-    "image/svg+xml"           => "svg",
-    "application/eps"         => "eps",
-    "image/eps"               => "eps",
-#    "application/postscript"  => "ps", #TODO: support once Cairo supports PSSurface
-    "application/pdf"         => "pdf"
-)
 _inspectdr_show(io::IO, mime::MIME, ::Nothing, w, h) =
    throw(ErrorException("Cannot show(::IO, ...) plot - not yet generated"))
 function _inspectdr_show(io::IO, mime::MIME, mplot, w, h)
    InspectDR._show(io, mime, mplot, Float64(w), Float64(h))
 end

-for (mime, fmt) in _inspectdr_mimeformats_dpi
-    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
-        dpi = plt[:dpi]#TODO: support
-        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
-    end
+function _show(io::IO, mime::MIME{Symbol("image/png")}, plt::Plot{InspectDRBackend})
+    dpi = plt[:dpi] # TODO: support
+    _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
 end
-for (mime, fmt) in _inspectdr_mimeformats_nodpi
+for (mime, fmt) in (
+    "image/svg+xml" => "svg",
+    "application/eps" => "eps",
+    "image/eps" => "eps",
+    # "application/postscript" => "ps", # TODO: support once Cairo supports PSSurface
+    "application/pdf" => "pdf",
+)
    @eval function _show(io::IO, mime::MIME{Symbol($mime)}, plt::Plot{InspectDRBackend})
        _inspectdr_show(io, mime, _inspectdr_getmplot(plt.o), plt[:size]...)
    end
@@ -0,0 +1,23 @@
+function plotlybase_syncplot(plt::Plot)
+    plt.o = ORCA.PlotlyBase.Plot()
+    traces = ORCA.PlotlyBase.GenericTrace[]
+    for series_dict in plotly_series(plt)
+        plotly_type = pop!(series_dict, :type)
+        push!(traces, ORCA.PlotlyBase.GenericTrace(plotly_type; series_dict...))
+    end
+    ORCA.PlotlyBase.addtraces!(plt.o, traces...)
+    layout = plotly_layout(plt)
+    w, h = plt[:size]
+    ORCA.PlotlyBase.relayout!(plt.o, layout, width = w, height = h)
+    return plt.o
+end
+
+for (mime, fmt) in (
+    "application/pdf" => "pdf",
+    "image/png" => "png",
+    "image/svg+xml" => "svg",
+    "image/eps" => "eps",
+)
+    @eval _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PlotlyBackend}) =
+        ORCA.PlotlyBase.savefig(io, plotlybase_syncplot(plt), format = $fmt)
+end
@@ -3,13 +3,11 @@

 is_subplot_supported(::PlotlyBackend) = true
 # is_string_supported(::PlotlyBackend) = true
-const _plotly_framestyles = [:box, :axes, :zerolines, :grid, :none]
-const _plotly_framestyle_defaults = Dict(:semi => :box, :origin => :zerolines)
 function _plotly_framestyle(style::Symbol)
-    if style in _plotly_framestyles
+    if style in (:box, :axes, :zerolines, :grid, :none)
        return style
    else
-        default_style = get(_plotly_framestyle_defaults, style, :axes)
+        default_style = get((semi = :box, origin = :zerolines), style, :axes)
        @warn("Framestyle :$style is not supported by Plotly and PlotlyJS. :$default_style was cosen instead.")
        default_style
    end
@@ -17,32 +15,11 @@ end


 # --------------------------------------------------------------------------------------
-const plotly_remote_file_path = "https://cdn.plot.ly/plotly-latest.min.js"

-
-# if isatom()
-#     import Atom
-#     Atom.@msg evaljs(_js_code)
-# end
 using UUIDs

-push!(_initialized_backends, :plotly)
 # ----------------------------------------------------------------

-const _plotly_legend_pos = KW(
-    :right => [1., 0.5],
-    :left => [0., 0.5],
-    :top => [0.5, 1.],
-    :bottom => [0.5, 0.],
-    :bottomleft => [0., 0.],
-    :bottomright => [1., 0.],
-    :topright => [1., 1.],
-    :topleft => [0., 1.]
-)
-
-plotly_legend_pos(pos::Symbol) = get(_plotly_legend_pos, pos, [1.,1.])
-plotly_legend_pos(v::Tuple{S,T}) where {S<:Real, T<:Real} = v
-
 function plotly_font(font::Font, color = font.color)
    KW(
        :family => font.family,
@@ -109,13 +86,13 @@ function shrink_by(lo, sz, ratio)
 end

 function plotly_apply_aspect_ratio(sp::Subplot, plotarea, pcts)
-    aspect_ratio = sp[:aspect_ratio]
+    aspect_ratio = get_aspect_ratio(sp)
    if aspect_ratio != :none
        if aspect_ratio == :equal
            aspect_ratio = 1.0
        end
-        xmin,xmax = axis_limits(sp[:xaxis])
-        ymin,ymax = axis_limits(sp[:yaxis])
+        xmin,xmax = axis_limits(sp, :x)
+        ymin,ymax = axis_limits(sp, :y)
        want_ratio = ((xmax-xmin) / (ymax-ymin)) / aspect_ratio
        parea_ratio = width(plotarea) / height(plotarea)
        if want_ratio > parea_ratio
@@ -163,7 +140,7 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)

    if letter in (:x,:y)
        ax[:domain] = plotly_domain(sp, letter)
-        if is3d(sp)
+        if RecipesPipeline.is3d(sp)
            # don't link 3d axes for synchronized interactivity
            x_idx = y_idx = sp[:subplot_index]
        else
@@ -174,10 +151,10 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)

    ax[:tickangle] = -axis[:rotation]
    ax[:type] = plotly_scale(axis[:scale])
-    lims = axis_limits(axis)
+    lims = axis_limits(sp, letter)

    if axis[:ticks] != :native || axis[:lims] != :auto
-        ax[:range] = map(scalefunc(axis[:scale]), lims)
+        ax[:range] = map(RecipesPipeline.scale_func(axis[:scale]), lims)
    end

    if !(axis[:ticks] in (nothing, :none, false))
@@ -186,14 +163,9 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
        ax[:tickcolor] = framestyle in (:zerolines, :grid) || !axis[:showaxis] ? rgba_string(invisible()) : rgb_string(axis[:foreground_color_axis])
        ax[:linecolor] = rgba_string(axis[:foreground_color_axis])

-        # flip
-        if axis[:flip]
-            ax[:range] = reverse(ax[:range])
-        end
-
        # ticks
        if axis[:ticks] != :native
-            ticks = get_ticks(axis)
+            ticks = get_ticks(sp, axis)
            ttype = ticksType(ticks)
            if ttype == :ticks
                ax[:tickmode] = "array"
@@ -208,20 +180,24 @@ function plotly_axis(plt::Plot, axis::Axis, sp::Subplot)
        ax[:showgrid] = false
    end

+    # flip
+    if axis[:flip]
+        ax[:range] = reverse(ax[:range])
+    end

    ax
 end

-function plotly_polaraxis(axis::Axis)
+function plotly_polaraxis(sp::Subplot, axis::Axis)
    ax = KW(
        :visible => axis[:showaxis],
        :showline => axis[:grid],
    )

    if axis[:letter] == :x
-        ax[:range] = rad2deg.(axis_limits(axis))
+        ax[:range] = rad2deg.(axis_limits(sp, :x))
    else
-        ax[:range] = axis_limits(axis)
+        ax[:range] = axis_limits(sp, :y)
        ax[:orientation] = -90
    end

@@ -247,7 +223,7 @@ function plotly_layout(plt::Plot)
        # but vertically just below the top of the subplot bounding box
        if sp[:title] != ""
            bb = plotarea(sp)
-            tpos = sp[:title_location]
+            tpos = sp[:titlelocation]
            xmm = if tpos == :left
                left(bb)
            elseif tpos == :right
@@ -265,8 +241,8 @@ function plotly_layout(plt::Plot)
        # set to supported framestyle
        sp[:framestyle] = _plotly_framestyle(sp[:framestyle])

-        # if any(is3d, seriesargs)
-        if is3d(sp)
+        # if any(RecipesPipeline.is3d, seriesargs)
+        if RecipesPipeline.is3d(sp)
            azim = sp[:camera][1] - 90 #convert azimuthal to match GR behaviour
            theta = 90 - sp[:camera][2] #spherical coordinate angle from z axis
            plotattributes_out[:scene] = KW(
@@ -284,8 +260,8 @@ function plotly_layout(plt::Plot)
                ),
            )
        elseif ispolar(sp)
-            plotattributes_out[Symbol("angularaxis$(spidx)")] = plotly_polaraxis(sp[:xaxis])
-            plotattributes_out[Symbol("radialaxis$(spidx)")] = plotly_polaraxis(sp[:yaxis])
+            plotattributes_out[Symbol("angularaxis$(spidx)")] = plotly_polaraxis(sp, sp[:xaxis])
+            plotattributes_out[Symbol("radialaxis$(spidx)")] = plotly_polaraxis(sp, sp[:yaxis])
        else
            plotattributes_out[Symbol("xaxis$(x_idx)")] = plotly_axis(plt, sp[:xaxis], sp)
            # don't allow yaxis to be reupdated/reanchored in a linked subplot
@@ -293,18 +269,7 @@ function plotly_layout(plt::Plot)
        end

        # legend
-        plotattributes_out[:showlegend] = sp[:legend] != :none
-        xpos,ypos = plotly_legend_pos(sp[:legend])
-        if sp[:legend] != :none
-            plotattributes_out[:legend] = KW(
-                :bgcolor  => rgba_string(sp[:background_color_legend]),
-                :bordercolor => rgba_string(sp[:foreground_color_legend]),
-                :font     => plotly_font(legendfont(sp)),
-                :tracegroupgap => 0,
-                :x => xpos,
-                :y => ypos
-            )
-        end
+        plotly_add_legend!(plotattributes_out, sp)

        # annotations
        for ann in sp[:annotations]
@@ -344,38 +309,109 @@ function plotly_layout(plt::Plot)
        plotattributes_out[:hovermode] = "none"
    end

-    plotattributes_out
+    plotattributes_out = recursive_merge(plotattributes_out, plt.attr[:extra_plot_kwargs])
 end

+
+function plotly_add_legend!(plotattributes_out::KW, sp::Subplot)
+    plotattributes_out[:showlegend] = sp[:legend] != :none
+    legend_position = plotly_legend_pos(sp[:legend])
+    if sp[:legend] != :none
+        plotattributes_out[:legend] = KW(
+            :bgcolor  => rgba_string(sp[:background_color_legend]),
+            :bordercolor => rgba_string(sp[:foreground_color_legend]),
+            :borderwidth => 1,
+            :traceorder => "normal",
+            :xanchor => legend_position.xanchor,
+            :yanchor => legend_position.yanchor,
+            :font     => plotly_font(legendfont(sp)),
+            :tracegroupgap => 0,
+            :x => legend_position.coords[1],
+            :y => legend_position.coords[2]
+        )
+    end
+end
+
+function plotly_legend_pos(pos::Symbol)
+    xleft = 0.07
+    ybot = 0.07
+    ytop = 1.0
+    xcenter = 0.55
+    ycenter = 0.52    
+    center = 0.5
+    youtertop = 1.1
+    youterbot = -0.15
+    xouterright = 1.05
+    xouterleft = -0.15
+    plotly_legend_position_mapping = (
+        right       = (coords = [1.0, ycenter], xanchor = "right", yanchor = "middle"),
+        left        = (coords = [xleft, ycenter], xanchor = "left",  yanchor = "middle"),
+        top         = (coords = [xcenter, ytop], xanchor = "center",  yanchor = "top"),
+        bottom      = (coords = [xcenter, ybot], xanchor = "center",  yanchor = "bottom"),
+        bottomleft  = (coords = [xleft, ybot], xanchor = "left",  yanchor = "bottom"),
+        bottomright = (coords = [1.0, ybot], xanchor = "right", yanchor = "bottom"),
+        topright    = (coords = [1.0, 1.0], xanchor = "right", yanchor = "top"),
+        topleft     = (coords = [xleft, 1.0], xanchor = "left",  yanchor = "top"),
+        outertop =(coords = [center, youtertop ], xanchor = "upper",  yanchor = "middle"), 
+        outerbottom =(coords = [center, youterbot], xanchor = "lower",  yanchor = "middle"), 
+        outerleft =(coords = [xouterleft, center], xanchor = "left",  yanchor = "top"), 
+        outerright =(coords = [xouterright, center], xanchor = "right",  yanchor = "top"),
+        outertopleft =(coords = [xouterleft, ytop], xanchor = "upper",  yanchor = "left"),
+        outertopright = (coords = [xouterright, ytop], xanchor = "upper",  yanchor = "right"),
+        outerbottomleft =(coords = [xouterleft, ybot], xanchor = "lower",  yanchor = "left"),
+        outerbottomright =(coords = [xouterright, ybot], xanchor = "lower",  yanchor = "right"),
+        default = (coords = [1.0, 1.0], xanchor = "auto",  yanchor = "auto")
+    )
+
+    legend_position = get(plotly_legend_position_mapping, pos, plotly_legend_position_mapping.default)
+end
+
+plotly_legend_pos(v::Tuple{S,T}) where {S<:Real, T<:Real} = (coords=v, xanchor="left", yanchor="top")
+
+
 function plotly_layout_json(plt::Plot)
-    JSON.json(plotly_layout(plt))
+    JSON.json(plotly_layout(plt), 4)
 end


-function plotly_colorscale(grad::ColorGradient, α)
-    [[grad.values[i], rgba_string(plot_color(grad.colors[i], α))] for i in 1:length(grad.colors)]
-end
-plotly_colorscale(c, α) = plotly_colorscale(cgrad(alpha=α), α)
-function plotly_colorscale(c::AbstractVector{<:RGBA}, α)
+plotly_colorscale(cg::ColorGradient, α = nothing) =
+    [[v, rgba_string(plot_color(cg.colors[v], α))] for v in cg.values]
+function plotly_colorscale(c::AbstractVector{<:Colorant}, α = nothing)
    if length(c) == 1
-        return [[0.0, rgba_string(plot_color(c[1], α))], [1.0, rgba_string(plot_color(c[1], α))]]
+        return [
+            [0.0, rgba_string(plot_color(c[1], α))],
+            [1.0, rgba_string(plot_color(c[1], α))],
+        ]
    else
-        vals = range(0.0, stop=1.0, length=length(c))
+        vals = range(0.0, stop = 1.0, length = length(c))
        return [[vals[i], rgba_string(plot_color(c[i], α))] for i in eachindex(c)]
    end
 end
-# plotly_colorscale(c, alpha = nothing) = plotly_colorscale(cgrad(), alpha)
+function plotly_colorscale(cg::PlotUtils.CategoricalColorGradient, α = nothing)
+    n = length(cg)
+    cinds = repeat(1:n, inner = 2)
+    vinds = vcat((i:(i + 1) for i in 1:n)...)
+    return [
+        [cg.values[vinds[i]], rgba_string(plot_color(color_list(cg)[cinds[i]], α))]
+        for i in eachindex(cinds)
+    ]
+end
+plotly_colorscale(c, α = nothing) = plotly_colorscale(_as_gradient(c), α)


-const _plotly_markers = KW(
-    :rect       => "square",
-    :xcross     => "x",
-    :x          => "x",
-    :utriangle  => "triangle-up",
-    :dtriangle  => "triangle-down",
-    :star5      => "star-triangle-up",
-    :vline      => "line-ns",
-    :hline      => "line-ew",
+get_plotly_marker(k, def) = get(
+    (
+        rect = "square",
+        xcross = "x",
+        x = "x",
+        utriangle = "triangle-up",
+        dtriangle = "triangle-down",
+        star5 = "star-triangle-up",
+        vline = "line-ns",
+        hline = "line-ew",
+    ),
+    k,
+    def,
 )

 # find indicies of axes to which the supblot links to
@@ -394,7 +430,7 @@ end
 # we split by NaNs and then construct/destruct the shapes to get the closed coords
 function plotly_close_shapes(x, y)
    xs, ys = nansplit(x), nansplit(y)
-    for i=1:length(xs)
+    for i=eachindex(xs)
        shape = Shape(xs[i], ys[i])
        xs[i], ys[i] = coords(shape)
    end
@@ -404,7 +440,7 @@ end
 function plotly_data(series::Series, letter::Symbol, data)
    axis = series[:subplot][Symbol(letter, :axis)]

-    data = if axis[:ticks] == :native && data != nothing
+    data = if axis[:ticks] == :native && data !== nothing
        plotly_native_data(axis, data)
    else
       data
@@ -416,7 +452,8 @@ function plotly_data(series::Series, letter::Symbol, data)
        plotly_data(data)
    end
 end
-plotly_data(v) = v != nothing ? collect(v) : v
+plotly_data(v) = v !== nothing ? collect(v) : v
+plotly_data(v::AbstractArray) = v
 plotly_data(surf::Surface) = surf.surf
 plotly_data(v::AbstractArray{R}) where {R<:Rational} = float(v)

@@ -437,7 +474,7 @@ plotly_native_data(axis::Axis, a::Surface) = Surface(plotly_native_data(axis, a.

 function plotly_convert_to_datetime(x::AbstractArray, formatter::Function)
    if formatter == datetimeformatter
-        map(xi -> replace(formatter(xi), "T", " "), x)
+        map(xi -> replace(formatter(xi), "T" => " "), x)
    elseif formatter == dateformatter
        map(xi -> string(formatter(xi), " 00:00:00"), x)
    elseif formatter == timeformatter
@@ -455,7 +492,7 @@ function plotly_series(plt::Plot, series::Series)
    st = series[:seriestype]

    sp = series[:subplot]
-    clims = get_clims(sp)
+    clims = get_clims(sp, series)

    if st == :shape
        return plotly_series_shapes(plt, series, clims)
@@ -470,7 +507,7 @@ function plotly_series(plt::Plot, series::Series)
    plotattributes_out[:showlegend] = should_add_to_legend(series)

    if st == :straightline
-        x, y = straightline_data(series)
+        x, y = straightline_data(series, 100)
        z = series[:z]
    else
        x, y, z  = series[:x], series[:y], series[:z]
@@ -507,13 +544,13 @@ function plotly_series(plt::Plot, series::Series)
        plotattributes_out[:showscale] = hascolorbar(sp)

    elseif st == :contour
+        filled = isfilledcontour(series)
        plotattributes_out[:type] = "contour"
        plotattributes_out[:x], plotattributes_out[:y], plotattributes_out[:z] = x, y, z
-        # plotattributes_out[:showscale] = series[:colorbar] != :none
-        plotattributes_out[:ncontours] = series[:levels]
-        plotattributes_out[:contours] = KW(:coloring => series[:fillrange] != nothing ? "fill" : "lines", :showlabels => series[:contour_labels] == true)
+        plotattributes_out[:ncontours] = series[:levels] + 2
+        plotattributes_out[:contours] = KW(:coloring => filled ? "fill" : "lines", :showlabels => series[:contour_labels] == true)
        plotattributes_out[:colorscale] = plotly_colorscale(series[:linecolor], series[:linealpha])
-        plotattributes_out[:showscale] = hascolorbar(sp)
+        plotattributes_out[:showscale] = hascolorbar(sp) && hascolorbar(series)

    elseif st in (:surface, :wireframe)
        plotattributes_out[:type] = "surface"
@@ -530,18 +567,12 @@ function plotly_series(plt::Plot, series::Series)
        else
            plotattributes_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
            plotattributes_out[:opacity] = series[:fillalpha]
-            if series[:fill_z] != nothing
+            if series[:fill_z] !== nothing
                plotattributes_out[:surfacecolor] = plotly_surface_data(series, series[:fill_z])
            end
            plotattributes_out[:showscale] = hascolorbar(sp)
        end

-    elseif st == :pie
-        plotattributes_out[:type] = "pie"
-        plotattributes_out[:labels] = pie_labels(sp, series)
-        plotattributes_out[:values] = y
-        plotattributes_out[:hoverinfo] = "label+percent+name"
-
    else
        @warn("Plotly: seriestype $st isn't supported.")
        return KW()
@@ -551,7 +582,7 @@ function plotly_series(plt::Plot, series::Series)
    if hasmarker
        inds = eachindex(x)
        plotattributes_out[:marker] = KW(
-            :symbol => get(_plotly_markers, series[:markershape], string(series[:markershape])),
+            :symbol => get_plotly_marker(series[:markershape], string(series[:markershape])),
            # :opacity => series[:markeralpha],
            :size => 2 * _cycle(series[:markersize], inds),
            :color => rgba_string.(plot_color.(get_markercolor.(series, inds), get_markeralpha.(series, inds))),
@@ -585,7 +616,7 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
    )

    x, y = (plotly_data(series, letter, data)
-        for (letter, data) in zip((:x, :y), shape_data(series))
+        for (letter, data) in zip((:x, :y), shape_data(series, 100))
    )

    for (i,rng) in enumerate(segments)
@@ -612,11 +643,11 @@ function plotly_series_shapes(plt::Plot, series::Series, clims)
        plotly_hover!(plotattributes_out, _cycle(series[:hover], i))
        plotattributes_outs[i] = plotattributes_out
    end
-    if series[:fill_z] != nothing
+    if series[:fill_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
-    elseif series[:line_z] != nothing
+    elseif series[:line_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :line))
-    elseif series[:marker_z] != nothing
+    elseif series[:marker_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :marker))
    end
    plotattributes_outs
@@ -632,11 +663,9 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
        (isa(series[:fillrange], AbstractVector) || isa(series[:fillrange], Tuple))

    segments = iter_segments(series)
-    plotattributes_outs = Vector{KW}(undef, (hasfillrange ? 2 : 1 ) * length(segments))
+    plotattributes_outs = fill(KW(), (hasfillrange ? 2 : 1 ) * length(segments))

    for (i,rng) in enumerate(segments)
-        !isscatter && length(rng) < 2 && continue
-
        plotattributes_out = deepcopy(plotattributes_base)
        plotattributes_out[:showlegend] = i==1 ? should_add_to_legend(series) : false
        plotattributes_out[:legendgroup] = series[:label]
@@ -673,7 +702,7 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
        # add "marker"
        if hasmarker
            plotattributes_out[:marker] = KW(
-                :symbol => get(_plotly_markers, _cycle(series[:markershape], i), string(_cycle(series[:markershape], i))),
+                :symbol => get_plotly_marker(_cycle(series[:markershape], i), string(_cycle(series[:markershape], i))),
                # :opacity => series[:markeralpha],
                :size => 2 * _cycle(series[:markersize], i),
                :color => rgba_string(plot_color(get_markercolor(series, clims, i), get_markeralpha(series, i))),
@@ -736,11 +765,11 @@ function plotly_series_segments(series::Series, plotattributes_base::KW, x, y, z
        end
    end

-    if series[:line_z] != nothing
+    if series[:line_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :line))
-    elseif series[:fill_z] != nothing
+    elseif series[:fill_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :fill))
-    elseif series[:marker_z] != nothing
+    elseif series[:marker_z] !== nothing
        push!(plotattributes_outs, plotly_colorbar_hack(series, plotattributes_base, :marker))
    end

@@ -751,11 +780,11 @@ function plotly_colorbar_hack(series::Series, plotattributes_base::KW, sym::Symb
    plotattributes_out = deepcopy(plotattributes_base)
    cmin, cmax = get_clims(series[:subplot])
    plotattributes_out[:showlegend] = false
-    plotattributes_out[:type] = is3d(series) ? :scatter3d : :scatter
+    plotattributes_out[:type] = RecipesPipeline.is3d(series) ? :scatter3d : :scatter
    plotattributes_out[:hoverinfo] = :none
    plotattributes_out[:mode] = :markers
    plotattributes_out[:x], plotattributes_out[:y] = [series[:x][1]], [series[:y][1]]
-    if is3d(series)
+    if RecipesPipeline.is3d(series)
        plotattributes_out[:z] = [series[:z][1]]
    end
    # zrange = zmax == zmin ? 1 : zmax - zmin # if all marker_z values are the same, plot all markers same color (avoids division by zero in next line)
@@ -775,7 +804,7 @@ end
 function plotly_polar!(plotattributes_out::KW, series::Series)
    # convert polar plots x/y to theta/radius
    if ispolar(series[:subplot])
-        theta, r = filter_radial_data(pop!(plotattributes_out, :x), pop!(plotattributes_out, :y), axis_limits(series[:subplot][:yaxis]))
+        theta, r = pop!(plotattributes_out, :x), pop!(plotattributes_out, :y)
        plotattributes_out[:t] = rad2deg.(theta)
        plotattributes_out[:r] = r
    end
@@ -783,9 +812,9 @@ end

 function plotly_hover!(plotattributes_out::KW, hover)
    # hover text
-    if hover in (:none, false)
+    if hover === nothing || all(in([:none, false]), hover)
        plotattributes_out[:hoverinfo] = "none"
-    elseif hover != nothing
+    elseif any(!isnothing, hover)
        plotattributes_out[:hoverinfo] = "text"
        plotattributes_out[:text] = hover
    end
@@ -801,15 +830,24 @@ function plotly_series(plt::Plot)
 end

 # get json string for a list of dictionaries, each representing the series params
-plotly_series_json(plt::Plot) = JSON.json(plotly_series(plt))
+plotly_series_json(plt::Plot) = JSON.json(plotly_series(plt), 4)

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

+html_head(plt::Plot{PlotlyBackend}) = plotly_html_head(plt)
+html_body(plt::Plot{PlotlyBackend}) = plotly_html_body(plt)
+
 const ijulia_initialized = Ref(false)

-function html_head(plt::Plot{PlotlyBackend})
-    local_file = ("file://" * plotly_local_file_path)
-    plotly = use_local_dependencies[] ? local_file : plotly_remote_file_path
+function plotly_html_head(plt::Plot)
+    local_file = ("file:///" * plotly_local_file_path)
+    plotly =
+        use_local_dependencies[] ? local_file : "https://cdn.plot.ly/plotly-1.54.2.min.js"
+
+    include_mathjax = get(plt[:extra_plot_kwargs], :include_mathjax, "")
+    mathjax_file = include_mathjax != "cdn" ? ("file://" * include_mathjax) : "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-MML-AM_CHTML"
+    mathjax_head = include_mathjax == "" ? "" : "<script src=\"$mathjax_file\"></script>\n\t\t"
+
    if isijulia() && !ijulia_initialized[]
        # using requirejs seems to be key to load a js depency in IJulia!
        # https://requirejs.org/docs/start.html
@@ -823,13 +861,11 @@ function html_head(plt::Plot{PlotlyBackend})
        """)
        ijulia_initialized[] = true
    end
-    # IJulia just needs one initialization
-    isijulia() && return ""
-    return "<script src=$(repr(plotly))></script>"
+    return "$mathjax_head<script src=$(repr(plotly))></script>"
 end

-function html_body(plt::Plot{PlotlyBackend}, style = nothing)
-    if style == nothing
+function plotly_html_body(plt, style = nothing)
+    if style === nothing
        w, h = plt[:size]
        style = "width:$(w)px;height:$(h)px;"
    end
@@ -844,21 +880,36 @@ function html_body(plt::Plot{PlotlyBackend}, style = nothing)
    html
 end

-function js_body(plt::Plot{PlotlyBackend}, uuid)
+function js_body(plt::Plot, uuid)
    js = """
        PLOT = document.getElementById('$(uuid)');
        Plotly.plot(PLOT, $(plotly_series_json(plt)), $(plotly_layout_json(plt)));
    """
 end

+function plotly_show_js(io::IO, plot::Plot)
+    data = []
+    for series in plot.series_list
+        append!(data, plotly_series(plot, series))
+    end
+    layout = plotly_layout(plot)
+    JSON.print(io, Dict(:data => data, :layout => layout))
+end

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

+Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot{PlotlyBackend}) = true
+
+function _show(io::IO, ::MIME"application/vnd.plotly.v1+json", plot::Plot{PlotlyBackend})
+    plotly_show_js(io, plot)
+end
+

 function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
-    write(io, html_head(plt) * html_body(plt))
+    write(io, standalone_html(plt))
 end

+
 function _display(plt::Plot{PlotlyBackend})
    standalone_html_window(plt)
 end
@@ -1,79 +1,46 @@
 # https://github.com/sglyon/PlotlyJS.jl

-# --------------------------------------------------------------------------------------
+# ------------------------------------------------------------------------------

-
-function _create_backend_figure(plt::Plot{PlotlyJSBackend})
-    if !isplotnull() && plt[:overwrite_figure] && isa(current().o, PlotlyJS.SyncPlot)
-        PlotlyJS.SyncPlot(PlotlyJS.Plot(), options = current().o.options)
-    else
-        PlotlyJS.plot()
+function plotlyjs_syncplot(plt::Plot{PlotlyJSBackend})
+    plt[:overwrite_figure] && closeall()
+    plt.o = PlotlyJS.plot()
+    traces = PlotlyJS.GenericTrace[]
+    for series_dict in plotly_series(plt)
+        plotly_type = pop!(series_dict, :type)
+        push!(traces, PlotlyJS.GenericTrace(plotly_type; series_dict...))
    end
+    PlotlyJS.addtraces!(plt.o, traces...)
+    layout = plotly_layout(plt)
+    w, h = plt[:size]
+    PlotlyJS.relayout!(plt.o, layout, width = w, height = h)
+    return plt.o
 end

+# ------------------------------------------------------------------------------

-function _series_added(plt::Plot{PlotlyJSBackend}, series::Series)
-    syncplot = plt.o
-    pdicts = plotly_series(plt, series)
-    for pdict in pdicts
-        typ = pop!(pdict, :type)
-        gt = PlotlyJS.GenericTrace(typ; pdict...)
-        PlotlyJS.addtraces!(syncplot, gt)
-    end
+for (mime, fmt) in (
+    "application/pdf" => "pdf",
+    "image/png"       => "png",
+    "image/svg+xml"   => "svg",
+    "image/eps"       => "eps",
+)
+    @eval _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plotlyjs_syncplot(plt), format = $fmt)
 end

-function _series_updated(plt::Plot{PlotlyJSBackend}, series::Series)
-    xsym, ysym = (ispolar(series) ? (:t,:r) : (:x,:y))
-    kw = KW(xsym => (series.plotattributes[:x],), ysym => (series.plotattributes[:y],))
-    z = series[:z]
-    if z != nothing
-        kw[:z] = (isa(z,Surface) ? transpose_z(series, series[:z].surf, false) : z,)
-    end
-    PlotlyJS.restyle!(
-        plt.o,
-        findfirst(isequal(series), plt.series_list),
-        kw
-    )
-end
+# Use the Plotly implementation for json and html:
+_show(io::IO, mime::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBackend}) = plotly_show_js(io, plt)

+html_head(plt::Plot{PlotlyJSBackend}) = plotly_html_head(plt)
+html_body(plt::Plot{PlotlyJSBackend}) = plotly_html_body(plt)

-# ----------------------------------------------------------------
+_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standalone_html(plt))

-function _update_plot_object(plt::Plot{PlotlyJSBackend})
-    pdict = plotly_layout(plt)
-    syncplot = plt.o
-    w,h = plt[:size]
-    PlotlyJS.relayout!(syncplot, pdict, width = w, height = h)
-end
+_display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))

-
-# ----------------------------------------------------------------
-
-_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = show(io, MIME("text/html"), plt.o)
-_show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="svg")
-_show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="png")
-_show(io::IO, ::MIME"application/pdf", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="pdf")
-_show(io::IO, ::MIME"image/eps", plt::Plot{PlotlyJSBackend}) = PlotlyJS.savefig(io, plt.o, format="eps")
-
-function write_temp_html(plt::Plot{PlotlyJSBackend})
-    filename = string(tempname(), ".html")
-    savefig(plt, filename)
-    filename
-end
-
-function _display(plt::Plot{PlotlyJSBackend})
-    if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
-        display(plt.o)
-    else
-        standalone_html_window(plt)
-    end
-end
-
-@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
-    function WebIO.render(plt::Plot{PlotlyJSBackend})
-        prepare_output(plt)
-        WebIO.render(plt.o)
-    end
+function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
+    plt_html = sprint(show, MIME("text/html"), plt)
+    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
 end

 function closeall(::PlotlyJSBackend)
@@ -81,3 +48,5 @@ function closeall(::PlotlyJSBackend)
        close(current().o)
    end
 end
+
+Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot{PlotlyJSBackend}) = true
@@ -3,19 +3,17 @@


 # don't warn on unsupported... there's just too many warnings!!
-warnOnUnsupported_args(::UnicodePlotsBackend, plotattributes::KW) = nothing
+warn_on_unsupported_args(::UnicodePlotsBackend, plotattributes::KW) = nothing

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

-const _canvas_type = Ref(:auto)
-
 function _canvas_map()
-    KW(
-        :braille => UnicodePlots.BrailleCanvas,
-        :ascii => UnicodePlots.AsciiCanvas,
-        :block => UnicodePlots.BlockCanvas,
-        :dot => UnicodePlots.DotCanvas,
-        :density => UnicodePlots.DensityCanvas,
+    (
+        braille = UnicodePlots.BrailleCanvas,
+        ascii = UnicodePlots.AsciiCanvas,
+        block = UnicodePlots.BlockCanvas,
+        dot = UnicodePlots.DotCanvas,
+        density = UnicodePlots.DensityCanvas,
    )
 end

@@ -27,8 +25,8 @@ function rebuildUnicodePlot!(plt::Plot, width, height)
    for sp in plt.subplots
        xaxis = sp[:xaxis]
        yaxis = sp[:yaxis]
-        xlim =  axis_limits(xaxis)
-        ylim =  axis_limits(yaxis)
+        xlim =  axis_limits(sp, :x)
+        ylim =  axis_limits(sp, :y)

        # make vectors
        xlim = [xlim[1], xlim[2]]
@@ -92,7 +90,7 @@ end


 # add a single series
-function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
+function addUnicodeSeries!(o, plotattributes, addlegend::Bool, xlim, ylim)
    # get the function, or special handling for step/bar/hist
    st = plotattributes[:seriestype]
    if st == :histogram2d
@@ -116,7 +114,7 @@ function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
    x, y = if st == :straightline
        straightline_data(plotattributes)
    elseif st == :shape
-        shape_data(series)
+        shape_data(plotattributes)
    else
        [collect(float(plotattributes[s])) for s in (:x, :y)]
    end
@@ -126,7 +124,7 @@ function addUnicodeSeries!(o, plotattributes::KW, addlegend::Bool, xlim, ylim)
    color = plotattributes[:linecolor] in UnicodePlots.color_cycle ? plotattributes[:linecolor] : :auto

    # add the series
-    x, y = Plots.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
+    x, y = RecipesPipeline.unzip(collect(Base.Iterators.filter(xy->isfinite(xy[1])&&isfinite(xy[2]), zip(x,y))))
    func(o, x, y; color = color, name = label)
 end

@@ -1,7 +1,7 @@


-const P2 = StaticArrays.SVector{2,Float64}
-const P3 = StaticArrays.SVector{3,Float64}
+const P2 = GeometryTypes.Point2{Float64}
+const P3 = GeometryTypes.Point3{Float64}

 nanpush!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); push!(a, b))
 nanappend!(a::AbstractVector{P2}, b) = (push!(a, P2(NaN,NaN)); append!(a, b))
@@ -29,7 +29,7 @@ end

 Construct a polygon to be plotted
 """
-Shape(verts::AVec) = Shape(unzip(verts)...)
+Shape(verts::AVec) = Shape(RecipesPipeline.unzip(verts)...)
 Shape(s::Shape) = deepcopy(s)

 get_xs(shape::Shape) = shape.x
@@ -187,7 +187,7 @@ end
 function scale!(shape::Shape, x::Real, y::Real = x, c = center(shape))
    sx, sy = coords(shape)
    cx, cy = c
-    for i=1:length(sx)
+    for i=eachindex(sx)
        sx[i] = (sx[i] - cx) * x + cx
        sy[i] = (sy[i] - cy) * y + cy
    end
@@ -202,7 +202,7 @@ end
 "translate a Shape in space"
 function translate!(shape::Shape, x::Real, y::Real = x)
    sx, sy = coords(shape)
-    for i=1:length(sx)
+    for i=eachindex(sx)
        sx[i] += x
        sy[i] += y
    end
@@ -230,7 +230,7 @@ end
 function rotate!(shape::Shape, Θ::Real, c = center(shape))
    x, y = coords(shape)
    cx, cy = c
-    for i=1:length(x)
+    for i=eachindex(x)
        xi = rotate_x(x[i], y[i], Θ, cx, cy)
        yi = rotate_y(x[i], y[i], Θ, cx, cy)
        x[i], y[i] = xi, yi
@@ -261,13 +261,13 @@ end
 Create a Font from a list of features. Values may be specified either as
 arguments (which are distinguished by type/value) or as keyword arguments.
 # Arguments
- `family`: AbstractString. "serif" or "sans-serif" or "monospace" 
+- `family`: AbstractString. "serif" or "sans-serif" or "monospace"
 - `pointsize`: Integer. Size of font in points
 - `halign`: Symbol. Horizontal alignment (:hcenter, :left, or :right)
 - `valign`: Symbol. Vertical aligment (:vcenter, :top, or :bottom)
 - `rotation`: Real. Angle of rotation for text in degrees (use a non-integer type)
 - `color`: Colorant or Symbol
-# Examples 
+# Examples
 ```julia-repl
 julia> font(8)
 julia> font(family="serif",halign=:center,rotation=45.0)
@@ -358,9 +358,15 @@ end
 Scales all **current** font sizes by `factor`. For example `scalefontsizes(1.1)` increases all current font sizes by 10%. To reset to initial sizes, use `scalefontsizes()`
 """
 function scalefontsizes(factor::Number)
-    for k in (:titlefontsize, :guidefontsize, :tickfontsize, :legendfontsize)
+    for k in (:titlefontsize, :legendfontsize, :legendtitlefontsize)
        scalefontsize(k, factor)
    end
+
+    for letter in (:x,:y,:z)
+        for k in (:guidefontsize, :tickfontsize)
+            scalefontsize(Symbol(letter, k), factor)
+        end
+    end
 end

 """
@@ -369,15 +375,27 @@ end
 Resets font sizes to initial default values.
 """
 function scalefontsizes()
-  for k in (:titlefontsize, :guidefontsize, :tickfontsize, :legendfontsize)
-      f = default(k)
-      if k in keys(_initial_fontsizes)
-        factor = f / _initial_fontsizes[k]
-        scalefontsize(k, 1.0/factor)
-      end
-  end
+    for k in (:titlefontsize, :legendfontsize, :legendtitlefontsize)
+        f = default(k)
+        if k in keys(_initial_fontsizes)
+            factor = f / _initial_fontsizes[k]
+            scalefontsize(k, 1.0/factor)
+        end
+    end
+
+    for letter in (:x,:y,:z)
+        for k in (:guidefontsize, :tickfontsize)
+            if k in keys(_initial_fontsizes)
+                f = default(Symbol(letter, k))
+                factor = f / _initial_fontsizes[k]
+                scalefontsize(Symbol(letter, k), 1.0/factor)
+            end
+        end
+    end
 end

+resetfontsizes() = scalefontsizes()
+
 "Wrap a string with font info"
 struct PlotText
  str::AbstractString
@@ -388,8 +406,8 @@ PlotText(str) = PlotText(string(str), font())
 """
    text(string, args...; kw...)

-Create a PlotText object wrapping a string with font info, for plot annotations. 
-`args` and `kw` are passed to `font`. 
+Create a PlotText object wrapping a string with font info, for plot annotations.
+`args` and `kw` are passed to `font`.
 """
 text(t::PlotText) = t
 text(t::PlotText, font::Font) = PlotText(t.str, font)
@@ -529,7 +547,7 @@ function series_annotations_shapes!(series::Series, scaletype::Symbol = :pixels)
    # end

    # @show msw msh
-    if anns != nothing && anns.baseshape != nothing
+    if anns !== nothing && anns.baseshape !== nothing
        # we use baseshape to overwrite the markershape attribute
        # with a list of custom shapes for each
        msw,msh = anns.scalefactor
@@ -568,7 +586,7 @@ mutable struct EachAnn
 end

 function Base.iterate(ea::EachAnn, i = 1)
-    if ea.anns == nothing || isempty(ea.anns.strs) || i > length(ea.y)
+    if ea.anns === nothing || isempty(ea.anns.strs) || i > length(ea.y)
        return nothing
    end

@@ -591,8 +609,12 @@ annotations(sa::SeriesAnnotations) = sa
 function process_annotation(sp::Subplot, xs, ys, labs, font = font())
    anns = []
    labs = makevec(labs)
-    for i in 1:max(length(xs), length(ys), length(labs))
-        x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+    xlength = length(methods(length, (typeof(xs),))) == 0 ? 1 : length(xs)
+    ylength = length(methods(length, (typeof(ys),))) == 0 ? 1 : length(ys)
+    for i in 1:max(xlength, ylength, length(labs))
+      x, y, lab = _cycle(xs, i), _cycle(ys, i), _cycle(labs, i)
+        x = typeof(x) <: TimeType ? Dates.value(x) : x
+        y = typeof(y) <: TimeType ? Dates.value(y) : y
        if lab == :auto
            alphabet = "abcdefghijklmnopqrstuvwxyz"
            push!(anns, (x, y, text(string("(", alphabet[sp[:subplot_index]], ")"), font)))
@@ -648,23 +670,6 @@ end

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

-abstract type AbstractSurface end
-
-"represents a contour or surface mesh"
-struct Surface{M<:AMat} <: AbstractSurface
-  surf::M
-end
-
-Surface(f::Function, x, y) = Surface(Float64[f(xi,yi) for yi in y, xi in x])
-
-Base.Array(surf::Surface) = surf.surf
-
-for f in (:length, :size)
-  @eval Base.$f(surf::Surface, args...) = $f(surf.surf, args...)
-end
-Base.copy(surf::Surface) = Surface(copy(surf.surf))
-Base.eltype(surf::Surface{T}) where {T} = eltype(T)
-
 function expand_extrema!(a::Axis, surf::Surface)
    ex = a[:extrema]
    for vi in surf.surf
@@ -684,28 +689,7 @@ end
 # # I don't want to clash with ValidatedNumerics, but this would be nice:
 # ..(a::T, b::T) = (a,b)

-struct Volume{T}
-    v::Array{T,3}
-    x_extents::Tuple{T,T}
-    y_extents::Tuple{T,T}
-    z_extents::Tuple{T,T}
-end

-default_extents(::Type{T}) where {T} = (zero(T), one(T))
-
-function Volume(v::Array{T,3},
-                x_extents = default_extents(T),
-                y_extents = default_extents(T),
-                z_extents = default_extents(T)) where T
-    Volume(v, x_extents, y_extents, z_extents)
-end
-
-Base.Array(vol::Volume) = vol.v
-for f in (:length, :size)
-  @eval Base.$f(vol::Volume, args...) = $f(vol.v, args...)
-end
-Base.copy(vol::Volume{T}) where {T} = Volume{T}(copy(vol.v), vol.x_extents, vol.y_extents, vol.z_extents)
-Base.eltype(vol::Volume{T}) where {T} = T

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

@@ -769,17 +753,9 @@ function add_arrows(func::Function, x::AVec, y::AVec)
    end
 end

-# -----------------------------------------------------------------------
-
-"Represents data values with formatting that should apply to the tick labels."
-struct Formatted{T}
-    data::T
-    formatter::Function
-end
-
 # -----------------------------------------------------------------------
 "create a BezierCurve for plotting"
-mutable struct BezierCurve{T <: StaticArrays.SVector}
+mutable struct BezierCurve{T <: GeometryTypes.Point}
    control_points::Vector{T}
 end

@@ -792,12 +768,9 @@ function (bc::BezierCurve)(t::Real)
    p
 end

-# mean(x::Real, y::Real) = 0.5*(x+y) #commented out as I cannot see this used anywhere and it overwrites a Base method with different functionality
-# mean{N,T<:Real}(ps::StaticArrays.SVector{N,T}...) = sum(ps) / length(ps) # I also could not see this used anywhere, and it's type piracy - implementing a NaNMath version for this would just involve converting to a standard array
-
@deprecate curve_points coords

-coords(curve::BezierCurve, n::Integer = 30; range = [0,1]) = map(curve, range(range..., stop=n, length=50))
+coords(curve::BezierCurve, n::Integer = 30; range = [0,1]) = map(curve, Base.range(first(range), stop=last(range), length=n))

 # build a BezierCurve which leaves point p vertically upwards and arrives point q vertically upwards.
 # may create a loop if necessary.  Assumes the view is [0,1]
@@ -20,7 +20,10 @@ frontends like jupyterlab and nteract.
 _ijulia__extra_mime_info!(plt::Plot, out::Dict) = out

 function _ijulia__extra_mime_info!(plt::Plot{PlotlyJSBackend}, out::Dict)
-    out["application/vnd.plotly.v1+json"] = JSON.lower(plt.o)
+    out["application/vnd.plotly.v1+json"] = Dict(
+        :data => plotly_series(plt),
+        :layout => plotly_layout(plt)
+    )
    out
 end

@@ -3,7 +3,7 @@ using REPL

 function _plots_defaults()
    if isdefined(Main, :PLOTS_DEFAULTS)
-        Main.PLOTS_DEFAULTS::Dict{Symbol,Any}
+        copy(Dict{Symbol,Any}(Main.PLOTS_DEFAULTS))
    else
        Dict{Symbol,Any}()
    end
@@ -13,11 +13,9 @@ end
 function __init__()
    user_defaults = _plots_defaults()
    if haskey(user_defaults, :theme)
-        theme(user_defaults[:theme])
-    end
-    for (k,v) in user_defaults
-        k == :theme || default(k, v)
+        theme(pop!(user_defaults, :theme))
    end
+    default(; user_defaults...)

    insert!(Base.Multimedia.displays, findlast(x -> x isa Base.TextDisplay || x isa REPL.REPLDisplay, Base.Multimedia.displays) + 1, PlotsDisplay())

@@ -28,12 +26,45 @@ function __init__()
        insert!(Base.Multimedia.displays, findlast(x -> x isa REPL.REPLDisplay, Base.Multimedia.displays) + 1, PlotsDisplay())
    end)

-    @require HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" include(joinpath(@__DIR__, "backends", "hdf5.jl"))
-    @require InspectDR = "d0351b0e-4b05-5898-87b3-e2a8edfddd1d" include(joinpath(@__DIR__, "backends", "inspectdr.jl"))
-    @require PGFPlots = "3b7a836e-365b-5785-a47d-02c71176b4aa" include(joinpath(@__DIR__, "backends", "pgfplots.jl"))
-    @require PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a" include(joinpath(@__DIR__, "backends", "plotlyjs.jl"))
-    @require PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee" include(joinpath(@__DIR__, "backends", "pyplot.jl"))
-    @require UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228" include(joinpath(@__DIR__, "backends", "unicodeplots.jl"))
+    @require HDF5 = "f67ccb44-e63f-5c2f-98bd-6dc0ccc4ba2f" begin
+        fn = joinpath(@__DIR__, "backends", "hdf5.jl")
+        include(fn)
+    end
+
+    @require InspectDR = "d0351b0e-4b05-5898-87b3-e2a8edfddd1d" begin
+        fn = joinpath(@__DIR__, "backends", "inspectdr.jl")
+        include(fn)
+    end
+
+    @require PGFPlots = "3b7a836e-365b-5785-a47d-02c71176b4aa" begin
+        fn = joinpath(@__DIR__, "backends", "deprecated", "pgfplots.jl")
+        include(fn)
+    end
+
+    @require ORCA = "47be7bcc-f1a6-5447-8b36-7eeeff7534fd" begin
+        fn = joinpath(@__DIR__, "backends", "orca.jl")
+        include(fn)
+    end
+
+    @require PGFPlotsX = "8314cec4-20b6-5062-9cdb-752b83310925" begin
+        fn = joinpath(@__DIR__, "backends", "pgfplotsx.jl")
+        include(fn)
+    end
+
+    @require PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a" begin
+        fn = joinpath(@__DIR__, "backends", "plotlyjs.jl")
+        include(fn)
+    end
+
+    @require PyPlot = "d330b81b-6aea-500a-939a-2ce795aea3ee" begin
+        fn = joinpath(@__DIR__, "backends", "pyplot.jl")
+        include(fn)
+    end
+
+    @require UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228" begin
+        fn = joinpath(@__DIR__, "backends", "unicodeplots.jl")
+        include(fn)
+    end

    @require IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" begin
        if IJulia.inited
@@ -107,11 +107,10 @@ function resolve_mixed(mix::MixedMeasures, sp::Subplot, letter::Symbol)
    if mix.len != 0mm
        f = (letter == :x ? width : height)
        totlen = f(plotarea(sp))
-        @show totlen
        pct += mix.len / totlen
    end
    if pct != 0
-        amin, amax = axis_limits(sp[Symbol(letter,:axis)])
+        amin, amax = axis_limits(sp, letter)
        xy += pct * (amax-amin)
    end
    xy
@@ -218,6 +217,7 @@ bottompad(layout::AbstractLayout) = 0mm
 # this is the parent of the top-level layout
 struct RootLayout <: AbstractLayout end

+Base.show(io::IO, layout::RootLayout) = Base.show_default(io, layout)
 Base.parent(::RootLayout) = nothing
 parent_bbox(::RootLayout) = defaultbox
 bbox(::RootLayout) = defaultbox
@@ -345,10 +345,8 @@ end
 # recursively compute the bounding boxes for the layout and plotarea (relative to canvas!)
 function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0mm,0mm])
    nr, nc = size(layout)
-
    # # create a matrix for each minimum padding direction
    # _update_min_padding!(layout)
-
    minpad_left   = map(leftpad,   layout.grid)
    minpad_top    = map(toppad,    layout.grid)
    minpad_right  = map(rightpad,  layout.grid)
@@ -407,10 +405,10 @@ function update_child_bboxes!(layout::GridLayout, minimum_perimeter = [0mm,0mm,0
        # this is the minimum perimeter as decided by this child's parent, so that
        # all children on this border have the same value
        min_child_perimeter = [
-            c == 1  ? layout.minpad[1] : 0mm,
-            r == 1  ? layout.minpad[2] : 0mm,
-            c == nc ? layout.minpad[3] : 0mm,
-            r == nr ? layout.minpad[4] : 0mm
+            c == 1  ? layout.minpad[1] : pad_left[c],
+            r == 1  ? layout.minpad[2] : pad_top[r],
+            c == nc ? layout.minpad[3] : pad_right[c],
+            r == nr ? layout.minpad[4] : pad_bottom[r]
        ]

        # recursively update the child's children
@@ -464,12 +462,12 @@ end
 # constructors

 # pass the layout arg through
-function layout_args(plotattributes::KW)
-    layout_args(get(plotattributes, :layout, default(:layout)))
+function layout_args(plotattributes::AKW)
+    layout_args(plotattributes[:layout])
 end

-function layout_args(plotattributes::KW, n_override::Integer)
-    layout, n = layout_args(get(plotattributes, :layout, n_override))
+function layout_args(plotattributes::AKW, n_override::Integer)
+    layout, n = layout_args(n_override, get(plotattributes, :layout, n_override))
    if n != n_override
        error("When doing layout, n ($n) != n_override ($(n_override)).  You're probably trying to force existing plots into a layout that doesn't fit them.")
    end
@@ -481,12 +479,27 @@ function layout_args(n::Integer)
    GridLayout(nr, nc), n
 end

-function layout_args(sztup::NTuple{2,I}) where I<:Integer
+function layout_args(sztup::NTuple{2, Integer})
    nr, nc = sztup
    GridLayout(nr, nc), nr*nc
 end

-function layout_args(sztup::NTuple{3,I}) where I<:Integer
+layout_args(n_override::Integer, n::Integer) = layout_args(n)
+layout_args(n, sztup::NTuple{2, Integer}) = layout_args(sztup)
+
+function layout_args(n, sztup::Tuple{Colon, Integer})
+    nc = sztup[2]
+    nr = ceil(Int, n / nc)
+    GridLayout(nr, nc), n
+end
+
+function layout_args(n, sztup::Tuple{Integer, Colon})
+    nr = sztup[1]
+    nc = ceil(Int, n / nr)
+    GridLayout(nr, nc), n
+end
+
+function layout_args(sztup::NTuple{3, Integer})
    n, nr, nc = sztup
    nr, nc = compute_gridsize(n, nr, nc)
    GridLayout(nr, nc), n
@@ -499,6 +512,8 @@ function layout_args(layout::GridLayout)
    layout, n
 end

+layout_args(n_override::Integer, layout::GridLayout) = layout_args(layout)
+
 layout_args(huh) = error("unhandled layout type $(typeof(huh)): $huh")


@@ -599,7 +614,7 @@ end
 # ----------------------------------------------------------------------
 # @layout macro

-function add_layout_pct!(kw::KW, v::Expr, idx::Integer, nidx::Integer)
+function add_layout_pct!(kw::AKW, v::Expr, idx::Integer, nidx::Integer)
    # dump(v)
    # something like {0.2w}?
    if v.head == :call && v.args[1] == :*
@@ -620,7 +635,7 @@ function add_layout_pct!(kw::KW, v::Expr, idx::Integer, nidx::Integer)
    error("Couldn't match layout curly (idx=$idx): $v")
 end

-function add_layout_pct!(kw::KW, v::Number, idx::Integer)
+function add_layout_pct!(kw::AKW, v::Number, idx::Integer)
    # kw[idx == 1 ? :w : :h] = v*pct
    idx == 1 && (kw[:w] = v*pct)
    (idx == 2 || nidx == 1) && (kw[:h] = v*pct)
@@ -1,100 +1,104 @@

-
 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)
+    fn = addExtension(fn, "png")
+    io = open(fn, "w")
+    show(io, MIME("image/png"), plt)
+    close(io)
 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)
+    fn = addExtension(fn, "svg")
+    io = open(fn, "w")
+    show(io, MIME("image/svg+xml"), plt)
+    close(io)
 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)
+    fn = addExtension(fn, "pdf")
+    io = open(fn, "w")
+    show(io, MIME("application/pdf"), plt)
+    close(io)
 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)
+    fn = addExtension(fn, "ps")
+    io = open(fn, "w")
+    show(io, MIME("application/postscript"), plt)
+    close(io)
 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)
+    fn = addExtension(fn, "eps")
+    io = open(fn, "w")
+    show(io, MIME("image/eps"), plt)
+    close(io)
 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)
+    fn = addExtension(fn, "tex")
+    io = open(fn, "w")
+    show(io, MIME("application/x-tex"), plt)
+    close(io)
 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)
+end
+json(fn::AbstractString) = json(current(), fn)
+
 function html(plt::Plot, fn::AbstractString)
    fn = addExtension(fn, "html")
    io = open(fn, "w")
-    _use_remote[] = true
    show(io, MIME("text/html"), plt)
-    _use_remote[] = false
    close(io)
 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)
+end
+txt(fn::AbstractString) = txt(current(), fn)
+

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

-
 const _savemap = Dict(
    "png" => png,
    "svg" => svg,
    "pdf" => pdf,
-    "ps"  => ps,
+    "ps" => ps,
    "eps" => eps,
    "tex" => tex,
+    "json" => json,
    "html" => html,
-  )
+    "tikz" => tex,
+    "txt" => txt,
+)

-function getExtension(fn::AbstractString)
-  pieces = split(fn, ".")
-  length(pieces) > 1 || error("Can't extract file extension: ", fn)
-  ext = pieces[end]
-  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
-  ext
-end
+const _extension_map = Dict("tikz" => "tex")

 function addExtension(fn::AbstractString, ext::AbstractString)
-  try
-    oldext = getExtension(fn)
-    if oldext == ext
-      return fn
+    oldfn, oldext = splitext(fn)
+    oldext = chop(oldext, head = 1, tail = 0)
+    if get(_extension_map, oldext, oldext) == ext
+        return fn
    else
-      return "$fn.$ext"
+        return string(fn, ".", ext)
    end
-  catch
-    return "$fn.$ext"
-  end
 end

 """
@@ -105,27 +109,28 @@ type is inferred from the file extension. All backends support png and pdf
 file types, some also support svg, ps, eps, html and tex.
 """
 function savefig(plt::Plot, fn::AbstractString)
+    fn = abspath(expanduser(fn))

-  # get the extension
-  local ext
-  try
-    ext = getExtension(fn)
-  catch
-    # if we couldn't extract the extension, add the default
-    ext = defaultOutputFormat(plt)
-    fn = addExtension(fn, ext)
-  end
+    # get the extension
+    fn, ext = splitext(fn)
+    ext = chop(ext, head = 1, tail = 0)
+    if isempty(ext)
+        ext = defaultOutputFormat(plt)
+    end

-  # save it
-  func = get(_savemap, ext) do
-    error("Unsupported extension $ext with filename ", fn)
-  end
-  func(plt, fn)
+    # save it
+    if haskey(_savemap, ext)
+        func = _savemap[ext]
+        return func(plt, fn)
+    else
+        error("Invalid file extension: ", fn)
+    end
 end
 savefig(fn::AbstractString) = savefig(current(), fn)


 # ---------------------------------------------------------
+
 """
    gui([plot])

@@ -148,17 +153,13 @@ end
 _do_plot_show(plt, showval::Bool) = showval && gui(plt)
 function _do_plot_show(plt, showval::Symbol)
    showval == :gui && gui(plt)
-    showval in (:inline,:ijulia) && inline(plt)
+    showval in (:inline, :ijulia) && inline(plt)
 end

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

-const _best_html_output_type = KW(
-    :pyplot => :png,
-    :unicodeplots => :txt,
-    :plotlyjs => :html,
-    :plotly => :html
-)
+const _best_html_output_type =
+    KW(:pyplot => :png, :unicodeplots => :txt, :plotlyjs => :html, :plotly => :html)

 # a backup for html... passes to svg or png depending on the html_output_format arg
 function _show(io::IO, ::MIME"text/html", plt::Plot)
@@ -168,7 +169,12 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
    end
    if output_type == :png
        # @info("writing png to html output")
-        print(io, "<img src=\"data:image/png;base64,", base64encode(show, MIME("image/png"), plt), "\" />")
+        print(
+            io,
+            "<img src=\"data:image/png;base64,",
+            base64encode(show, MIME("image/png"), plt),
+            "\" />",
+        )
    elseif output_type == :svg
        # @info("writing svg to html output")
        show(io, MIME("image/svg+xml"), plt)
@@ -180,7 +186,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
 end

 # delegate showable to _show instead
-function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
+function Base.showable(m::M, plt::P) where {M <: MIME, P <: Plot}
    return hasmethod(_show, Tuple{IO, M, P})
 end

@@ -189,19 +195,32 @@ function _display(plt::Plot)
 end

 # for writing to io streams... first prepare, then callback
-for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
-             "application/eps", "application/pdf", "application/postscript",
-             "application/x-tex")
+for mime in (
+    "text/plain",
+    "text/html",
+    "image/png",
+    "image/eps",
+    "image/svg+xml",
+    "application/eps",
+    "application/pdf",
+    "application/postscript",
+    "application/x-tex",
+    "application/vnd.plotly.v1+json",
+)
    @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
        if haskey(io, :juno_plotsize)
-          showjuno(io, m, plt)
+            showjuno(io, m, plt)
        else
-          prepare_output(plt)
-          _show(io, m, plt)
+            prepare_output(plt)
+            _show(io, m, plt)
        end
+        return nothing
    end
 end

+Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
+    showjuno(io, MIME("text/html"), plt)
+
 # default text/plain for all backends
 _show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)

@@ -230,33 +249,36 @@ closeall() = closeall(backend())
 # Atom PlotPane
 # ---------------------------------------------------------
 function showjuno(io::IO, m, plt)
-    sz = plt[:size]
+    sz = collect(plt[:size])
    dpi = plt[:dpi]
    thickness_scaling = plt[:thickness_scaling]

    jsize = get(io, :juno_plotsize, [400, 500])
+    jratio = get(io, :juno_dpi_ratio, 1)

    scale = minimum(jsize[i] / sz[i] for i in 1:2)
-    plt[:size] = (s * scale for s in sz)
-    plt[:dpi] = Plots.DPI
+    plt[:size] = [s * scale for s in sz]
+    plt[:dpi] = jratio * Plots.DPI
    plt[:thickness_scaling] *= scale

    prepare_output(plt)
    try
-      _showjuno(io, m, plt)
+        _showjuno(io, m, plt)
    finally
-      plt[:size] = sz
-      plt[:dpi] = dpi
-      plt[:thickness_scaling] = thickness_scaling
+        plt[:size] = sz
+        plt[:dpi] = dpi
+        plt[:thickness_scaling] = thickness_scaling
    end
 end

 function _showjuno(io::IO, m::MIME"image/svg+xml", plt)
-  if Symbol(plt.attr[:html_output_format]) ≠ :svg
-    throw(MethodError(show, (typeof(m), typeof(plt))))
-  else
-    _show(io, m, plt)
-  end
+    if Symbol(plt.attr[:html_output_format]) ≠ :svg
+        throw(MethodError(show, (typeof(m), typeof(plt))))
+    else
+        _show(io, m, plt)
+    end
 end

+Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot) = false
+
 _showjuno(io::IO, m, plt) = _show(io, m, plt)
@@ -1,103 +1,74 @@
+# RecipesPipeline API

+## Warnings

-# ------------------------------------------------------------------
-# preprocessing
-
-function command_idx(kw_list::AVec{KW}, kw::KW)
-    Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
-end
-
-function _expand_seriestype_array(plotattributes::KW, args)
-    sts = get(plotattributes, :seriestype, :path)
-    if typeof(sts) <: AbstractArray
-        delete!(plotattributes, :seriestype)
-        rd = Vector{RecipeData}(undef, size(sts, 1))
-        for r in 1:size(sts, 1)
-            dc = copy(plotattributes)
-            dc[:seriestype] = sts[r:r,:]
-            rd[r] = RecipeData(dc, args)
-        end
-        rd
-    else
-        RecipeData[RecipeData(copy(plotattributes), args)]
-    end
-end
-
-function _preprocess_args(plotattributes::KW, args, still_to_process::Vector{RecipeData})
-    # the grouping mechanism is a recipe on a GroupBy object
-    # we simply add the GroupBy object to the front of the args list to allow
-    # the recipe to be applied
-    if haskey(plotattributes, :group)
-        args = (extractGroupArgs(plotattributes[:group], args...), args...)
-    end
-
-    # if we were passed a vector/matrix of seriestypes and there's more than one row,
-    # we want to duplicate the inputs, once for each seriestype row.
-    if !isempty(args)
-        append!(still_to_process, _expand_seriestype_array(plotattributes, args))
-    end
-
-    # remove subplot and axis args from plotattributes... they will be passed through in the kw_list
-    if !isempty(args)
-        for (k,v) in plotattributes
-            for defdict in (_subplot_defaults,
-                            _axis_defaults,
-                            _axis_defaults_byletter)
-                if haskey(defdict, k)
-                    delete!(plotattributes, k)
-                end
+function RecipesPipeline.warn_on_recipe_aliases!(
+    plt::Plot,
+    plotattributes,
+    recipe_type,
+    args...,
+)
+    for k in keys(plotattributes)
+        if !is_default_attribute(k)
+            dk = get(_keyAliases, k, k)
+            if k !== dk
+                @warn "Attribute alias `$k` detected in the $recipe_type recipe defined for the signature $(_signature_string(Val{recipe_type}, args...)). To ensure expected behavior it is recommended to use the default attribute `$dk`."
            end
+            plotattributes[dk] = RecipesPipeline.pop_kw!(plotattributes, k)
        end
    end
-
-    args
+end
+function RecipesPipeline.warn_on_recipe_aliases!(
+    plt::Plot,
+    v::AbstractVector,
+    recipe_type,
+    args...,
+)
+    foreach(x -> RecipesPipeline.warn_on_recipe_aliases!(plt, x, recipe_type, args...), v)
+end
+function RecipesPipeline.warn_on_recipe_aliases!(
+    plt::Plot,
+    rd::RecipeData,
+    recipe_type,
+    args...,
+)
+    RecipesPipeline.warn_on_recipe_aliases!(plt, rd.plotattributes, recipe_type, args...)
 end

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


-function _process_userrecipes(plt::Plot, plotattributes::KW, args)
-    still_to_process = RecipeData[]
-    args = _preprocess_args(plotattributes, args, still_to_process)
+## Grouping

-    # for plotting recipes, swap out the args and update the parameter dictionary
-    # we are keeping a stack of series that still need to be processed.
-    # each pass through the loop, we pop one off and apply the recipe.
-    # the recipe will return a list a Series objects... the ones that are
-    # finished (no more args) get added to the kw_list, the ones that are not
-    # are placed on top of the stack and are then processed further.
-    kw_list = KW[]
-    while !isempty(still_to_process)
-        # grab the first in line to be processed and either add it to the kw_list or
-        # pass it through apply_recipe to generate a list of RecipeData objects (data + attributes)
-        # for further processing.
-        next_series = popfirst!(still_to_process)
-        # recipedata should be of type RecipeData.  if it's not then the inputs must not have been fully processed by recipes
-        if !(typeof(next_series) <: RecipeData)
-            error("Inputs couldn't be processed... expected RecipeData but got: $next_series")
-        end
-        if isempty(next_series.args)
-            _process_userrecipe(plt, kw_list, next_series)
-        else
-            rd_list = RecipesBase.apply_recipe(next_series.plotattributes, next_series.args...)
-            prepend!(still_to_process,rd_list)
-        end
-    end
+RecipesPipeline.splittable_attribute(plt::Plot, key, val::SeriesAnnotations, len) =
+    RecipesPipeline.splittable_attribute(plt, key, val.strs, len)

-    # don't allow something else to handle it
-    plotattributes[:smooth] = false
-    kw_list
+function RecipesPipeline.split_attribute(plt::Plot, key, val::SeriesAnnotations, indices)
+    split_strs = _RecipesPipeline.split_attribute(key, val.strs, indices)
+    return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor)
 end

-function _process_userrecipe(plt::Plot, kw_list::Vector{KW}, recipedata::RecipeData)
-    # when the arg tuple is empty, that means there's nothing left to recursively
-    # process... finish up and add to the kw_list
-    kw = recipedata.plotattributes
-    preprocessArgs!(kw)
+
+## Preprocessing attributes
+
+RecipesPipeline.preprocess_attributes!(plt::Plot, plotattributes) =
+    RecipesPipeline.preprocess_attributes!(plotattributes) # in src/args.jl
+
+RecipesPipeline.is_axis_attribute(plt::Plot, attr) = is_axis_attr_noletter(attr) # in src/args.jl
+
+RecipesPipeline.is_subplot_attribute(plt::Plot, attr) = is_subplot_attr(attr) # in src/args.jl
+
+
+## User recipes
+
+function RecipesPipeline.process_userrecipe!(plt::Plot, kw_list, kw)
    _preprocess_userrecipe(kw)
-    warnOnUnsupported_scales(plt.backend, kw)
-
+    warn_on_unsupported_scales(plt.backend, kw)
    # add the plot index
    plt.n += 1
    kw[:series_plotindex] = plt.n
@@ -108,35 +79,34 @@ function _process_userrecipe(plt::Plot, kw_list::Vector{KW}, recipedata::RecipeD
    return
 end

-function _preprocess_userrecipe(kw::KW)
+function _preprocess_userrecipe(kw::AKW)
    _add_markershape(kw)

-    # if there was a grouping, filter the data here
-    _filter_input_data!(kw)
-
    # map marker_z if it's a Function
    if isa(get(kw, :marker_z, nothing), 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]) : map(kw[:marker_z], kw[:x], kw[:y], kw[:z])
+        kw[:marker_z] = isa(kw[:z], Nothing) ? map(kw[:marker_z], kw[:x], kw[:y]) :
+            map(kw[:marker_z], kw[:x], kw[:y], kw[:z])
    end

    # map line_z if it's a Function
    if isa(get(kw, :line_z, nothing), 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])
+        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
+    if get(kw, :ribbon, nothing) !== nothing
        make_fillrange_from_ribbon(kw)
    end
    return
 end

-function _add_errorbar_kw(kw_list::Vector{KW}, kw::KW)
+function _add_errorbar_kw(kw_list::Vector{KW}, kw::AKW)
    # handle error bars by creating new recipedata data... these will have
    # the same recipedata index as the recipedata they are copied from
-    for esym in (:xerror, :yerror)
-        if get(kw, esym, nothing) != nothing
+    for esym in (:xerror, :yerror, :zerror)
+        if get(kw, esym, nothing) !== nothing
            # we make a copy of the KW and apply an errorbar recipe
            errkw = copy(kw)
            errkw[:seriestype] = esym
@@ -147,65 +117,65 @@ function _add_errorbar_kw(kw_list::Vector{KW}, kw::KW)
    end
 end

-function _add_smooth_kw(kw_list::Vector{KW}, kw::KW)
+function _add_smooth_kw(kw_list::Vector{KW}, kw::AKW)
    # handle smoothing by adding a new series
    if get(kw, :smooth, false)
        x, y = kw[:x], kw[:y]
        β, α = convert(Matrix{Float64}, [x ones(length(x))]) \ convert(Vector{Float64}, y)
        sx = [ignorenan_minimum(x), ignorenan_maximum(x)]
        sy = β .* sx .+ α
-        push!(kw_list, merge(copy(kw), KW(
-            :seriestype => :path,
-            :x => sx,
-            :y => sy,
-            :fillrange => nothing,
-            :label => "",
-            :primary => false,
-        )))
+        push!(
+            kw_list,
+            merge(
+                copy(kw),
+                KW(
+                    :seriestype => :path,
+                    :x => sx,
+                    :y => sy,
+                    :fillrange => nothing,
+                    :label => "",
+                    :primary => false,
+                ),
+            ),
+        )
    end
 end

-# ------------------------------------------------------------------
-# plot recipes

-# Grab the first in line to be processed and pass it through apply_recipe
-# to generate a list of RecipeData objects (data + attributes).
-# If we applied a "plot recipe" without error, then add the returned datalist's KWs,
-# otherwise we just add the original KW.
-function _process_plotrecipe(plt::Plot, kw::KW, kw_list::Vector{KW}, still_to_process::Vector{KW})
-    if !isa(get(kw, :seriestype, nothing), Symbol)
-        # seriestype was never set, or it's not a Symbol, so it can't be a plot recipe
-        push!(kw_list, kw)
-        return
-    end
-    try
-        st = kw[:seriestype]
-        st = kw[:seriestype] = get(_typeAliases, st, st)
-        datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
-        for data in datalist
-            preprocessArgs!(data.plotattributes)
-            if data.plotattributes[:seriestype] == st
-                error("Plot recipe $st returned the same seriestype: $(data.plotattributes)")
-            end
-            push!(still_to_process, data.plotattributes)
-        end
-    catch err
-        if isa(err, MethodError)
-            push!(kw_list, kw)
-        else
-            rethrow()
+RecipesPipeline.get_axis_limits(plt::Plot, f, letter) = axis_limits(plt[1], letter)
+
+
+## Plot recipes
+
+RecipesPipeline.type_alias(plt::Plot) = get(_typeAliases, st, st)
+
+
+## Plot setup
+
+function RecipesPipeline.plot_setup!(plt::Plot, plotattributes, kw_list)
+    _plot_setup(plt, plotattributes, kw_list)
+    _subplot_setup(plt, plotattributes, kw_list)
+    return nothing
+end
+
+function RecipesPipeline.process_sliced_series_attributes!(plt::Plots.Plot, kw_list)
+    # swap errors
+    err_inds = findall(kw -> get(kw, :seriestype, :path) in (:xerror, :yerror, :zerror), kw_list)
+    for ind in err_inds
+        if get(kw_list[ind-1],:seriestype,:path) == :scatter
+            tmp = copy(kw_list[ind])
+            kw_list[ind] = copy(kw_list[ind-1])
+            kw_list[ind-1] = tmp
        end
    end
-    return
+    return nothing
 end


-# ------------------------------------------------------------------
-# setup plot and subplot
-
-function _plot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
+# TODO: Should some of this logic be moved to RecipesPipeline?
+function _plot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
    # merge in anything meant for the Plot
-    for kw in kw_list, (k,v) in kw
+    for kw in kw_list, (k, v) in kw
        haskey(_plot_defaults, k) && (plotattributes[k] = pop!(kw, k))
    end

@@ -216,7 +186,7 @@ function _plot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})

        # create the layout and subplots from the inputs
        plt.layout, plt.subplots, plt.spmap = build_layout(plt.attr)
-        for (idx,sp) in enumerate(plt.subplots)
+        for (idx, sp) in enumerate(plt.subplots)
            sp.plt = plt
            sp.attr[:subplot_index] = idx
        end
@@ -227,7 +197,7 @@ function _plot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})

    # handle inset subplots
    insets = plt[:inset_subplots]
-    if insets != nothing
+    if insets !== nothing
        if !(typeof(insets) <: AVec)
            insets = [insets]
        end
@@ -241,7 +211,7 @@ function _plot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
            else
                parent = plt.layout
            end
-            sp = Subplot(backend(), parent=parent)
+            sp = Subplot(backend(), parent = parent)
            sp.plt = plt
            push!(plt.subplots, sp)
            push!(plt.inset_subplots, sp)
@@ -252,33 +222,39 @@ function _plot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
    plt[:inset_subplots] = nothing
 end

-function _subplot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
+function _subplot_setup(plt::Plot, plotattributes::AKW, kw_list::Vector{KW})
    # we'll keep a map of subplot to an attribute override dict.
    # Subplot/Axis attributes set by a user/series recipe apply only to the
    # Subplot object which they belong to.
    # TODO: allow matrices to still apply to all subplots
-    sp_attrs = Dict{Subplot,Any}()
+    sp_attrs = Dict{Subplot, Any}()
    for kw in kw_list
        # get the Subplot object to which the series belongs.
        sps = get(kw, :subplot, :auto)
-        sp = get_subplot(plt, _cycle(sps == :auto ? plt.subplots : plt.subplots[sps], command_idx(kw_list,kw)))
+        sp = get_subplot(
+            plt,
+            _cycle(
+                sps == :auto ? plt.subplots : plt.subplots[sps],
+                series_idx(kw_list, kw),
+            ),
+        )
        kw[:subplot] = sp

        # extract subplot/axis attributes from kw and add to sp_attr
        attr = KW()
-        for (k,v) in collect(kw)
-            if haskey(_subplot_defaults, k) || haskey(_axis_defaults_byletter, k)
+        for (k, v) in collect(kw)
+            if is_subplot_attr(k) || is_axis_attr(k)
                attr[k] = pop!(kw, k)
            end
-            if haskey(_axis_defaults, k)
+            if is_axis_attr_noletter(k)
                v = pop!(kw, k)
-                for letter in (:x,:y,:z)
-                    attr[Symbol(letter,k)] = v
+                for letter in (:x, :y, :z)
+                    attr[Symbol(letter, k)] = v
                end
            end
-            for k in (:scale,), letter in (:x,:y,:z)
+            for k in (:scale,), letter in (:x, :y, :z)
                # Series recipes may need access to this information
-                lk = Symbol(letter,k)
+                lk = Symbol(letter, k)
                if haskey(attr, lk)
                    kw[lk] = attr[lk]
                end
@@ -288,7 +264,7 @@ function _subplot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
    end

    # override subplot/axis args.  `sp_attrs` take precendence
-    for (idx,sp) in enumerate(plt.subplots)
+    for (idx, sp) in enumerate(plt.subplots)
        attr = if !haskey(plotattributes, :subplot) || plotattributes[:subplot] == idx
            merge(plotattributes, get(sp_attrs, sp, KW()))
        else
@@ -301,9 +277,35 @@ function _subplot_setup(plt::Plot, plotattributes::KW, kw_list::Vector{KW})
    link_axes!(plt.layout, plt[:link])
 end

+function series_idx(kw_list::AVec{KW}, kw::AKW)
+    Int(kw[:series_plotindex]) - Int(kw_list[1][:series_plotindex]) + 1
+end
+
+
+## Series recipes
+
+function RecipesPipeline.slice_series_attributes!(plt::Plot, kw_list, kw)
+    sp::Subplot = kw[:subplot]
+    # in series attributes given as vector with one element per series,
+    # select the value for current series
+    _slice_series_args!(kw, plt, sp, series_idx(kw_list, kw))
+    return nothing
+end
+
+RecipesPipeline.series_defaults(plt::Plot) = _series_defaults # in args.jl
+
+RecipesPipeline.is_seriestype_supported(plt::Plot, st) = is_seriestype_supported(st)
+
+function RecipesPipeline.add_series!(plt::Plot, plotattributes)
+    sp = _prepare_subplot(plt, plotattributes)
+    _expand_subplot_extrema(sp, plotattributes, plotattributes[:seriestype])
+    _update_series_attributes!(plotattributes, plt, sp)
+    _add_the_series(plt, sp, plotattributes)
+end
+
 # getting ready to add the series... last update to subplot from anything
 # that might have been added during series recipes
-function _prepare_subplot(plt::Plot{T}, plotattributes::KW) where T
+function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T}
    st::Symbol = plotattributes[:seriestype]
    sp::Subplot{T} = plotattributes[:subplot]
    sp_idx = get_subplot_index(plt, sp)
@@ -312,7 +314,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::KW) where T
    st = _override_seriestype_check(plotattributes, st)

    # change to a 3d projection for this subplot?
-    if is3d(st)
+    if RecipesPipeline.needs_3d_axes(st)
        sp.attr[:projection] = "3d"
    end

@@ -324,14 +326,12 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::KW) where T
    sp
 end

-# ------------------------------------------------------------------
-# series types
-
-function _override_seriestype_check(plotattributes::KW, st::Symbol)
+function _override_seriestype_check(plotattributes::AKW, st::Symbol)
    # do we want to override the series type?
-    if !is3d(st) && !(st in (:contour,:contour3d))
+    if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d))
        z = plotattributes[:z]
-        if !isa(z, Nothing) && (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))
+        if !isa(z, Nothing) &&
+           (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))
            st = (st == :scatter ? :scatter3d : :path3d)
            plotattributes[:seriestype] = st
        end
@@ -339,30 +339,14 @@ function _override_seriestype_check(plotattributes::KW, st::Symbol)
    st
 end

-function _prepare_annotations(sp::Subplot, plotattributes::KW)
-    # strip out series annotations (those which are based on series x/y coords)
-    # and add them to the subplot attr
-    sp_anns = annotations(sp[:annotations])
-    # series_anns = annotations(pop!(plotattributes, :series_annotations, []))
-    # if isa(series_anns, SeriesAnnotations)
-    #     series_anns.x = plotattributes[:x]
-    #     series_anns.y = plotattributes[:y]
-    # elseif length(series_anns) > 0
-    #     x, y = plotattributes[:x], plotattributes[:y]
-    #     nx, ny, na = map(length, (x,y,series_anns))
-    #     n = max(nx, ny, na)
-    #     series_anns = [(x[mod1(i,nx)], y[mod1(i,ny)], text(series_anns[mod1(i,na)])) for i=1:n]
-    # end
-    # sp.attr[:annotations] = vcat(sp_anns, series_anns)
-end
-
-function _expand_subplot_extrema(sp::Subplot, plotattributes::KW, st::Symbol)
+function _expand_subplot_extrema(sp::Subplot, plotattributes::AKW, st::Symbol)
    # adjust extrema and discrete info
    if st == :image
-        xmin, xmax = ignorenan_extrema(plotattributes[:x]); ymin, ymax = ignorenan_extrema(plotattributes[:y])
+        xmin, xmax = ignorenan_extrema(plotattributes[:x])
+        ymin, ymax = ignorenan_extrema(plotattributes[:y])
        expand_extrema!(sp[:xaxis], (xmin, xmax))
        expand_extrema!(sp[:yaxis], (ymin, ymax))
-    elseif !(st in (:pie, :histogram, :bins2d, :histogram2d))
+    elseif !(st in (:histogram, :bins2d, :histogram2d))
        expand_extrema!(sp, plotattributes)
    end
    # expand for zerolines (axes through origin)
@@ -373,53 +357,23 @@ function _expand_subplot_extrema(sp::Subplot, plotattributes::KW, st::Symbol)
 end

 function _add_the_series(plt, sp, plotattributes)
-    warnOnUnsupported_args(plt.backend, plotattributes)
-    warnOnUnsupported(plt.backend, plotattributes)
+    extra_kwargs = warn_on_unsupported_args(plt.backend, plotattributes)
+    if (kw = plt[:extra_kwargs]) isa AbstractDict
+        plt[:extra_plot_kwargs] = get(kw,:plot,KW())
+        sp[:extra_kwargs] = get(kw,:subplot, KW())
+        plotattributes[:extra_kwargs] = get(kw,:series,KW())
+    elseif plt[:extra_kwargs] == :plot
+        plt[:extra_plot_kwargs] = extra_kwargs
+    elseif plt[:extra_kwargs] == :subplot
+        sp[:extra_kwargs] = extra_kwargs
+    elseif plt[:extra_kwargs] == :series
+        plotattributes[:extra_kwargs] = extra_kwargs
+    else
+        ArgumentError("Unsupported type for extra keyword arguments")
+    end
+    warn_on_unsupported(plt.backend, plotattributes)
    series = Series(plotattributes)
    push!(plt.series_list, series)
    push!(sp.series_list, series)
    _series_added(plt, series)
 end
-
-# -------------------------------------------------------------------------------
-
-# this method recursively applies series recipes when the seriestype is not supported
-# natively by the backend
-function _process_seriesrecipe(plt::Plot, plotattributes::KW)
-    # replace seriestype aliases
-    st = Symbol(plotattributes[:seriestype])
-    st = plotattributes[:seriestype] = get(_typeAliases, st, st)
-
-    # shapes shouldn't have fillrange set
-    if plotattributes[:seriestype] == :shape
-        plotattributes[:fillrange] = nothing
-    end
-
-    # if it's natively supported, finalize processing and pass along to the backend, otherwise recurse
-    if is_seriestype_supported(st)
-        sp = _prepare_subplot(plt, plotattributes)
-        _prepare_annotations(sp, plotattributes)
-        _expand_subplot_extrema(sp, plotattributes, st)
-        _update_series_attributes!(plotattributes, plt, sp)
-        _add_the_series(plt, sp, plotattributes)
-
-    else
-        # get a sub list of series for this seriestype
-        datalist = RecipesBase.apply_recipe(plotattributes, Val{st}, plotattributes[:x], plotattributes[:y], plotattributes[:z])
-
-        # assuming there was no error, recursively apply the series recipes
-        for data in datalist
-            if isa(data, RecipeData)
-                preprocessArgs!(data.plotattributes)
-                if data.plotattributes[:seriestype] == st
-                    error("The seriestype didn't change in series recipe $st.  This will cause a StackOverflow.")
-                end
-                _process_seriesrecipe(plt, data.plotattributes)
-            else
-                @warn("Unhandled recipe: $(data)")
-                break
-            end
-        end
-    end
-    nothing
-end
@@ -4,7 +4,7 @@ mutable struct CurrentPlot
 end
 const CURRENT_PLOT = CurrentPlot(nothing)

-isplotnull() = CURRENT_PLOT.nullableplot == nothing
+isplotnull() = CURRENT_PLOT.nullableplot === nothing

 """
    current()
@@ -49,7 +49,7 @@ as a String to look up its docstring; e.g. `plotattr("seriestype")`.
 function plot(args...; kw...)
    # this creates a new plot with args/kw and sets it to be the current plot
    plotattributes = KW(kw)
-    preprocessArgs!(plotattributes)
+    RecipesPipeline.preprocess_attributes!(plotattributes)

    # create an empty Plot then process
    plt = Plot()
@@ -61,7 +61,7 @@ end
 # note: we split into plt1 and plts_tail so we can dispatch correctly
 function plot(plt1::Plot, plts_tail::Plot...; kw...)
    plotattributes = KW(kw)
-    preprocessArgs!(plotattributes)
+    RecipesPipeline.preprocess_attributes!(plotattributes)

    # build our plot vector from the args
    n = length(plts_tail) + 1
@@ -96,7 +96,7 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)

    series_attr = KW()
    for (k,v) in plotattributes
-        if haskey(_series_defaults, k)
+        if is_series_attr(k)
            series_attr[k] = pop!(plotattributes,k)
        end
    end
@@ -119,7 +119,7 @@ function plot(plt1::Plot, plts_tail::Plot...; kw...)
        sp.attr[:subplot_index] = idx
        for series in serieslist
            merge!(series.plotattributes, series_attr)
-            _add_defaults!(series.plotattributes, plt, sp, cmdidx)
+            _slice_series_args!(series.plotattributes, plt, sp, cmdidx)
            push!(plt.series_list, series)
            _series_added(plt, series)
            cmdidx += 1
@@ -153,7 +153,7 @@ end
 # this adds to a specific plot... most plot commands will flow through here
 function plot!(plt::Plot, args...; kw...)
    plotattributes = KW(kw)
-    preprocessArgs!(plotattributes)
+    RecipesPipeline.preprocess_attributes!(plotattributes)
    # merge!(plt.user_attr, plotattributes)
    _plot!(plt, plotattributes, args)
 end
@@ -163,88 +163,11 @@ end
 # this is the core plotting function.  recursively apply recipes to build
 # a list of series KW dicts.
 # note: at entry, we only have those preprocessed args which were passed in... no default values yet
-function _plot!(plt::Plot, plotattributes::KW, args::Tuple)
-    plotattributes[:plot_object] = plt
-
-    if !isempty(args) && !isdefined(Main, :StatsPlots) &&
-            first(split(string(typeof(args[1])), ".")) == "DataFrames"
-        @warn("You're trying to plot a DataFrame, but this functionality is provided by StatsPlots")
-    end
-
-    # --------------------------------
-    # "USER RECIPES"
-    # --------------------------------
-
-    kw_list = _process_userrecipes(plt, plotattributes, args)
-
-    # @info(1)
-    # map(DD, kw_list)
-
-
-    # --------------------------------
-    # "PLOT RECIPES"
-    # --------------------------------
-
-    # "plot recipe", which acts like a series type, and is processed before
-    # the plot layout is created, which allows for setting layouts and other plot-wide attributes.
-    # we get inputs which have been fully processed by "user recipes" and "type recipes",
-    # so we can expect standard vectors, surfaces, etc.  No defaults have been set yet.
-    still_to_process = kw_list
-    kw_list = KW[]
-    while !isempty(still_to_process)
-        next_kw = popfirst!(still_to_process)
-        _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
-    end
-
-    # @info(2)
-    # map(DD, kw_list)
-
-    # --------------------------------
-    # Plot/Subplot/Layout setup
-    # --------------------------------
-    _plot_setup(plt, plotattributes, kw_list)
-    _subplot_setup(plt, plotattributes, kw_list)
-
-    # !!! note: At this point, kw_list is fully decomposed into individual series... one KW per series.          !!!
-    # !!!       The next step is to recursively apply series recipes until the backend supports that series type !!!
-
-    # --------------------------------
-    # "SERIES RECIPES"
-    # --------------------------------
-
-    # @info(3)
-    # map(DD, kw_list)
-
-    for kw in kw_list
-        sp::Subplot = kw[:subplot]
-        # idx = get_subplot_index(plt, sp)
-
-        # # we update subplot args in case something like the color palatte is part of the recipe
-        # _update_subplot_args(plt, sp, kw, idx, true)
-
-        # set default values, select from attribute cycles, and generally set the final attributes
-        _add_defaults!(kw, plt, sp, command_idx(kw_list,kw))
-
-        # now we have a fully specified series, with colors chosen.   we must recursively handle
-        # series recipes, which dispatch on seriestype.  If a backend does not natively support a seriestype,
-        # we check for a recipe that will convert that series type into one made up of lower-level components.
-        # For example, a histogram is just a bar plot with binned data, a bar plot is really a filled step plot,
-        # and a step plot is really just a path.  So any backend that supports drawing a path will implicitly
-        # be able to support step, bar, and histogram plots (and any recipes that use those components).
-        _process_seriesrecipe(plt, kw)
-    end
-
-    # --------------------------------
-
+function _plot!(plt::Plot, plotattributes, args)
+    RecipesPipeline.recipe_pipeline!(plt, plotattributes, args)
    current(plt)
-
-    # do we want to force display?
-    # if plt[:show]
-    #     gui(plt)
-    # end
    _do_plot_show(plt, plt[:show])
-
-    plt
+    return plt
 end


@@ -289,5 +212,3 @@ function plot!(sp::Subplot, args...; kw...)
    plt = sp.plt
    plot!(plt, args...; kw..., subplot = findfirst(isequal(sp), plt.subplots))
 end
-
-# --------------------------------------------------------------------
@@ -50,8 +50,13 @@ function plotattr(attrtype::Symbol, attribute::AbstractString)

    desc = get(_arg_desc, attribute, "")
    first_period_idx = findfirst(isequal('.'), desc)
-    typedesc = desc[1:first_period_idx-1]
-    desc = strip(desc[first_period_idx+1:end])
+    if isnothing(first_period_idx) 
+        typedesc = ""
+        desc = strip(desc)
+    else
+        typedesc = desc[1:first_period_idx-1]
+        desc = strip(desc[first_period_idx+1:end])
+    end
    als = keys(filter(x->x[2]==attribute, _keyAliases)) |> collect |> sort
    als = join(map(string,als), ", ")
    def = _attribute_defaults[attrtype][attribute]
@@ -1,3 +1,740 @@
 function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
+    isdefined(Plots, Symbol("#@layout")) && precompile(Tuple{getfield(Plots, Symbol("#@layout")), LineNumberNode, Module, Expr})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Array{Int64, 1}}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
+    isdefined(Plots, Symbol("#_make_hist##kw")) && precompile(Tuple{getfield(Plots, Symbol("#_make_hist##kw")), NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}}, typeof(Plots._make_hist), Tuple{Array{Float64, 1}}, Symbol})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{Symbol}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:formatter,), Tuple{typeof(RecipesPipeline.datetimeformatter)}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Int64, Int64}, Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:grid,), Tuple{Bool}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, ColorTypes.RGBA{Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:guide,), Tuple{String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, Base.StepRange{Int64, Int64}, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Float64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:rotation,), Tuple{Int64}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:scale, :guide), Tuple{Symbol, String}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Base.UnitRange{Int64}}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#attr!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#attr!##kw")), NamedTuple{(:ticks,), Tuple{Nothing}}, typeof(Plots.attr!), Plots.Axis})
+    isdefined(Plots, Symbol("#contour##kw")) && precompile(Tuple{getfield(Plots, Symbol("#contour##kw")), NamedTuple{(:fill,), Tuple{Bool}}, typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#default##kw")) && precompile(Tuple{getfield(Plots, Symbol("#default##kw")), NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}}, typeof(Plots.default)})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Array{Int64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#gr_polyline##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_polyline##kw")), NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}}, typeof(Plots.gr_polyline), Base.UnitRange{Int64}, Base.UnitRange{Int64}})
+    isdefined(Plots, Symbol("#gr_set_font##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_set_font##kw")), NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}}, typeof(Plots.gr_set_font), Plots.Font})
+    isdefined(Plots, Symbol("#gr_set_font##kw")) && precompile(Tuple{getfield(Plots, Symbol("#gr_set_font##kw")), NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, ColorTypes.RGBA{Float64}}}, typeof(Plots.gr_set_font), Plots.Font})
+    isdefined(Plots, Symbol("#heatmap##kw")) && precompile(Tuple{getfield(Plots, Symbol("#heatmap##kw")), NamedTuple{(:aspect_ratio,), Tuple{Int64}}, typeof(Plots.heatmap), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#histogram##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram##kw")), NamedTuple{(:bins, :weights), Tuple{Symbol, Array{Int64, 1}}}, typeof(Plots.histogram), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), NamedTuple{(:nbins, :show_empty_bins, :normed, :aspect_ratio), Tuple{Tuple{Int64, Int64}, Bool, Bool, Int64}}, typeof(Plots.histogram2d), Array{Base.Complex{Float64}, 1}})
+    isdefined(Plots, Symbol("#histogram2d##kw")) && precompile(Tuple{getfield(Plots, Symbol("#histogram2d##kw")), NamedTuple{(:nbins,), Tuple{Int64}}, typeof(Plots.histogram2d), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#hline!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#hline!##kw")), NamedTuple{(:line,), Tuple{Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}}}, typeof(Plots.hline!), Array{Float64, 2}})
+    isdefined(Plots, Symbol("#lens!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#lens!##kw")), NamedTuple{(:inset,), Tuple{Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}}}, typeof(Plots.lens!), Array{Int64, 1}, Int})
+    isdefined(Plots, Symbol("#pie##kw")) && precompile(Tuple{getfield(Plots, Symbol("#pie##kw")), NamedTuple{(:title, :l), Tuple{String, Float64}}, typeof(Plots.pie), Array{String, 1}, Int})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Float64, Float64, String})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, Plots.PlotText})
+    isdefined(Plots, Symbol("#plotly_annotation_dict##kw")) && precompile(Tuple{getfield(Plots, Symbol("#plotly_annotation_dict##kw")), NamedTuple{(:xref, :yref), Tuple{String, String}}, typeof(Plots.plotly_annotation_dict), Int64, Float64, String})
+    isdefined(Plots, Symbol("#portfoliocomposition##kw")) && precompile(Tuple{getfield(Plots, Symbol("#portfoliocomposition##kw")), NamedTuple{(:labels,), Tuple{Array{String, 2}}}, typeof(Plots.portfoliocomposition), Array{Float64, 2}, Int})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:marker, :series_annotations), Tuple{Tuple{Int64, Float64, Symbol}, Array{Any, 1}}}, typeof(Plots.scatter!), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:markersize, :c), Tuple{Int64, Symbol}}, typeof(Plots.scatter!), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#scatter!##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter!##kw")), NamedTuple{(:zcolor, :m, :ms, :lab), Tuple{Array{Float64, 1}, Tuple{Symbol, Float64, Plots.Stroke}, Array{Float64, 1}, String}}, typeof(Plots.scatter!), Array{Float64, 1}})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:framestyle, :title, :color, :layout, :label, :markerstrokewidth, :ticks), Tuple{Array{Symbol, 2}, Array{String, 2}, Base.ReshapedArray{Int64, 2, Base.UnitRange{Int64}, Tuple{}}, Int64, String, Int64, Base.UnitRange{Int64}}}, typeof(Plots.scatter), Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:m, :lab, :bg, :xlim, :ylim), Tuple{Tuple{Int64, Symbol}, Array{String, 2}, Symbol, Tuple{Int64, Int64}, Tuple{Int64, Int64}}}, typeof(Plots.scatter), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    isdefined(Plots, Symbol("#scatter##kw")) && precompile(Tuple{getfield(Plots, Symbol("#scatter##kw")), NamedTuple{(:marker_z, :color, :legend), Tuple{typeof(Base.:+), Symbol, Bool}}, typeof(Plots.scatter), Array{Float64, 1}, Array{Float64, 1}})
+    isdefined(Plots, Symbol("#standalone_html##kw")) && precompile(Tuple{getfield(Plots, Symbol("#standalone_html##kw")), NamedTuple{(:title,), Tuple{String}}, typeof(Plots.standalone_html), Plots.Plot{Plots.PlotlyBackend}})
+    isdefined(Plots, Symbol("#test_examples##kw")) && precompile(Tuple{getfield(Plots, Symbol("#test_examples##kw")), NamedTuple{(:skip,), Tuple{Array{Int64, 1}}}, typeof(Plots.test_examples), Symbol})
+    precompile(Tuple{typeof(Plots.__init__)})
+    precompile(Tuple{typeof(Plots._add_errorbar_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._add_markershape), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._add_smooth_kw), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._add_the_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._as_gradient), PlotUtils.ContinuousColorGradient})
+    precompile(Tuple{typeof(Plots._backend_instance), Symbol})
+    precompile(Tuple{typeof(Plots._bin_centers), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._binbarlike_baseline), Float64, Symbol})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Int64, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Nothing, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{PlotUtils.ContinuousColorGradient, 1}, String})
+    precompile(Tuple{typeof(Plots._cbar_unique), Array{Symbol, 1}, String})
+    precompile(Tuple{typeof(Plots._create_backend_figure), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._create_backend_figure), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._cycle), Array{Any, 1}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots._cycle), Array{Float64, 1}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Array{Plots.Subplot{T} where T<:RecipesBase.AbstractBackend, 1}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Array{String, 1}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Base.OneTo{Int64}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Base.StepRange{Int64, Int64}, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), ColorTypes.RGBA{Float64}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Float64, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Int64, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots._cycle), Int64, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Nothing, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots._cycle), Nothing, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots._cycle), Nothing, Int64})
+    precompile(Tuple{typeof(Plots._cycle), PlotUtils.ColorPalette, Int64})
+    precompile(Tuple{typeof(Plots._cycle), PlotUtils.ContinuousColorGradient, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Plots.Shape, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Plots.Subplot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots._cycle), Symbol, Int64})
+    precompile(Tuple{typeof(Plots._display), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Bool})
+    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots._do_plot_show), Plots.Plot{Plots.PlotlyBackend}, Bool})
+    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._expand_subplot_extrema), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._heatmap_edges), Array{Float64, 1}, Bool})
+    precompile(Tuple{typeof(Plots._hist_edge), Tuple{Array{Float64, 1}}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Int64})
+    precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}, Array{Float64, 1}}, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots._hist_edges), Tuple{Array{Float64, 1}}, Symbol})
+    precompile(Tuple{typeof(Plots._initialize_backend), Plots.PlotlyBackend})
+    precompile(Tuple{typeof(Plots._override_seriestype_check), RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots._pick_default_backend)})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}, Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Int64}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{typeof(Base.log), Int64}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{Float64, 1}, 1}, Array{Array{Float64, 1}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Array{T, 1} where T, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Base.Complex{Float64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Dates.DateTime, 1}, Base.UnitRange{Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Function, 1}, Float64, Float64}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Int64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Plots.OHLC{T} where T<:Real, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{String, 1}, Array{String, 1}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Tuple{Int64, Real}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Array{Union{Base.Missing, Int64}, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.StepRange{Int64, Int64}, Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Base.UnitRange{Int64}}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.PortfolioComposition}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{Plots.Spy}})
+    precompile(Tuple{typeof(Plots._plot!), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Tuple{}})
+    precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._plot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._plotly_framestyle), Symbol})
+    precompile(Tuple{typeof(Plots._plots_defaults)})
+    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._prepare_subplot), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Array{Int64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_barlike), RecipesPipeline.DefaultsDict, Base.OneTo{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_binlike), RecipesPipeline.DefaultsDict, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots._preprocess_userrecipe), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._replace_linewidth), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._replace_markershape), Array{Symbol, 2}})
+    precompile(Tuple{typeof(Plots._replace_markershape), Plots.Shape})
+    precompile(Tuple{typeof(Plots._scale_adjusted_values), Type{Float64}, Array{Float64, 1}, Symbol})
+    precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._series_index), RecipesPipeline.DefaultsDict, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._show), Base.IOStream, Base.Multimedia.MIME{Symbol("image/png")}, Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), Base.Dict{Symbol, Any}, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Int64})
+    precompile(Tuple{typeof(Plots._slice_series_args!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Int64})
+    precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._subplot_setup), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Array{Base.Dict{Symbol, Any}, 1}})
+    precompile(Tuple{typeof(Plots._transform_ticks), Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots._transform_ticks), Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots._transform_ticks), Nothing})
+    precompile(Tuple{typeof(Plots._transform_ticks), Symbol})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Axis, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Symbol, Int64})
+    precompile(Tuple{typeof(Plots._update_axis_colors), Plots.Axis})
+    precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.GRBackend}, Plots.Axis, Symbol})
+    precompile(Tuple{typeof(Plots._update_axis_links), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Symbol})
+    precompile(Tuple{typeof(Plots._update_clims), Float64, Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots._update_clims), Float64, Float64, Int64, Int64})
+    precompile(Tuple{typeof(Plots._update_min_padding!), Plots.GridLayout})
+    precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_min_padding!), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots._update_plot_args), Plots.Plot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_series_attributes!), RecipesPipeline.DefaultsDict, Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, Base.Dict{Symbol, Any}, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_args), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict, Int64, Bool})
+    precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots._update_subplot_colors), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.GRBackend}, Array{Any, 1}})
+    precompile(Tuple{typeof(Plots._update_subplot_periphery), Plots.Subplot{Plots.PlotlyBackend}, Array{Any, 1}})
+    precompile(Tuple{typeof(Plots.addExtension), String, String})
+    precompile(Tuple{typeof(Plots.add_layout_pct!), Base.Dict{Symbol, Any}, Expr, Int64, Int64})
+    precompile(Tuple{typeof(Plots.aliasesAndAutopick), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}, Array{Symbol, 1}, Int64})
+    precompile(Tuple{typeof(Plots.allAlphas), Int64})
+    precompile(Tuple{typeof(Plots.allStyles), Int64})
+    precompile(Tuple{typeof(Plots.allStyles), Symbol})
+    precompile(Tuple{typeof(Plots.annotate!), Array{Tuple{Int64, Float64, Plots.PlotText}, 1}})
+    precompile(Tuple{typeof(Plots.arrow), Int64})
+    precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.attr), Plots.EmptyLayout, Symbol})
+    precompile(Tuple{typeof(Plots.autopick_ignore_none_auto), Array{Symbol, 1}, Int64})
+    precompile(Tuple{typeof(Plots.axis_drawing_info), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.axis_drawing_info_3d), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.GRBackend}, Symbol, Bool, Bool})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.PlotlyBackend}, Symbol, Bool, Bool})
+    precompile(Tuple{typeof(Plots.axis_limits), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.backend), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.backend), Plots.PlotlyBackend})
+    precompile(Tuple{typeof(Plots.backend), Symbol})
+    precompile(Tuple{typeof(Plots.backend)})
+    precompile(Tuple{typeof(Plots.bar), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.bbox!), Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bbox!), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bbox!), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bbox), Float64, Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots.bbox), Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
+    precompile(Tuple{typeof(Plots.bbox_to_pcts), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Bool})
+    precompile(Tuple{typeof(Plots.bbox_to_pcts), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
+    precompile(Tuple{typeof(Plots.bottom), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.bottom), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}})
+    precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.bottompad), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64, Array{Plots.Plot{T} where T<:RecipesBase.AbstractBackend, 1}})
+    precompile(Tuple{typeof(Plots.build_layout), Plots.GridLayout, Int64})
+    precompile(Tuple{typeof(Plots.build_layout), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.EmptyLayout})
+    precompile(Tuple{typeof(Plots.calc_num_subplots), Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.color_or_nothing!), RecipesPipeline.DefaultsDict, Symbol})
+    precompile(Tuple{typeof(Plots.colorbar_style), Plots.Series})
+    precompile(Tuple{typeof(Plots.compute_gridsize), Int64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.concatenate_fillrange), Base.UnitRange{Int64}, Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.contour), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Int})
+    precompile(Tuple{typeof(Plots.contour_levels), Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.convertLegendValue), Bool})
+    precompile(Tuple{typeof(Plots.convertLegendValue), Symbol})
+    precompile(Tuple{typeof(Plots.convert_sci_unicode), String})
+    precompile(Tuple{typeof(Plots.convert_to_polar), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Int64, Float64}})
+    precompile(Tuple{typeof(Plots.copy_series!), Plots.Series, Symbol})
+    precompile(Tuple{typeof(Plots.create_grid), Expr})
+    precompile(Tuple{typeof(Plots.create_grid), Symbol})
+    precompile(Tuple{typeof(Plots.create_grid_curly), Expr})
+    precompile(Tuple{typeof(Plots.create_grid_vcat), Expr})
+    precompile(Tuple{typeof(Plots.default), Symbol, Bool})
+    precompile(Tuple{typeof(Plots.default), Symbol, Int64})
+    precompile(Tuple{typeof(Plots.default), Symbol, String})
+    precompile(Tuple{typeof(Plots.default), Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.default), Symbol})
+    precompile(Tuple{typeof(Plots.default_should_widen), Plots.Axis})
+    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{String, 1}})
+    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Array{Union{Base.Missing, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Base.Missing})
+    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, Char})
+    precompile(Tuple{typeof(Plots.discrete_value!), Plots.Axis, String})
+    precompile(Tuple{typeof(Plots.ensure_gradient!), RecipesPipeline.DefaultsDict, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.error_coords), Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.error_style!), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.error_zipit), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Float64})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Int64})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Axis, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.GRBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.expand_extrema!), Plots.Subplot{Plots.PlotlyBackend}, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.extend_by_data!), Array{Float64, 1}, Float64})
+    precompile(Tuple{typeof(Plots.extend_series_data!), Plots.Series, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.fakedata), Int64, Int64})
+    precompile(Tuple{typeof(Plots.fg_color), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.font), Int64, Int})
+    precompile(Tuple{typeof(Plots.font), String, Int})
+    precompile(Tuple{typeof(Plots.font), Symbol, Int})
+    precompile(Tuple{typeof(Plots.frame), Plots.Animation, Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.frame), Plots.Animation})
+    precompile(Tuple{typeof(Plots.get_aspect_ratio), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_aspect_ratio), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.get_axis), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.get_axis), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.GRBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.PlotlyBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.get_clims), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.get_colorgradient), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_fillalpha), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_fillalpha), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Float64, Float64, Int64})
+    precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Tuple{Float64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.get_fillcolor), Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.get_gradient), PlotUtils.ContinuousColorGradient})
+    precompile(Tuple{typeof(Plots.get_linealpha), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linealpha), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Float64, Float64, Int64})
+    precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Tuple{Float64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.get_linecolor), Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.get_linestyle), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linestyle), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_linewidth), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_linewidth), Plots.Series})
+    precompile(Tuple{typeof(Plots.get_markeralpha), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_markercolor), Plots.Series, Float64, Float64, Int64})
+    precompile(Tuple{typeof(Plots.get_markerstrokealpha), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_markerstrokecolor), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Float64, 1}, Array{String, 1}}})
+    precompile(Tuple{typeof(Plots.get_minor_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Tuple{Array{Int64, 1}, Array{String, 1}}})
+    precompile(Tuple{typeof(Plots.get_plotly_marker), Symbol, String})
+    precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), ColorTypes.RGBA{Float64}, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Int64, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Int64, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), PlotUtils.ContinuousColorGradient, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), PlotUtils.ContinuousColorGradient, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Symbol, Plots.Subplot{Plots.GRBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_series_color), Symbol, Plots.Subplot{Plots.PlotlyBackend}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.get_subplot), Plots.Plot{Plots.GRBackend}, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.get_subplot), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.get_ticks), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.get_ticks), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.get_xy), Array{Plots.OHLC{T} where T<:Real, 1}, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.get_xy), Plots.OHLC{Float64}, Int64, Float64})
+    precompile(Tuple{typeof(Plots.gr_axis_height), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.gr_axis_width), Plots.Subplot{Plots.GRBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.gr_color), ColorTypes.RGBA{Float64}, Type{ColorTypes.RGB{Float64}}})
+    precompile(Tuple{typeof(Plots.gr_colorbar_colors), Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_contour_levels), Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_display), Plots.Plot{Plots.GRBackend}, String})
+    precompile(Tuple{typeof(Plots.gr_display), Plots.Subplot{Plots.GRBackend}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.gr_draw_colorbar), Plots.GRColorbar, Plots.Subplot{Plots.GRBackend}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Int64, Float64, Float64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Int64, Float64, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Float64, Float64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Float64, Tuple{Float64, Float64}, Int64, Float64, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Int64, Tuple{Float64, Float64}, Int64, Float64, Float64, Plots.Shape})
+    precompile(Tuple{typeof(Plots.gr_draw_marker), Plots.Series, Int64, Int64, Tuple{Float64, Float64}, Int64, Float64, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Int64, 1}, Tuple{Float64, Float64}, Int64, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Array{Int64, 1}, Array{Int64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}, Array{Float64, 1}, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.OneTo{Int64}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Float64, Float64}, Int64, Int64})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.gr_draw_markers), Plots.Series, Float64, Float64, Tuple{Float64, Float64}, Float64, Float64})
+    precompile(Tuple{typeof(Plots.gr_fill_viewport), Array{Float64, 1}, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Float64, 1}, Array{Any, 1}}, Int64})
+    precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Float64, 1}, Array{String, 1}}, Int64})
+    precompile(Tuple{typeof(Plots.gr_get_ticks_size), Tuple{Array{Int64, 1}, Array{String, 1}}, Int64})
+    precompile(Tuple{typeof(Plots.gr_getcolorind), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_inqtext), Int64, Int64, String})
+    precompile(Tuple{typeof(Plots.gr_legend_pos), Plots.Subplot{Plots.GRBackend}, Float64, Float64})
+    precompile(Tuple{typeof(Plots.gr_linetype), Symbol})
+    precompile(Tuple{typeof(Plots.gr_polaraxes), Int64, Float64, Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}, typeof(identity)})
+    precompile(Tuple{typeof(Plots.gr_polyline), Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.gr_set_bordercolor), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_fill), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_fillcolor), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_font), Plots.Font})
+    precompile(Tuple{typeof(Plots.gr_set_gradient), PlotUtils.ContinuousColorGradient})
+    precompile(Tuple{typeof(Plots.gr_set_gradient), Plots.Series})
+    precompile(Tuple{typeof(Plots.gr_set_line), Float64, Symbol, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_line), Int64, Symbol, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_line), Int64, Symbol, PlotUtils.ContinuousColorGradient})
+    precompile(Tuple{typeof(Plots.gr_set_linecolor), PlotUtils.ContinuousColorGradient})
+    precompile(Tuple{typeof(Plots.gr_set_markercolor), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_textcolor), ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Float64})
+    precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Int64})
+    precompile(Tuple{typeof(Plots.gr_set_transparency), ColorTypes.RGBA{Float64}, Nothing})
+    precompile(Tuple{typeof(Plots.gr_set_transparency), Float64})
+    precompile(Tuple{typeof(Plots.gr_set_viewport_polar)})
+    precompile(Tuple{typeof(Plots.gr_set_xticks_font), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.gr_set_yticks_font), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.gr_text), Float64, Float64, String})
+    precompile(Tuple{typeof(Plots.gr_text_size), String, Int64})
+    precompile(Tuple{typeof(Plots.gr_text_size), String})
+    precompile(Tuple{typeof(Plots.gr_tick_label), Plots.Axis, String})
+    precompile(Tuple{typeof(Plots.gr_update_colorbar!), Plots.GRColorbar, Plots.Series})
+    precompile(Tuple{typeof(Plots.gr_viewport_from_bbox), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.gr_w3tondc), Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.gui), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.guide_padding), Plots.Axis})
+    precompile(Tuple{typeof(Plots.guidefont), Plots.Axis})
+    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Array{Symbol, 2}, Symbol})
+    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}, Symbol})
+    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Plots.Shape, Symbol})
+    precompile(Tuple{typeof(Plots.handleColors!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.has_attribute_segments), Plots.Series})
+    precompile(Tuple{typeof(Plots.has_black_border_for_default), Symbol})
+    precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.hascolorbar), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.hasgrid), Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.heatmap), Array{Dates.DateTime, 1}, Int})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Array{Float64, 1}, Symbol, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Base.UnitRange{Int64}, Symbol, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol, Bool})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Array{Float64, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol, Bool})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Symbol})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Base.UnitRange{Int64}, Symbol, Bool})
+    precompile(Tuple{typeof(Plots.heatmap_edges), Base.UnitRange{Int64}, Symbol})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.ignorenan_extrema), Plots.Axis})
+    precompile(Tuple{typeof(Plots.ignorenan_maximum), Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.ignorenan_minimum), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.ignorenan_minimum), Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.inline), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.intersection_point), Float64, Float64, Float64, Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots.is_2tuple), Int64})
+    precompile(Tuple{typeof(Plots.is_2tuple), Symbol})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Array{Float64, 1}, Array{Float64, 1}}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Float64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.is_2tuple), Tuple{Int64, Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}}})
+    precompile(Tuple{typeof(Plots.is_axis_attr), Symbol})
+    precompile(Tuple{typeof(Plots.is_default_attribute), Symbol})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.GRBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.PlotlyBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Shape})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Plots.Stroke})
+    precompile(Tuple{typeof(Plots.is_marker_supported), Symbol})
+    precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.GRBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_seriestype_supported), Plots.PlotlyBackend, Symbol})
+    precompile(Tuple{typeof(Plots.is_seriestype_supported), Symbol})
+    precompile(Tuple{typeof(Plots.is_uniformly_spaced), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iscontour), Plots.Series})
+    precompile(Tuple{typeof(Plots.isijulia)})
+    precompile(Tuple{typeof(Plots.ispolar), Plots.Series})
+    precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.ispolar), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.isvertical), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.isvertical), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}, Int})
+    precompile(Tuple{typeof(Plots.iter_segments), Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Array{Int64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.OneTo{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.OneTo{Int64}, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.StepRange{Int64, Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Base.UnitRange{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.iter_segments), Plots.Series})
+    precompile(Tuple{typeof(Plots.labelfunc), Symbol, Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.labelfunc), Symbol, Plots.PlotlyBackend})
+    precompile(Tuple{typeof(Plots.layout_args), Base.Dict{Symbol, Any}, Int64})
+    precompile(Tuple{typeof(Plots.layout_args), Int64, Int64})
+    precompile(Tuple{typeof(Plots.layout_args), Int64, Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.layout_args), Int64, Tuple{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.layout_args), Int64})
+    precompile(Tuple{typeof(Plots.layout_args), Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.layout_args), RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.left), Measures.BoundingBox{Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}, Tuple{Measures.Length{:w, Float64}, Measures.Length{:h, Float64}}}})
+    precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.leftpad), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.legendfont), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.legendfont), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.legendtitlefont), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.link_axes!), Array{RecipesBase.AbstractLayout, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis, Plots.Axis})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.Axis})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.GridLayout, Symbol})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.GRBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.link_axes!), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.link_subplots), Array{RecipesBase.AbstractLayout, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.locate_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.make_fillrange_from_ribbon), Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Base.LinRange{Float64}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.make_fillrange_side), Base.UnitRange{Int64}, Int64})
+    precompile(Tuple{typeof(Plots.make_steps), Array{Float64, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.make_steps), Array{Int64, 1}, Symbol})
+    precompile(Tuple{typeof(Plots.make_steps), Base.OneTo{Int64}, Symbol})
+    precompile(Tuple{typeof(Plots.make_steps), Nothing, Symbol})
+    precompile(Tuple{typeof(Plots.nanappend!), Array{Float64, 1}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.ohlc), Array{Plots.OHLC{T} where T<:Real, 1}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.GRBackend}, Plots.Axis, Nothing})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.optimal_ticks_and_labels), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis, Nothing})
+    precompile(Tuple{typeof(Plots.parse_axis_kw), Symbol})
+    precompile(Tuple{typeof(Plots.partialcircle), Float64, Float64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.partialcircle), Int64, Float64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.plotarea!), Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.plotarea!), Plots.Subplot{Plots.GRBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.plotarea!), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.plotarea), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.plotarea), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_annotation_dict), Float64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.plotly_apply_aspect_ratio), Plots.Subplot{Plots.PlotlyBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_axis), Plots.Plot{Plots.PlotlyBackend}, Plots.Axis, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_colorbar_hack), Plots.Series, Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.plotly_colorscale), PlotUtils.CategoricalColorGradient, Int64})
+    precompile(Tuple{typeof(Plots.plotly_colorscale), PlotUtils.ContinuousColorGradient, Int64})
+    precompile(Tuple{typeof(Plots.plotly_colorscale), PlotUtils.ContinuousColorGradient, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_data), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_data), Plots.Series, Symbol, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_domain), Plots.Subplot{Plots.PlotlyBackend}, Symbol})
+    precompile(Tuple{typeof(Plots.plotly_font), Plots.Font, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.plotly_font), Plots.Font})
+    precompile(Tuple{typeof(Plots.plotly_hover!), Base.Dict{Symbol, Any}, Array{Nothing, 1}})
+    precompile(Tuple{typeof(Plots.plotly_hover!), Base.Dict{Symbol, Any}, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_html_body), Plots.Plot{Plots.PlotlyBackend}, Nothing})
+    precompile(Tuple{typeof(Plots.plotly_html_head), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_layout), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_legend_pos), Symbol})
+    precompile(Tuple{typeof(Plots.plotly_link_indicies), Plots.Plot{Plots.PlotlyBackend}, Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Float64, 2}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.OneTo{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.StepRange{Int64, Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, Base.UnitRange{Int64}})
+    precompile(Tuple{typeof(Plots.plotly_native_data), Plots.Axis, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.plotly_polar!), Base.Dict{Symbol, Any}, Plots.Series})
+    precompile(Tuple{typeof(Plots.plotly_polaraxis), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}, Plots.Series})
+    precompile(Tuple{typeof(Plots.plotly_series), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Array{Float64, 1}, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Float64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Array{Int64, 1}, Array{Int64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.OneTo{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.OneTo{Int64}, Base.UnitRange{Int64}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Base.UnitRange{Int64}, Array{Float64, 1}, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_segments), Plots.Series, Base.Dict{Symbol, Any}, Nothing, Nothing, Nothing, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_series_shapes), Plots.Plot{Plots.PlotlyBackend}, Plots.Series, Tuple{Float64, Float64}})
+    precompile(Tuple{typeof(Plots.plotly_surface_data), Plots.Series, RecipesPipeline.Surface{Array{Float64, 2}}})
+    precompile(Tuple{typeof(Plots.png), Plots.Plot{Plots.GRBackend}, String})
+    precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.prepare_output), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Bool})
+    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Int64})
+    precompile(Tuple{typeof(Plots.processFillArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Int64})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, String})
+    precompile(Tuple{typeof(Plots.processFontArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Int64, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.processGridArg!), RecipesPipeline.DefaultsDict, Bool, Symbol})
+    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
+    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Float64})
+    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Int64})
+    precompile(Tuple{typeof(Plots.processLineArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Array{Symbol, 2}})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Bool})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, ColorTypes.RGBA{Float64}})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Float64})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Int64})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Shape})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Plots.Stroke})
+    precompile(Tuple{typeof(Plots.processMarkerArg), Base.Dict{Symbol, Any}, Symbol})
+    precompile(Tuple{typeof(Plots.processMinorGridArg!), Base.Dict{Symbol, Any}, Bool, Symbol})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.GRBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText, Plots.Font})
+    precompile(Tuple{typeof(Plots.process_annotation), Plots.Subplot{Plots.PlotlyBackend}, Int64, Float64, Plots.PlotText})
+    precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Base.StepRange{Int64, Int64}, Symbol})
+    precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, String, Symbol})
+    precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.process_axis_arg!), Base.Dict{Symbol, Any}, Tuple{Int64, Int64}, Symbol})
+    precompile(Tuple{typeof(Plots.recompute_lengths), Array{Measures.Measure, 1}})
+    precompile(Tuple{typeof(Plots.replaceAlias!), Base.Dict{Symbol, Any}, Symbol, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.replaceAlias!), RecipesPipeline.DefaultsDict, Symbol, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.replaceAliases!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.replaceAliases!), RecipesPipeline.DefaultsDict, Base.Dict{Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.reset_axis_defaults_byletter!)})
+    precompile(Tuple{typeof(Plots.right), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.rightpad), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.rowsize), Expr})
+    precompile(Tuple{typeof(Plots.rowsize), Symbol})
+    precompile(Tuple{typeof(Plots.series_annotations), Array{Any, 1}})
+    precompile(Tuple{typeof(Plots.series_annotations), Plots.SeriesAnnotations})
+    precompile(Tuple{typeof(Plots.series_annotations_shapes!), Plots.Series, Symbol})
+    precompile(Tuple{typeof(Plots.series_idx), Array{Base.Dict{Symbol, Any}, 1}, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.shape_data), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.should_add_to_legend), Plots.Series})
+    precompile(Tuple{typeof(Plots.showaxis), Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.shrink_by), Float64, Float64, Float64})
+    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any}, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.slice_arg!), Base.Dict{Symbol, Any}, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.slice_arg!), RecipesPipeline.DefaultsDict, RecipesPipeline.DefaultsDict, Symbol, Int64, Bool})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{ColorTypes.RGBA{Float64}, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{Float64, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{Measures.Length{:mm, Float64}, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{PlotUtils.ContinuousColorGradient, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{String, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Array{Symbol, 2}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Base.ReshapedArray{Int64, 2, Base.UnitRange{Int64}, Tuple{}}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Base.StepRange{Int64, Int64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Base.UnitRange{Int64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Bool, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), ColorTypes.RGBA{Float64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Float64, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Int64, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Nothing, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), String, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Symbol, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Tuple{Float64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Float64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), Tuple{Int64, Int64}, Int64})
+    precompile(Tuple{typeof(Plots.slice_arg), typeof(identity), Int64})
+    precompile(Tuple{typeof(Plots.straightline_data), Plots.Series, Int64})
+    precompile(Tuple{typeof(Plots.straightline_data), Tuple{Int64, Int64}, Tuple{Float64, Float64}, Array{Float64, 1}, Array{Float64, 1}, Int64})
+    precompile(Tuple{typeof(Plots.stroke), Int64, Int})
+    precompile(Tuple{typeof(Plots.supported_markers), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.supported_markers), Plots.PlotlyBackend})
+    precompile(Tuple{typeof(Plots.supported_markers)})
+    precompile(Tuple{typeof(Plots.supported_styles), Plots.GRBackend})
+    precompile(Tuple{typeof(Plots.supported_styles), Plots.PlotlyBackend})
+    precompile(Tuple{typeof(Plots.supported_styles)})
+    precompile(Tuple{typeof(Plots.test_examples), Symbol})
+    precompile(Tuple{typeof(Plots.text), String, Int64, Symbol, Symbol})
+    precompile(Tuple{typeof(Plots.text), String, Plots.Font})
+    precompile(Tuple{typeof(Plots.text), String, Symbol, Int64, Int})
+    precompile(Tuple{typeof(Plots.text), String, Symbol})
+    precompile(Tuple{typeof(Plots.text_size), Int64, Int64, Int64})
+    precompile(Tuple{typeof(Plots.tick_padding), Plots.Subplot{Plots.PlotlyBackend}, Plots.Axis})
+    precompile(Tuple{typeof(Plots.tickfont), Plots.Axis})
+    precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{Any, 1}}})
+    precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Float64, 1}, Array{String, 1}}})
+    precompile(Tuple{typeof(Plots.ticksType), Tuple{Array{Int64, 1}, Array{String, 1}}})
+    precompile(Tuple{typeof(Plots.title!), String})
+    precompile(Tuple{typeof(Plots.title_padding), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.titlefont), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.top), Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}})
+    precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.toppad), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.transpose_z), Plots.Series, Array{Float64, 2}, Bool})
+    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout, Array{Measures.Length{:mm, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.GridLayout})
+    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.Subplot{Plots.GRBackend}, Array{Measures.Length{:mm, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.update_child_bboxes!), Plots.Subplot{Plots.PlotlyBackend}, Array{Measures.Length{:mm, Float64}, 1}})
+    precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.update_inset_bboxes!), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.vline!), Array{Int64, 1}})
+    precompile(Tuple{typeof(Plots.wand_edges), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.GRBackend, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.GRBackend, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_args), Plots.PlotlyBackend, RecipesPipeline.DefaultsDict})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.GRBackend, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.warn_on_unsupported_scales), Plots.PlotlyBackend, Base.Dict{Symbol, Any}})
+    precompile(Tuple{typeof(Plots.widen), Float64, Float64, Symbol})
+    precompile(Tuple{typeof(Plots.wraptuple), Array{Any, 1}})
+    precompile(Tuple{typeof(Plots.wraptuple), Array{Float64, 1}})
+    precompile(Tuple{typeof(Plots.wraptuple), Base.StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
+    precompile(Tuple{typeof(Plots.wraptuple), Bool})
+    precompile(Tuple{typeof(Plots.wraptuple), Float64})
+    precompile(Tuple{typeof(Plots.wraptuple), Int64})
+    precompile(Tuple{typeof(Plots.wraptuple), Nothing})
+    precompile(Tuple{typeof(Plots.wraptuple), Plots.SeriesAnnotations})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Array{Symbol, 2}, Int64, Float64, Plots.Stroke}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Array{Symbol, 2}, Int64}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Base.LinRange{Float64}, Base.LinRange{Float64}}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Array{Symbol, 2}}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol, Plots.Stroke}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Float64, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, String}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Float64, Array{Symbol, 2}}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Int64, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Plots.Shape, Int64, ColorTypes.RGBA{Float64}}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{String, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{String, Tuple{Int64, Int64}, Base.StepRange{Int64, Int64}, Symbol}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Float64, Plots.Stroke}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Int64}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Symbol, Int64, Symbol, Float64}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{Symbol, Symbol, Symbol, Int64, Float64}})
+    precompile(Tuple{typeof(Plots.wraptuple), Tuple{}})
+    precompile(Tuple{typeof(Plots.write_temp_html), Plots.Plot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.xgrid!), Plots.Plot{Plots.GRBackend}, Symbol, Int})
+    precompile(Tuple{typeof(Plots.xgrid!), Plots.Plot{Plots.PlotlyBackend}, Symbol, Int})
+    precompile(Tuple{typeof(Plots.xlims), Int64})
+    precompile(Tuple{typeof(Plots.xlims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.xlims), Plots.Subplot{Plots.PlotlyBackend}})
+    precompile(Tuple{typeof(Plots.xy_mm_to_pcts), Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}})
+    precompile(Tuple{typeof(Plots.yaxis!), String, Symbol})
+    precompile(Tuple{typeof(Plots.ylims), Int64})
+    precompile(Tuple{typeof(Plots.ylims), Plots.Subplot{Plots.GRBackend}})
+    precompile(Tuple{typeof(Plots.ylims), Plots.Subplot{Plots.PlotlyBackend}})
 end
@@ -1,671 +0,0 @@
-
-
-# create a new "build_series_args" which converts all inputs into xs = Any[xitems], ys = Any[yitems].
-# Special handling for: no args, xmin/xmax, parametric, dataframes
-# Then once inputs have been converted, build the series args, map functions, etc.
-# This should cut down on boilerplate code and allow more focused dispatch on type
-# note: returns meta information... mainly for use with automatic labeling from DataFrames for now
-
-const FuncOrFuncs{F} = Union{F, Vector{F}, Matrix{F}}
-
-all3D(plotattributes::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image, :plots_heatmap), get(plotattributes, :seriestype, :none))
-
-# unknown
-convertToAnyVector(x, plotattributes::KW) = error("No user recipe defined for $(typeof(x))")
-
-# missing
-convertToAnyVector(v::Nothing, plotattributes::KW) = Any[nothing], nothing
-
-# fixed number of blank series
-convertToAnyVector(n::Integer, plotattributes::KW) = Any[zeros(0) for i in 1:n], nothing
-
-# numeric vector
-convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:Number} = Any[v], nothing
-convertToAnyVector(v::AVec{Union{Missing, T}}, plotattributes::KW) where {T<:Number} = Any[replace(v, missing => NaN)], nothing
-
-# string vector
-convertToAnyVector(v::AVec{T}, plotattributes::KW) where {T<:AbstractString} = Any[v], nothing
-convertToAnyVector(v::AVec{Union{Missing, T}}, plotattributes::KW) where {T<:AbstractString} = Any[replace(v, missing => "")], nothing
-
-function convertToAnyVector(v::AMat, plotattributes::KW)
-    v = handlemissings(v)
-    if all3D(plotattributes)
-        Any[Surface(v)]
-    else
-        Any[v[:,i] for i in 1:size(v,2)]
-    end, nothing
-end
-
-handlemissings(v::AMat) = v
-handlemissings(v::AMat{T}) where T <: Number = replace(v, missing => NaN)
-handlemissings(v::AMat{T}) where T <: String = replace(v, missing => "")
-
-# function
-convertToAnyVector(f::Function, plotattributes::KW) = Any[f], nothing
-
-# surface
-convertToAnyVector(s::Surface, plotattributes::KW) = Any[s], nothing
-
-# volume
-convertToAnyVector(v::Volume, plotattributes::KW) = Any[v], nothing
-
-# # vector of OHLC
-# convertToAnyVector(v::AVec{OHLC}, plotattributes::KW) = Any[v], nothing
-
-# # dates
-convertToAnyVector(dts::AVec{D}, plotattributes::KW) where {D<:Union{Date,DateTime}} = Any[dts], nothing
-
-# list of things (maybe other vectors, functions, or something else)
-function convertToAnyVector(v::AVec, plotattributes::KW)
-    if all(x -> typeof(x) <: Number, v)
-        # all real numbers wrap the whole vector as one item
-        Any[convert(Vector{Float64}, v)], nothing
-    else
-        # something else... treat each element as an item
-        vcat(Any[convertToAnyVector(vi, plotattributes)[1] for vi in v]...), nothing
-        # Any[vi for vi in v], nothing
-    end
-end
-
-convertToAnyVector(t::Tuple, plotattributes::KW) = Any[t], nothing
-
-
-function convertToAnyVector(args...)
-    error("In convertToAnyVector, could not handle the argument types: $(map(typeof, args[1:end-1]))")
-end
-
-# --------------------------------------------------------------------
-
-# TODO: can we avoid the copy here?  one error that crops up is that mapping functions over the same array
-#       result in that array being shared.  push!, etc will add too many items to that array
-
-compute_x(x::Nothing, y::Nothing, z)      = 1:size(z,1)
-compute_x(x::Nothing, y, z)            = 1:size(y,1)
-compute_x(x::Function, y, z)        = map(x, y)
-compute_x(x, y, z)                  = copy(x)
-
-# compute_y(x::Void, y::Function, z)  = error()
-compute_y(x::Nothing, y::Nothing, z)      = 1:size(z,2)
-compute_y(x, y::Function, z)        = map(y, x)
-compute_y(x, y, z)                  = copy(y)
-
-compute_z(x, y, z::Function)        = map(z, x, y)
-compute_z(x, y, z::AbstractMatrix)  = Surface(z)
-compute_z(x, y, z::Nothing)            = nothing
-compute_z(x, y, z)                  = copy(z)
-
-nobigs(v::AVec{BigFloat}) = map(Float64, v)
-nobigs(v::AVec{BigInt}) = map(Int64, v)
-nobigs(v) = v
-
-@noinline function compute_xyz(x, y, z)
-    x = compute_x(x,y,z)
-    y = compute_y(x,y,z)
-    z = compute_z(x,y,z)
-    nobigs(x), nobigs(y), nobigs(z)
-end
-
-# not allowed
-compute_xyz(x::Nothing, y::FuncOrFuncs{F}, z) where {F<:Function}       = error("If you want to plot the function `$y`, you need to define the x values!")
-compute_xyz(x::Nothing, y::Nothing, z::FuncOrFuncs{F}) where {F<:Function} = error("If you want to plot the function `$z`, you need to define x and y values!")
-compute_xyz(x::Nothing, y::Nothing, z::Nothing)        = error("x/y/z are all nothing!")
-
-# --------------------------------------------------------------------
-
-
-# we are going to build recipes to do the processing and splitting of the args
-
-# ensure we dispatch to the slicer
-struct SliceIt end
-
-# the catch-all recipes
-@recipe function f(::Type{SliceIt}, x, y, z)
-
-    # handle data with formatting attached
-    if typeof(x) <: Formatted
-        xformatter := x.formatter
-        x = x.data
-    end
-    if typeof(y) <: Formatted
-        yformatter := y.formatter
-        y = y.data
-    end
-    if typeof(z) <: Formatted
-        zformatter := z.formatter
-        z = z.data
-    end
-
-    xs, _ = convertToAnyVector(x, plotattributes)
-    ys, _ = convertToAnyVector(y, plotattributes)
-    zs, _ = convertToAnyVector(z, plotattributes)
-
-    fr = pop!(plotattributes, :fillrange, nothing)
-    fillranges, _ = if typeof(fr) <: Number
-        ([fr],nothing)
-    else
-        convertToAnyVector(fr, plotattributes)
-    end
-    mf = length(fillranges)
-
-    rib = pop!(plotattributes, :ribbon, nothing)
-    ribbons, _ = if typeof(rib) <: Number
-        ([fr],nothing)
-    else
-        convertToAnyVector(rib, plotattributes)
-    end
-    mr = length(ribbons)
-
-    # @show zs
-
-    mx = length(xs)
-    my = length(ys)
-    mz = length(zs)
-    if mx > 0 && my > 0 && mz > 0
-        for i in 1:max(mx, my, mz)
-            # add a new series
-            di = copy(plotattributes)
-            xi, yi, zi = xs[mod1(i,mx)], ys[mod1(i,my)], zs[mod1(i,mz)]
-            di[:x], di[:y], di[:z] = compute_xyz(xi, yi, zi)
-
-            # handle fillrange
-            fr = fillranges[mod1(i,mf)]
-            di[:fillrange] = isa(fr, Function) ? map(fr, di[:x]) : fr
-
-            # handle ribbons
-            rib = ribbons[mod1(i,mr)]
-            di[:ribbon] = isa(rib, Function) ? map(rib, di[:x]) : rib
-
-            push!(series_list, RecipeData(di, ()))
-        end
-    end
-    nothing  # don't add a series for the main block
-end
-
-# this is the default "type recipe"... just pass the object through
-@recipe f(::Type{T}, v::T) where {T<:Any} = v
-
-# this should catch unhandled "series recipes" and error with a nice message
-@recipe f(::Type{V}, x, y, z) where {V<:Val} = error("The backend must not support the series type $V, and there isn't a series recipe defined.")
-
-_apply_type_recipe(plotattributes, v) = RecipesBase.apply_recipe(plotattributes, typeof(v), v)[1].args[1]
-
-# Handle type recipes when the recipe is defined on the elements.
-# This sort of recipe should return a pair of functions... one to convert to number,
-# and one to format tick values.
-function _apply_type_recipe(plotattributes, v::AbstractArray)
-    isempty(v) && return Float64[]
-    args = RecipesBase.apply_recipe(plotattributes, typeof(v[1]), v[1])[1].args
-    if length(args) == 2 && typeof(args[1]) <: Function && typeof(args[2]) <: Function
-        numfunc, formatter = args
-        Formatted(map(numfunc, v), formatter)
-    else
-        v
-    end
-end
-
-# # special handling for Surface... need to properly unwrap and re-wrap
-# function _apply_type_recipe(plotattributes, v::Surface)
-#     T = eltype(v.surf)
-#     @show T
-#     if T <: Integer || T <: AbstractFloat
-#         v
-#     else
-#         ret = _apply_type_recipe(plotattributes, v.surf)
-#         if typeof(ret) <: Formatted
-#             Formatted(Surface(ret.data), ret.formatter)
-#         else
-#             v
-#         end
-#     end
-# end
-
-# don't do anything for ints or floats
-_apply_type_recipe(plotattributes, v::AbstractArray{T}) where {T<:Union{Integer,AbstractFloat}} = v
-
-# handle "type recipes" by converting inputs, and then either re-calling or slicing
-@recipe function f(x, y, z)
-    did_replace = false
-    newx = _apply_type_recipe(plotattributes, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(plotattributes, y)
-    y === newy || (did_replace = true)
-    newz = _apply_type_recipe(plotattributes, z)
-    z === newz || (did_replace = true)
-    if did_replace
-        newx, newy, newz
-    else
-        SliceIt, x, y, z
-    end
-end
-@recipe function f(x, y)
-    did_replace = false
-    newx = _apply_type_recipe(plotattributes, x)
-    x === newx || (did_replace = true)
-    newy = _apply_type_recipe(plotattributes, y)
-    y === newy || (did_replace = true)
-    if did_replace
-        newx, newy
-    else
-        SliceIt, x, y, nothing
-    end
-end
-@recipe function f(y)
-    newy = _apply_type_recipe(plotattributes, y)
-    if y !== newy
-        newy
-    else
-        SliceIt, nothing, y, nothing
-    end
-end
-
-# if there's more than 3 inputs, it can't be passed directly to SliceIt
-# so we'll apply_type_recipe to all of them
-@recipe function f(v1, v2, v3, v4, vrest...)
-    did_replace = false
-    newargs = map(v -> begin
-        newv = _apply_type_recipe(plotattributes, v)
-        if newv !== v
-            did_replace = true
-        end
-        newv
-    end, (v1, v2, v3, v4, vrest...))
-    if !did_replace
-        error("Couldn't process recipe args: $(map(typeof, (v1, v2, v3, v4, vrest...)))")
-    end
-    newargs
-end
-
-
-# # --------------------------------------------------------------------
-# # 1 argument
-# # --------------------------------------------------------------------
-
-# helper function to ensure relevant attributes are wrapped by Surface
-function wrap_surfaces(plotattributes::KW)
-    if haskey(plotattributes, :fill_z)
-        v = plotattributes[:fill_z]
-        if !isa(v, Surface)
-            plotattributes[:fill_z] = Surface(v)
-        end
-    end
-end
-
-@recipe f(n::Integer) = is3d(get(plotattributes,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
-
-# return a surface if this is a 3d plot, otherwise let it be sliced up
-@recipe function f(mat::AMat{T}) where T<:Union{Integer,AbstractFloat}
-    if all3D(plotattributes)
-        n,m = size(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        SliceIt, nothing, mat, nothing
-    end
-end
-
-# if a matrix is wrapped by Formatted, do similar logic, but wrap data with Surface
-@recipe function f(fmt::Formatted{T}) where T<:AbstractMatrix
-    if all3D(plotattributes)
-        mat = fmt.data
-        n,m = size(mat)
-        wrap_surfaces(plotattributes)
-        SliceIt, 1:m, 1:n, Formatted(Surface(mat), fmt.formatter)
-    else
-        SliceIt, nothing, fmt, nothing
-    end
-end
-
-# assume this is a Volume, so construct one
-@recipe function f(vol::AbstractArray{T,3}, args...) where T<:Number
-    seriestype := :volume
-    SliceIt, nothing, Volume(vol, args...), nothing
-end
-
-
-# # images - grays
-function clamp_greys!(mat::AMat{T}) where T<:Gray
-    for i in eachindex(mat)
-        mat[i].val < 0 && (mat[i] = Gray(0))
-        mat[i].val > 1 && (mat[i] = Gray(1))
-    end
-    mat
-end
-
-@recipe function f(mat::AMat{T}) where T<:Gray
-    n, m = size(mat)
-    if is_seriestype_supported(:image)
-        seriestype := :image
-        yflip --> true
-        SliceIt, 1:m, 1:n, Surface(clamp_greys!(mat))
-    else
-        seriestype := :heatmap
-        yflip --> true
-        cbar --> false
-        fillcolor --> ColorGradient([:black, :white])
-        SliceIt, 1:m, 1:n, Surface(clamp!(convert(Matrix{Float64}, mat), 0., 1.))
-    end
-end
-
-# # images - colors
-
-@recipe function f(mat::AMat{T}) where T<:Colorant
-	n, m = size(mat)
-
-    if is_seriestype_supported(:image)
-        seriestype := :image
-        yflip --> true
-        SliceIt, 1:m, 1:n, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        cbar --> false
-        z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat)
-        SliceIt, 1:m, 1:n, Surface(z)
-    end
-end
-
-#
-# # plotting arbitrary shapes/polygons
-
-@recipe function f(shape::Shape)
-    seriestype --> :shape
-    coords(shape)
-end
-
-@recipe function f(shapes::AVec{Shape})
-    seriestype --> :shape
-    coords(shapes)
-end
-
-@recipe function f(shapes::AMat{Shape})
-    seriestype --> :shape
-    for j in 1:size(shapes,2)
-        @series coords(vec(shapes[:,j]))
-    end
-end
-
-
-
-# function without range... use the current range of the x-axis
-
-@recipe function f(f::FuncOrFuncs{F}) where F<:Function
-    plt = plotattributes[:plot_object]
-    xmin, xmax = try
-        axis_limits(plt[1][:xaxis])
-    catch
-        xinv = invscalefunc(get(plotattributes, :xscale, :identity))
-        xm = tryrange(f, xinv.([-5,-1,0,0.01]))
-        xm, tryrange(f, filter(x->x>xm, xinv.([5,1,0.99, 0, -0.01])))
-    end
-
-    f, xmin, xmax
-end
-
-# try some intervals over which the function may be defined
-function tryrange(F::AbstractArray, vec)
-    rets = [tryrange(f, vec) for f in F] # get the preferred for each
-    maxind = maximum(indexin(rets, vec)) # get the last attempt that succeeded (most likely to fit all)
-    rets .= [tryrange(f, vec[maxind:maxind]) for f in F] # ensure that all functions compute there
-    rets[1]
-end
-
-function tryrange(F, vec)
-    for v in vec
-        try
-            tmp = F(v)
-            return v
-        catch
-        end
-    end
-    error("$F is not a Function, or is not defined at any of the values $vec")
-end
-#
-# # --------------------------------------------------------------------
-# # 2 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # if functions come first, just swap the order (not to be confused with parametric functions...
-# # as there would be more than one function passed in)
-
-@recipe function f(f::FuncOrFuncs{F}, x) where F<:Function
-    F2 = typeof(x)
-    @assert !(F2 <: Function || (F2 <: AbstractArray && F2.parameters[1] <: Function))  # otherwise we'd hit infinite recursion here
-    x, f
-end
-
-#
-# # --------------------------------------------------------------------
-# # 3 arguments
-# # --------------------------------------------------------------------
-#
-#
-# # 3d line or scatter
-
-@recipe function f(x::AVec, y::AVec, z::AVec)
-    # st = get(plotattributes, :seriestype, :none)
-    # if st == :scatter
-    #     plotattributes[:seriestype] = :scatter3d
-    # elseif !is3d(st)
-    #     plotattributes[:seriestype] = :path3d
-    # end
-    SliceIt, x, y, z
-end
-
-@recipe function f(x::AMat, y::AMat, z::AMat)
-    # st = get(plotattributes, :seriestype, :none)
-    # if size(x) == size(y) == size(z)
-    #     if !is3d(st)
-    #         seriestype := :path3d
-    #     end
-    # end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, z
-end
-
-#
-# # surface-like... function
-
-@recipe function f(x::AVec, y::AVec, zf::Function)
-    # x = X <: Number ? sort(x) : x
-    # y = Y <: Number ? sort(y) : y
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(zf, x, y)  # TODO: replace with SurfaceFunction when supported
-end
-
-#
-# # surface-like... matrix grid
-
-@recipe function f(x::AVec, y::AVec, z::AMat)
-    if !like_surface(get(plotattributes, :seriestype, :none))
-        plotattributes[:seriestype] = :contour
-    end
-    wrap_surfaces(plotattributes)
-    SliceIt, x, y, Surface(z)
-end
-
-# # images - grays
-
-@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Gray
-    if is_seriestype_supported(:image)
-        seriestype := :image
-        yflip --> true
-        SliceIt, x, y, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        cbar --> false
-        fillcolor --> ColorGradient([:black, :white])
-        SliceIt, x, y, Surface(convert(Matrix{Float64}, mat))
-    end
-end
-
-# # images - colors
-
-@recipe function f(x::AVec, y::AVec, mat::AMat{T}) where T<:Colorant
-    if is_seriestype_supported(:image)
-        seriestype := :image
-        yflip --> true
-        SliceIt, x, y, Surface(mat)
-    else
-        seriestype := :heatmap
-        yflip --> true
-        cbar --> false
-        z, plotattributes[:fillcolor] = replace_image_with_heatmap(mat)
-        SliceIt, x, y, Surface(z)
-    end
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Parametric functions
-# # --------------------------------------------------------------------
-
-#
-# # special handling... xmin/xmax with parametric function(s)
-@recipe function f(f::Function, xmin::Number, xmax::Number)
-    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
-    xs = _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
-    xs, f
-end
-@recipe function f(fs::AbstractArray{F}, xmin::Number, xmax::Number) where F<:Function
-    xscale, yscale = [get(plotattributes, sym, :identity) for sym=(:xscale,:yscale)]
-    xs = Any[_scaled_adapted_grid(f, xscale, yscale, xmin, xmax) for f in fs]
-    xs, fs
-end
-@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, u::AVec) where {F<:Function,G<:Function}  = mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u)
-@recipe f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, umin::Number, umax::Number, n = 200) where {F<:Function,G<:Function} = fx, fy, range(umin, stop = umax, length = n)
-
-function _scaled_adapted_grid(f, xscale, yscale, xmin, xmax)
-    (xf, xinv), (yf, yinv) =  ((scalefunc(s),invscalefunc(s)) for s in (xscale,yscale))
-    xinv.(adapted_grid(yf∘f∘xinv, xf.((xmin, xmax))))
-end
-
-#
-# # special handling... 3D parametric function(s)
-@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, u::AVec) where {F<:Function,G<:Function,H<:Function}
-    mapFuncOrFuncs(fx, u), mapFuncOrFuncs(fy, u), mapFuncOrFuncs(fz, u)
-end
-@recipe function f(fx::FuncOrFuncs{F}, fy::FuncOrFuncs{G}, fz::FuncOrFuncs{H}, umin::Number, umax::Number, numPoints = 200) where {F<:Function,G<:Function,H<:Function}
-    fx, fy, fz, range(umin, stop = umax, length = numPoints)
-end
-
-#
-#
-# # --------------------------------------------------------------------
-# # Lists of tuples and StaticArrays
-# # --------------------------------------------------------------------
-#
-# # if we get an unhandled tuple, just splat it in
-@recipe f(tup::Tuple) = tup
-
-#
-# # (x,y) tuples
-@recipe f(xy::AVec{Tuple{R1,R2}}) where {R1<:Number,R2<:Number} = unzip(xy)
-@recipe f(xy::Tuple{R1,R2}) where {R1<:Number,R2<:Number}       = [xy[1]], [xy[2]]
-
-#
-# # (x,y,z) tuples
-@recipe f(xyz::AVec{Tuple{R1,R2,R3}}) where {R1<:Number,R2<:Number,R3<:Number} = unzip(xyz)
-@recipe f(xyz::Tuple{R1,R2,R3}) where {R1<:Number,R2<:Number,R3<:Number}       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-# these might be points+velocity, or OHLC or something else
-@recipe f(xyuv::AVec{Tuple{R1,R2,R3,R4}}) where {R1<:Number,R2<:Number,R3<:Number,R4<:Number} = get(plotattributes,:seriestype,:path)==:ohlc ? OHLC[OHLC(t...) for t in xyuv] : unzip(xyuv)
-@recipe f(xyuv::Tuple{R1,R2,R3,R4}) where {R1<:Number,R2<:Number,R3<:Number,R4<:Number}       = [xyuv[1]], [xyuv[2]], [xyuv[3]], [xyuv[4]]
-
-
-#
-# # 2D StaticArrays
-@recipe f(xy::AVec{StaticArrays.SVector{2,T}}) where {T<:Number} = unzip(xy)
-@recipe f(xy::StaticArrays.SVector{2,T}) where {T<:Number}       = [xy[1]], [xy[2]]
-
-#
-# # 3D StaticArrays
-@recipe f(xyz::AVec{StaticArrays.SVector{3,T}}) where {T<:Number} = unzip(xyz)
-@recipe f(xyz::StaticArrays.SVector{3,T}) where {T<:Number}       = [xyz[1]], [xyz[2]], [xyz[3]]
-
-#
-# # --------------------------------------------------------------------
-# # handle grouping
-# # --------------------------------------------------------------------
-
-# @recipe function f(groupby::GroupBy, args...)
-#     for (i,glab) in enumerate(groupby.groupLabels)
-#         # create a new series, with the label of the group, and an idxfilter (to be applied in slice_and_dice)
-#         # TODO: use @series instead
-#         @show i, glab, groupby.groupIds[i]
-#         di = copy(plotattributes)
-#         get!(di, :label, string(glab))
-#         get!(di, :idxfilter, groupby.groupIds[i])
-#         push!(series_list, RecipeData(di, args))
-#     end
-#     nothing
-# end
-
-splittable_kw(key, val, lengthGroup) = false
-splittable_kw(key, val::AbstractArray, lengthGroup) = (key != :group) && size(val,1) == lengthGroup
-splittable_kw(key, val::Tuple, lengthGroup) = all(splittable_kw.(key, val, lengthGroup))
-splittable_kw(key, val::SeriesAnnotations, lengthGroup) = splittable_kw(key, val.strs, lengthGroup)
-
-split_kw(key, val::AbstractArray, indices) = val[indices, fill(Colon(), ndims(val)-1)...]
-split_kw(key, val::Tuple, indices) = Tuple(split_kw(key, v, indices) for v in val)
-function split_kw(key, val::SeriesAnnotations, indices)
-    split_strs = split_kw(key, val.strs, indices)
-    return SeriesAnnotations(split_strs, val.font, val.baseshape, val.scalefactor)
-end
-
-function groupedvec2mat(x_ind, x, y::AbstractArray, groupby, def_val = y[1])
-    y_mat = Array{promote_type(eltype(y), typeof(def_val))}(undef, length(keys(x_ind)), length(groupby.groupLabels))
-    fill!(y_mat, def_val)
-    for i in 1:length(groupby.groupLabels)
-        xi = x[groupby.groupIds[i]]
-        yi = y[groupby.groupIds[i]]
-        y_mat[getindex.(Ref(x_ind), xi), i] = yi
-    end
-    return y_mat
-end
-
-groupedvec2mat(x_ind, x, y::Tuple, groupby) = Tuple(groupedvec2mat(x_ind, x, v, groupby) for v in y)
-
-group_as_matrix(t) = false
-
-# split the group into 1 series per group, and set the label and idxfilter for each
-@recipe function f(groupby::GroupBy, args...)
-    lengthGroup = maximum(union(groupby.groupIds...))
-    if !(group_as_matrix(args[1]))
-        for (i,glab) in enumerate(groupby.groupLabels)
-            @series begin
-                label     --> string(glab)
-                idxfilter --> groupby.groupIds[i]
-                for (key,val) in plotattributes
-                    if splittable_kw(key, val, lengthGroup)
-                        :($key) := split_kw(key, val, groupby.groupIds[i])
-                    end
-                end
-                args
-            end
-        end
-    else
-        g = args[1]
-        if length(g.args) == 1
-            x = zeros(Int, lengthGroup)
-            for indexes in groupby.groupIds
-                x[indexes] = 1:length(indexes)
-            end
-            last_args = g.args
-        else
-            x = g.args[1]
-            last_args = g.args[2:end]
-        end
-        x_u = unique(sort(x))
-        x_ind = Dict(zip(x_u, 1:length(x_u)))
-        for (key,val) in plotattributes
-            if splittable_kw(key, val, lengthGroup)
-                :($key) := groupedvec2mat(x_ind, x, val, groupby)
-            end
-        end
-        label --> reshape(groupby.groupLabels, 1, :)
-        typeof(g)((x_u, (groupedvec2mat(x_ind, x, arg, groupby, NaN) for arg in last_args)...))
-    end
-end
@@ -2,10 +2,10 @@
    scatter(x,y)
    scatter!(x,y)

-Make a scatter plot of y vs x. 
+Make a scatter plot of y vs x.

 # Examples
-```julia-repl 
+```julia-repl
 julia> scatter([1,2,3],[4,5,6],markersize=[3,4,5],markercolor=[:red,:green,:blue])
 julia> scatter([(1,4),(2,5),(3,6)])
 ```
@@ -16,9 +16,9 @@ julia> scatter([(1,4),(2,5),(3,6)])
    bar(x,y)
    bar!(x,y)

-Make a bar plot of y vs x. 
+Make a bar plot of y vs x.

-# Arguments 
+# Arguments

 - $(_document_argument("bar_position"))
 - $(_document_argument("bar_width"))
@@ -26,7 +26,7 @@ Make a bar plot of y vs x.
 - $(_document_argument("orientation"))

 # Examples
-```julia-repl 
+```julia-repl
 julia> bar([1,2,3],[4,5,6],fillcolor=[:red,:green,:blue],fillalpha=[0.2,0.4,0.6])
 julia> bar([(1,4),(2,5),(3,6)])
 ```
@@ -41,7 +41,7 @@ julia> bar([(1,4),(2,5),(3,6)])

 Plot a histogram.

-# Arguments 
+# Arguments

 - `x`: AbstractVector of values to be binned
 - $(_document_argument("bins"))
@@ -53,7 +53,7 @@ Plot a histogram.
 - $(_document_argument("orientation"))

 # Example
-```julia-repl 
+```julia-repl
 julia> histogram([1,2,1,1,4,3,8],bins=0:8)
 ```
 """
@@ -63,7 +63,7 @@ julia> histogram([1,2,1,1,4,3,8],bins=0:8)
    barhist(x)
    barhist!(x)

-Make a histogram bar plot. See `histogram`. 
+Make a histogram bar plot. See `histogram`.
 """
@shorthands barhist

@@ -72,7 +72,7 @@ Make a histogram bar plot. See `histogram`.
    stephist(x)

 Make a histogram step plot (bin counts are represented using horizontal lines
-instead of bars). See `histogram`. 
+instead of bars). See `histogram`.
 """
@shorthands stephist

@@ -80,8 +80,8 @@ instead of bars). See `histogram`.
    scatterhist(x)
    scatterhist!(x)

-Make a histogram scatter plot (bin counts are represented using points 
-instead of bars). See `histogram`. 
+Make a histogram scatter plot (bin counts are represented using points
+instead of bars). See `histogram`.
 """
@shorthands scatterhist

@@ -91,14 +91,14 @@ instead of bars). See `histogram`.

 Plot a two-dimensional histogram.

-# Arguments 
+# Arguments

- `bins`: Number of bins (if an `Integer`) or bin edges (if an `AbtractVector`) 
- `weights`: Vector of weights for the values in `x`. Each entry of x contributes 
-             its weight to the height of its bin. 
+- `bins`: Number of bins (if an `Integer`) or bin edges (if an `AbtractVector`)
+- `weights`: Vector of weights for the values in `x`. Each entry of x contributes
+             its weight to the height of its bin.

 # Example
-```julia-repl 
+```julia-repl
 julia> histogram2d(randn(10_000),randn(10_000))
 ```
 """
@@ -108,14 +108,14 @@ julia> histogram2d(randn(10_000),randn(10_000))
    density(x)
    density!(x)

-Make a line plot of a kernel density estimate of x. 
+Make a line plot of a kernel density estimate of x.

 # Arguments

- `x`: AbstractVector of samples for probability density estimation 
+- `x`: AbstractVector of samples for probability density estimation

 # Example
-```julia-repl 
+```julia-repl
 julia> using StatsPlots
 julia> density(randn(100_000))
 ```
@@ -126,10 +126,10 @@ julia> density(randn(100_000))
    heatmap(x,y,z)
    heatmap!(x,y,z)

-Plot a heatmap of the rectangular array `z`. 
+Plot a heatmap of the rectangular array `z`.

 # Example
-```julia-repl 
+```julia-repl
 julia> heatmap(randn(10,10))
 ```
 """
@@ -140,7 +140,7 @@ julia> heatmap(randn(10,10))
    hexbin(x,y)
    hexbin!(x,y)

-Make a hexagonal binning plot (a histogram of the observations `(x[i],y[i])` 
+Make a hexagonal binning plot (a histogram of the observations `(x[i],y[i])`
 with hexagonal bins)

 # Example
@@ -154,11 +154,11 @@ julia> hexbin(randn(10_000), randn(10_000))
    sticks(x,y)
    sticks!(x,y)

-Draw a stick plot of y vs x. 
+Draw a stick plot of y vs x.

 # Example
 ```julia-repl
-julia> sticks(1:10) 
+julia> sticks(1:10)
 ```
 """
@shorthands sticks
@@ -167,11 +167,11 @@ julia> sticks(1:10)
    hline(y)
    hline!(y)

-Draw horizontal lines at positions specified by the values in 
+Draw horizontal lines at positions specified by the values in
 the AbstractVector `y`

 # Example
-```julia-repl 
+```julia-repl
 julia> hline([-1,0,2])
 ```
 """
@@ -181,11 +181,11 @@ julia> hline([-1,0,2])
    vline(x)
    vline!(x)

-Draw vertical lines at positions specified by the values in 
+Draw vertical lines at positions specified by the values in
 the AbstractVector `x`

 # Example
-```julia-repl 
+```julia-repl
 julia> vline([-1,0,2])
 ```
 """
@@ -194,13 +194,13 @@ julia> vline([-1,0,2])
 """
    hspan(y)

-Draw a rectangle between the horizontal line at position `y[1]` 
-and the horizontal line at position `y[2]`. If `length(y) ≥ 4`, 
-then further rectangles are drawn between `y[3]` and `y[4]`, 
-`y[5]` and `y[6]`, and so on. If `length(y)` is odd, then the 
-last entry of `y` is ignored. 
+Draw a rectangle between the horizontal line at position `y[1]`
+and the horizontal line at position `y[2]`. If `length(y) ≥ 4`,
+then further rectangles are drawn between `y[3]` and `y[4]`,
+`y[5]` and `y[6]`, and so on. If `length(y)` is odd, then the
+last entry of `y` is ignored.
 # Example
-```julia-repl 
+```julia-repl
 julia> hspan(1:6)
 ```
 """
@@ -209,13 +209,13 @@ julia> hspan(1:6)
 """
    vspan(x)

-Draw a rectangle between the vertical line at position `x[1]` 
-and the vertical line at position `x[2]`. If `length(x) ≥ 4`, 
-then further rectangles are drawn between `x[3]` and `x[4]`, 
-`x[5]` and `x[6]`, and so on. If `length(x)` is odd, then the 
-last entry of `x` is ignored. 
+Draw a rectangle between the vertical line at position `x[1]`
+and the vertical line at position `x[2]`. If `length(x) ≥ 4`,
+then further rectangles are drawn between `x[3]` and `x[4]`,
+`x[5]` and `x[6]`, and so on. If `length(x)` is odd, then the
+last entry of `x` is ignored.
 # Example
-```julia-repl 
+```julia-repl
 julia> vspan(1:6)
 ```
 """
@@ -225,9 +225,9 @@ julia> vspan(1:6)
    ohlc(x,y::Vector{OHLC})
    ohlc!(x,y::Vector{OHLC})

-Make open-high-low-close plot. Each entry of y is represented by a vertical 
-segment extending from the low value to the high value, with short horizontal 
-segments on the left and right indicating the open and close values, respectively. 
+Make open-high-low-close plot. Each entry of y is represented by a vertical
+segment extending from the low value to the high value, with short horizontal
+segments on the left and right indicating the open and close values, respectively.

 # Example
 ```julia-repl
@@ -240,18 +240,18 @@ julia> ohlc(y)


 """
-    contour(x,y,z) 
-    contour!(x,y,z) 
+    contour(x,y,z)
+    contour!(x,y,z)

-Draw contour lines of the `Surface` z. 
+Draw contour lines of the `Surface` z.

 # Arguments
 - `levels`: Contour levels (if `AbstractVector`) or number of levels (if `Integer`)
 - `fill`: Bool. Fill area between contours or draw contours only (false by default)

-# Example 
+# Example
 ```julia-repl
-julia> x = y = range(-20, 20, length = 100)
+julia> x = y = range(-20, stop = 20, length = 100)
 julia> contour(x, y, (x, y) -> x^2 + y^2)
 ```
 """
@@ -267,11 +267,12 @@ julia> contour(x, y, (x, y) -> x^2 + y^2)
    surface(x,y,z)
    surface!(x,y,z)

-Draw a 3D surface plot. 
+Draw a 3D surface plot.

 # Example
-```julia-repl 
-julia> x = y = range(-3, 3, length = 100)
+```julia-repl
+julia> using LinearAlgebra
+julia> x = y = range(-3, stop = 3, length = 100)
 julia> surface(x, y, (x, y) -> sinc(norm([x, y])))
 ```
 """
@@ -281,10 +282,10 @@ julia> surface(x, y, (x, y) -> sinc(norm([x, y])))
    wireframe(x,y,z)
    wireframe!(x,y,z)

-Draw a 3D wireframe plot. 
+Draw a 3D wireframe plot.

 # Example
-```julia-repl 
+```julia-repl
 julia> wireframe(1:10,1:10,randn(10,10))
 ```
 """
@@ -295,10 +296,10 @@ julia> wireframe(1:10,1:10,randn(10,10))
    path3d!(x,y,z)

 Plot a 3D path from `(x[1],y[1],z[1])` to `(x[2],y[2],z[2])`,
-..., to `(x[end],y[end],z[end])`. 
+..., to `(x[end],y[end],z[end])`.

 # Example
-```julia-repl 
+```julia-repl
 julia> path3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
 ```
 """
@@ -308,10 +309,10 @@ julia> path3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
    scatter3d(x,y,z)
    scatter3d!(x,y,z)

-Make a 3D scatter plot. 
+Make a 3D scatter plot.

 # Example
-```julia-repl 
+```julia-repl
 julia> scatter3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
 ```
 """
@@ -321,17 +322,17 @@ julia> scatter3d([0,1,2,3],[0,1,4,9],[0,1,8,27])
    boxplot(x, y)
    boxplot!(x, y)

-Make a box and whisker plot. 
+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) 
- `outliers`: Bool. Show outliers? (true) 
- `whisker_width`: Real or Symbol. Length of whiskers (:match) 
+           or above the third quartile are shown as outliers (1.5)
+- `outliers`: Bool. Show outliers? (true)
+- `whisker_width`: Real or Symbol. Length of whiskers (:match)

 # Example
-```julia-repl 
+```julia-repl
 julia> using StatsPlots
 julia> boxplot(repeat([1,2,3],outer=100),randn(300))
 ```
@@ -342,10 +343,10 @@ julia> boxplot(repeat([1,2,3],outer=100),randn(300))
    violin(x,y,z)
    violin!(x,y,z)

-Make a violin plot. 
+Make a violin plot.

 # Example
-```julia-repl 
+```julia-repl
 julia> violin(repeat([1,2,3],outer=100),randn(300))
 ```
 """
@@ -355,11 +356,11 @@ julia> violin(repeat([1,2,3],outer=100),randn(300))
    quiver(x,y,quiver=(u,v))
    quiver!(x,y,quiver=(u,v))

-Make a quiver (vector field) plot. The `i`th vector extends 
-from `(x[i],y[i])` to `(x[i] + u[i], y[i] + v[i])`. 
+Make a quiver (vector field) plot. The `i`th vector extends
+from `(x[i],y[i])` to `(x[i] + u[i], y[i] + v[i])`.

 # Example
-```julia-repl 
+```julia-repl
 julia> quiver([1,2,3],[3,2,1],quiver=([1,1,1],[1,2,3]))
 ```
 """
@@ -369,19 +370,18 @@ julia> quiver([1,2,3],[3,2,1],quiver=([1,1,1],[1,2,3]))
    curves(x,y)
    curves!(x,y)

-Draw a Bezier curve from `(x[1],y[1])` to `(x[end],y[end])` 
+Draw a Bezier curve from `(x[1],y[1])` to `(x[end],y[end])`
 with control points `(x[2],y[2]), ..., (x[end-1],y[end]-1)`

 # Example
-```julia-repl 
+```julia-repl
 julia> curves([1,2,3,4],[1,1,2,4])
 ```
 """
@shorthands curves

 "Plot a pie diagram"
-pie(args...; kw...)        = plot(args...; kw...,  seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
-pie!(args...; kw...)       = plot!(args...; kw..., seriestype = :pie, aspect_ratio = :equal, grid=false, xticks=nothing, yticks=nothing)
+@shorthands pie

 "Plot with seriestype :path3d"
 plot3d(args...; kw...)     = plot(args...; kw...,  seriestype = :path3d)
@@ -424,12 +424,12 @@ ticks::AVec{T}, labels::AVec{S}; kw...) where {T<:Real,S<:AbstractString}     =
 """
    annotate!(anns...)

-Add annotations to an existing plot. 
+Add annotations to an existing plot.

-# Arguments 
+# Arguments

- `anns`: An `AbstractVector` of tuples of the form (x,y,text). The text object
-          can be an String or PlotText
+- `anns`: An `AbstractVector` of tuples of the form `(x,y,text)`. The `text` object
+          can be a `String` or `PlotText`.

 # Example
 ```julia-repl
@@ -437,8 +437,9 @@ julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
 ```
 """
-annotate!(anns...; kw...)                                        = plot!(; annotation = anns, kw...)
-annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)
+annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)
+annotate!(anns::Tuple...; kw...)      = plot!(; annotation = collect(anns), kw...)
+annotate!(anns::AVec{<:Tuple}; kw...) = plot!(; annotation = anns, kw...)

 "Flip the current plots' x axis"
 xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)
@@ -449,7 +450,7 @@ yflip!(flip::Bool = true; kw...)                          = plot!(; yflip = flip
 "Specify x axis attributes for an existing plot"
 xaxis!(args...; kw...)                                    = plot!(; xaxis = args, kw...)

-"Specify x axis attributes for an existing plot"
+"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...)
@@ -7,7 +7,7 @@ function Subplot(::T; parent = RootLayout()) where T<:AbstractBackend
        (20mm, 5mm, 2mm, 10mm),
        defaultbox,
        defaultbox,
-        KW(),
+        DefaultsDict(KW(), _subplot_defaults),
        nothing,
        nothing
    )
@@ -42,12 +42,24 @@ get_subplot_index(plt::Plot, sp::Subplot) = findfirst(x -> x === sp, plt.subplot
 series_list(sp::Subplot) = sp.series_list # filter(series -> series.plotattributes[:subplot] === sp, sp.plt.series_list)

 function should_add_to_legend(series::Series)
-    series.plotattributes[:primary] && series.plotattributes[:label] != "" &&
-        !(series.plotattributes[:seriestype] in (
-            :hexbin,:bins2d,:histogram2d,:hline,:vline,
-            :contour,:contourf,:contour3d,:surface,:wireframe,
-            :heatmap, :pie, :image
-        ))
+    series.plotattributes[:primary] &&
+    series.plotattributes[:label] != "" &&
+    !(
+        series.plotattributes[:seriestype] in (
+            :hexbin,
+            :bins2d,
+            :histogram2d,
+            :hline,
+            :vline,
+            :contour,
+            :contourf,
+            :contour3d,
+            :surface,
+            :wireframe,
+            :heatmap,
+            :image,
+        )
+    )
 end

 # ----------------------------------------------------------------------
@@ -4,55 +4,25 @@
 Specify the colour theme for plots.
 """
 function theme(s::Symbol; kw...)
-    defaults = _get_defaults(s)
+    defaults = copy(PlotThemes._themes[s].defaults)
    _theme(s, defaults; kw...)
 end

-function _get_defaults(s::Symbol)
-    thm = PlotThemes._themes[s]
-    if :defaults in fieldnames(typeof(thm))
-        return thm.defaults
-    else # old PlotTheme type
-        defaults = KW(
-            :bg       => thm.bg_secondary,
-            :bginside => thm.bg_primary,
-            :fg       => thm.lines,
-            :fgtext   => thm.text,
-            :fgguide  => thm.text,
-            :fglegend => thm.text,
-            :palette  => thm.palette,
-        )
-        if thm.gradient != nothing
-            push!(defaults, :gradient => thm.gradient)
-        end
-        return defaults
-    end
-end
-
-function _theme(s::Symbol, defaults::KW; kw...)
+function _theme(s::Symbol, defaults::AKW; kw...)
    # Reset to defaults to overwrite active theme
    reset_defaults()

    # Set the theme's gradient as default
-    if haskey(defaults, :gradient)
-        PlotUtils.clibrary(:misc)
-        PlotUtils.default_cgrad(default = :sequential, sequential = PlotThemes.gradient_name(s))
+    if haskey(defaults, :colorgradient)
+        PlotUtils.default_cgrad(pop!(defaults, :colorgradient))
    else
-        PlotUtils.clibrary(:Plots)
-        PlotUtils.default_cgrad(default = :sequential, sequential = :inferno)
+        PlotUtils.default_cgrad(:default)
    end

    # maybe overwrite the theme's gradient
    kw = KW(kw)
-    if haskey(kw, :gradient)
-        kwgrad = pop!(kw, :gradient)
-        for clib in clibraries()
-            if kwgrad in cgradients(clib)
-                PlotUtils.clibrary(clib)
-                PlotUtils.default_cgrad(default = :sequential, sequential = kwgrad)
-                break
-            end
-        end
+    if haskey(kw, :colorgradient)
+        PlotUtils.default_cgrad(pop!(kw, :colorgradient))
    end

    # Set the theme's defaults
@@ -74,19 +44,19 @@ _get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func

@recipe function showtheme(st::ShowTheme)
    thm, cfunc = _get_showtheme_args(st.args...)
-    defaults = _get_defaults(thm)
+    defaults = PlotThemes._themes[thm].defaults

    # get the gradient
-    gradient_colors = get(defaults, :gradient, cgrad(:inferno).colors)
-    gradient = cgrad(cfunc.(RGB.(gradient_colors)))
+    gradient_colors = color_list(cgrad(get(defaults, :colorgradient, :default)))
+    colorgradient = cgrad(cfunc.(RGB.(gradient_colors)))

    # get the palette
-    palette = get(defaults, :palette, get_color_palette(:auto, plot_color(:white), 17))
-    palette = cfunc.(RGB.(palette))
+    cp = color_list(palette(get(defaults, :palette, :default)))
+    cp = cfunc.(RGB.(cp))

    # apply the theme
    for k in keys(defaults)
-        k in (:gradient, :palette) && continue
+        k in (:colorgradient, :palette) && continue
        def = defaults[k]
        arg = get(_keyAliases, k, k)
        plotattributes[arg] = if typeof(def) <: Colorant
@@ -109,7 +79,7 @@ _get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func
    for j in 1:4
        @series begin
            subplot := 1
-            palette := palette
+            color_palette := cp
            seriestype := :path
            cumsum(randn(50))
        end
@@ -117,7 +87,7 @@ _get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func
        @series begin
            subplot := 2
            seriestype := :scatter
-            palette := palette
+            color_palette := cp
            marker := (:circle, :diamond, :star5, :square)[j]
            randn(10), randn(10)
        end
@@ -126,7 +96,7 @@ _get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func
    @series begin
        subplot := 3
        seriestype := :histogram
-        palette := palette
+        color_palette := cp
        randn(1000) .+ (0:2:4)'
    end

@@ -139,27 +109,30 @@ _get_showtheme_args(thm::Symbol, func::Symbol) = thm, get(_color_functions, func
    @series begin
        subplot := 4
        seriestype := :heatmap
-        seriescolor := gradient
-        ticks := -5:5:5
+        seriescolor := colorgradient
+        xticks := (-2π:2π:2π, string.(-2:2:2, "π"))
+        yticks := (-2π:2π:2π, string.(-2:2:2, "π"))
        x, y, z
    end

    @series begin
        subplot := 5
        seriestype := :surface
-        seriescolor := gradient
+        seriescolor := colorgradient
+        xticks := (-2π:2π:2π, string.(-2:2:2, "π"))
+        yticks := (-2π:2π:2π, string.(-2:2:2, "π"))
        x, y, z
    end

    n = 100
    ts = range(0, stop = 10π, length = n)
-    x = ts .* cos.(ts)
+    x = (0.1ts) .* cos.(ts)
    y = (0.1ts) .* sin.(ts)
    z = 1:n

    @series begin
        subplot := 6
-        seriescolor := gradient
+        seriescolor := colorgradient
        linewidth := 3
        line_z := z
        x, y, z
@@ -5,6 +5,7 @@
 const AVec = AbstractVector
 const AMat = AbstractMatrix
 const KW = Dict{Symbol,Any}
+const AKW = AbstractDict{Symbol,Any}
 const TicksArgs = Union{AVec{T}, Tuple{AVec{T}, AVec{S}}, Symbol} where {T<:Real, S<:AbstractString}

 struct PlotsDisplay <: AbstractDisplay end
@@ -17,11 +18,10 @@ end
 wrap(obj::T) where {T} = InputWrapper{T}(obj)
 Base.isempty(wrapper::InputWrapper) = false

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

 mutable struct Series
-    plotattributes::KW
+    plotattributes::DefaultsDict
 end

 attr(series::Series, k::Symbol) = series.plotattributes[k]
@@ -36,7 +36,7 @@ mutable struct Subplot{T<:AbstractBackend} <: AbstractLayout
    minpad::Tuple # leftpad, toppad, rightpad, bottompad
    bbox::BoundingBox  # the canvas area which is available to this subplot
    plotarea::BoundingBox  # the part where the data goes
-    attr::KW  # args specific to this subplot
+    attr::DefaultsDict  # args specific to this subplot
    o  # can store backend-specific data... like a pyplot ax
    plt  # the enclosing Plot object (can't give it a type because of no forward declarations)
 end
@@ -48,7 +48,7 @@ Base.show(io::IO, sp::Subplot) = print(io, "Subplot{$(sp[:subplot_index])}")
 # simple wrapper around a KW so we can hold all attributes pertaining to the axis in one place
 mutable struct Axis
    sps::Vector{Subplot}
-    plotattributes::KW
+    plotattributes::DefaultsDict
 end

 mutable struct Extrema
@@ -67,8 +67,7 @@ const SubplotMap = Dict{Any, Subplot}
 mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T}
    backend::T                   # the backend type
    n::Int                       # number of series
-    attr::KW                     # arguments for the whole plot
-    user_attr::KW                # raw arg inputs (after aliases).  these are used as the input dict in `_plot!`
+    attr::DefaultsDict            # arguments for the whole plot
    series_list::Vector{Series}  # arguments for each series
    o                            # the backend's plot object
    subplots::Vector{Subplot}
@@ -79,7 +78,7 @@ mutable struct Plot{T<:AbstractBackend} <: AbstractPlot{T}
 end

 function Plot()
-    Plot(backend(), 0, KW(), KW(), Series[], nothing,
+    Plot(backend(), 0, DefaultsDict(KW(), _plot_defaults), Series[], nothing,
         Subplot[], SubplotMap(), EmptyLayout(),
         Subplot[], false)
 end
@@ -0,0 +1 @@
+reference_images
@@ -1,10 +0,0 @@
-StatsPlots
-Images
-ImageMagick
-@osx QuartzImageIO
-FileIO
-GR 0.31.0
-RDatasets
-VisualRegressionTests
-UnicodePlots
-LaTeXStrings
@@ -1,46 +0,0 @@
-using Pkg
-
-# need this to use Conda
-# ENV["PYTHON"] = ""
-
-to_add = [
-    # PackageSpec(url="https://github.com/JuliaStats/KernelDensity.jl.git"),
-    PackageSpec(name="PlotUtils", rev="master"),
-    PackageSpec(name="RecipesBase", rev="master"),
-    # PackageSpec(name="Blink", rev="master"),
-    # PackageSpec(name="Rsvg", rev="master"),
-    # PackageSpec(name="PlotlyJS", rev="master"),
-    # PackageSpec(name="VisualRegressionTests", rev="master"),
-    # PackageSpec("PyPlot"),
-    # PackageSpec("InspectDR"),
-]
-
-if isinteractive()
-    Pkg.develop(PackageSpec(url="https://github.com/JuliaPlots/PlotReferenceImages.jl.git"))
-    append!(to_add, [
-        PackageSpec(name="FileIO"),
-        PackageSpec(name="ImageMagick"),
-        PackageSpec(name="UnicodePlots"),
-        PackageSpec(name="VisualRegressionTests"),
-        PackageSpec(name="Gtk"),
-        # PlotlyJS:
-        # PackageSpec(name="PlotlyJS"),
-        # PackageSpec(name="Blink"),
-        # PackageSpec(name="ORCA"),
-        # PyPlot:
-        # PackageSpec(name="PyPlot"),
-        # PackageSpec(name="PyCall"),
-        # PackageSpec(name="LaTeXStrings"),
-    ])
-else
-    push!(to_add, PackageSpec(url="https://github.com/JuliaPlots/PlotReferenceImages.jl.git"))
-end
-
-Pkg.add(to_add)
-
-Pkg.build("ImageMagick")
-# Pkg.build("GR")
-# Pkg.build("Blink")
-# import Blink
-# Blink.AtomShell.install()
-# Pkg.build("PyPlot")
@@ -1,92 +1,43 @@
-
-using VisualRegressionTests
-# using ExamplePlots
-
-if isinteractive()
-    @eval Main import Gtk
-end
-
-# import DataFrames, RDatasets
-
-# don't let pyplot use a gui... it'll crash
-# note: Agg will set gui -> :none in PyPlot
-# ENV["MPLBACKEND"] = "Agg"
-# try
-#   @eval import PyPlot
-#   @info("Matplotlib version: $(PyPlot.matplotlib[:__version__])")
-# end
-
-
-using Plots
-# using StatsPlots
-import PlotReferenceImages
-using Random
-using Test
-
-default(size=(500,300))
-
-
-# TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
-#       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
-
 import Plots._current_plots_version

+# replace `f(args...)` with `f(rng, args...)` for `f ∈ (rand, randn)`
+function replace_rand!(ex) end
+function replace_rand!(ex::Expr)
+   for arg in ex.args
+       replace_rand!(arg)
+   end
+   if ex.head === :call && ex.args[1] ∈ (:rand, :randn)
+       pushfirst!(ex.args, ex.args[1])
+       ex.args[2] = :rng
+   end
+end
+function fix_rand!(ex)
+    replace_rand!(ex)
+    pushfirst!(ex.args[1].args, :(rng = StableRNG(1234)))
+end

-function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], tol = 1e-2)
+function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = !is_ci(), sigma = [1,1], tol = 1e-2)
    Plots._debugMode.on = debug
    example = Plots._examples[idx]
+    Plots.theme(:default)
    @info("Testing plot: $pkg:$idx:$(example.header)")
    backend(pkg)
    backend()
+    default(size=(500,300))

-    # ensure consistent results
-    Random.seed!(1234)
-
-    # reference image directory setup
-    # refdir = joinpath(Pkg.dir("ExamplePlots"), "test", "refimg", string(pkg))
-    refdir = joinpath(dirname(pathof(PlotReferenceImages)), "..", "Plots", string(pkg))
    fn = "ref$idx.png"
-
-    # firgure out version info
-    vns = filter(x->x[1] != '.', readdir(refdir))
-    versions = sort(VersionNumber.(vns), rev = true)
-    versions = filter(v -> v <= _current_plots_version, versions)
-    # @show refdir fn versions
-
-    newdir = joinpath(refdir, string(_current_plots_version))
-    newfn = joinpath(newdir, fn)
-
-    # figure out which reference file we should compare to, by finding the highest versioned file
-    reffn = nothing
-    for v in versions
-        tmpfn = joinpath(refdir, string(v), fn)
-        if isfile(tmpfn)
-            reffn = tmpfn
-            break
-        end
-    end
-
-    # now we have the fn (if any)... do the comparison
-    # @show reffn
-    if reffn == nothing
-        reffn = newfn
-    end
-    # @show reffn
-    # return
+    reffn = reference_file(pkg, idx, _current_plots_version)
+    newfn = joinpath(reference_path(pkg, _current_plots_version), fn)

    # test function
    func = (fn, idx) -> begin
-        map(eval, example.exprs)
+        expr = Expr(:block)
+        append!(expr.args, example.exprs)
+        fix_rand!(expr)
+        eval(expr)
        png(fn)
    end

-    # try
-    #     run(`mkdir -p $newdir`)
-    # catch err
-    #     display(err)
-    # end
-    # # reffn = joinpath(refdir, "ref$idx.png")
-
    # the test
    vtest = VisualTest(func, reffn, idx)
    test_images(vtest, popup=popup, sigma=sigma, tol=tol, newfn = newfn)
@@ -100,7 +51,7 @@ function image_comparison_facts(pkg::Symbol;
                                tol = 1e-2)     # acceptable error (percent)
  for i in 1:length(Plots._examples)
    i in skip && continue
-    if only == nothing || i in only
+    if only === nothing || i in only
      @test image_comparison_tests(pkg, i, debug=debug, sigma=sigma, tol=tol) |> success == true
    end
  end
@@ -1,102 +1,121 @@
-module PlotsTests
+import ImageMagick
+using VisualRegressionTests
+using Plots
+using Random
+using StableRNGs
+using Test
+using FileIO
+using Gtk
+using LibGit2
+import GeometryTypes, GeometryBasics
+using Dates
+
+include("test_axes.jl")
+include("test_hdf5plots.jl")
+include("test_pgfplotsx.jl")
+
+reference_dir(args...) = joinpath(homedir(), ".julia", "dev", "PlotReferenceImages", args...)
+
+function reference_file(backend, i, version)
+    refdir = reference_dir("Plots", string(backend))
+    fn = "ref$i.png"
+    versions = sort(VersionNumber.(readdir(refdir)), rev = true)
+
+    reffn = joinpath(refdir, string(version), fn)
+    for v in versions
+        tmpfn = joinpath(refdir, string(v), fn)
+        if isfile(tmpfn)
+            reffn = tmpfn
+            break
+        end
+    end
+
+    return reffn
+end
+
+reference_path(backend, version) = reference_dir("Plots", string(backend), string(version))
+
+if !isdir(reference_dir())
+    mkpath(reference_dir())
+    LibGit2.clone("https://github.com/JuliaPlots/PlotReferenceImages.jl.git", reference_dir())
+end

-include("add_packages.jl")
 include("imgcomp.jl")
-
 # don't actually show the plots
 Random.seed!(1234)
 default(show=false, reuse=true)
-img_tol = isinteractive() ? 1e-2 : 10e-2
+is_ci() = get(ENV, "CI", "false") == "true"
+img_tol = is_ci() ? 1e-2 : Sys.islinux() ? 1e-3 : 0.1

-@testset "GR" begin
-    ENV["PLOTS_TEST"] = "true"
-    ENV["GKSwstype"] = "100"
-    @test gr() == Plots.GRBackend()
-    @test backend() == Plots.GRBackend()
+## Uncomment the following lines to update reference images for different backends

-    @static if Sys.islinux()
-        image_comparison_facts(:gr, tol=img_tol, skip = [25, 30])
-    end
-end
-
-# @static if isinteractive()
-#     @testset "PyPlot" begin
-#         @test pyplot() == Plots.PyPlotBackend()
-#         @test backend() == Plots.PyPlotBackend()
-#
-#         image_comparison_facts(:pyplot, tol=img_tol, skip = [2, 25, 30, 31])
-#     end
+# @testset "GR" begin
+#     image_comparison_facts(:gr, tol=img_tol, skip = Plots._backend_skips[:gr])
 # end
-
-@testset "UnicodePlots" begin
-    @test unicodeplots() == Plots.UnicodePlotsBackend()
-    @test backend() == Plots.UnicodePlotsBackend()
-
-    # lets just make sure it runs without error
-    @test isa(plot(rand(10)), Plots.Plot) == true
-end
-
-# The plotlyjs testimages return a connection error on travis:
-# connect: connection refused (ECONNREFUSED)
-
-# @static if isinteractive()
-#     @testset "PlotlyJS" begin
-#         @test plotlyjs() == Plots.PlotlyJSBackend()
-#         @test backend() == Plots.PlotlyJSBackend()
 #
-#         image_comparison_facts(:plotlyjs,
-#             skip=[
-#                 2,  # animation (skipped for speed)
-#                 25,
-#                 27, # (polar plots) takes very long / not working
-#                 30,
-#                 31, # animation (skipped for speed)
-#             ],
-#             tol=img_tol)
-#     end
-# end
-
-# InspectDR returns that error on travis:
-# ERROR: LoadError: InitError: Cannot open display:
-#  in Gtk.GLib.GError(::Gtk.##229#230) at /home/travis/.julia/v0.5/Gtk/src/GLib/gerror.jl:17
-
-# @testset "InspectDR" begin
-#     @test inspectdr() == Plots.InspectDRBackend()
-#     @test backend() == Plots.InspectDRBackend()
-#
-#     image_comparison_facts(:inspectdr,
-#         skip=[
-#             2,  # animation
-#             6,  # heatmap not defined
-#             10, # heatmap not defined
-#             22, # contour not defined
-#             23, # pie not defined
-#             27, # polar plot not working
-#             28, # heatmap not defined
-#             31, # animation
-#         ],
-#         tol=img_tol)
-# end
-
-
+# plotly()
 # @testset "Plotly" begin
-#     @test plotly() == Plots.PlotlyBackend()
-#     @test backend() == Plots.PlotlyBackend()
+#     image_comparison_facts(:plotly, tol=img_tol, skip = Plots._backend_skips[:plotlyjs])
+# end
 #
-#     # # until png generation is reliable on OSX, just test on linux
-#     # @static Sys.islinux() && image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], tol=img_tol)
+# pyplot()
+# @testset "PyPlot" begin
+#     image_comparison_facts(:pyplot, tol=img_tol, skip = Plots._backend_skips[:pyplot])
+# end
+#
+# pgfplotsx()
+# @testset "PGFPlotsX" begin
+#     image_comparison_facts(:pgfplotsx, tol=img_tol, skip = Plots._backend_skips[:pgfplotsx])
 # end

-# @testset "PlotlyJS" begin
-#     @test plotlyjs() == Plots.PlotlyJSBackend()
-#     @test backend() == Plots.PlotlyJSBackend()
-#
-#     # as long as we can plot anything without error, it should be the same as Plotly
-#     image_comparison_facts(:plotlyjs, only=[1], tol=img_tol)
-# end
+# 10 Histogram2D

+##

+@testset "Backends" begin

+    @testset "GR" begin
+        ENV["PLOTS_TEST"] = "true"
+        ENV["GKSwstype"] = "100"
+        @test gr() == Plots.GRBackend()
+        @test backend() == Plots.GRBackend()
+
+        @static if haskey(ENV, "APPVEYOR")
+            @info "Skipping GR image comparison tests on AppVeyor"
+        else
+            image_comparison_facts(:gr, tol=img_tol, skip = Plots._backend_skips[:gr])
+        end
+    end
+
+    @testset "UnicodePlots" begin
+        @test unicodeplots() == Plots.UnicodePlotsBackend()
+        @test backend() == Plots.UnicodePlotsBackend()
+
+        # lets just make sure it runs without error
+        p = plot(rand(10))
+        @test isa(p, Plots.Plot) == true
+        @test isa(display(p), Nothing) == true
+        p = bar(randn(10))
+        @test isa(p, Plots.Plot) == true
+        @test isa(display(p), Nothing) == true
+        p = plot([1, 2], [3, 4])
+        annotate!(p, [(1.5, 3.2, Plots.text("Test", :red, :center))])
+        hline!(p, [3.1])
+        @test isa(p, Plots.Plot) == true
+        @test isa(display(p), Nothing) == true
+        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 isa(p, Plots.Plot) == true
+        @test isa(display(p), Nothing) == true
+        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
+        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
+        hline!(p, [3.1])
+        @test isa(p, Plots.Plot) == true
+        @test isa(display(p), Nothing) == true
+    end
+
+end

@testset "Axes" begin
    p = plot()
@@ -113,46 +132,58 @@ end
 end

@testset "NoFail" begin
-    histogram([1, 0, 0, 0, 0, 0])
+    plots = [histogram([1, 0, 0, 0, 0, 0]),
+             plot([missing]),
+             plot([missing; 1:4]),
+             plot([fill(missing,10); 1:4]),
+             plot([1 1; 1 missing]),
+             plot(["a" "b"; missing "d"], [1 2; 3 4])]
+    for plt in plots
+        display(plt)
+    end
+    @test_nowarn plot(x->x^2,0,2)
 end

-# tests for preprocessing recipes
+@testset "EmptyAnim" begin
+    anim = @animate for i in []
+    end

-# @testset "recipes" begin
+    @test_throws ArgumentError gif(anim)
+end

-    # user recipe
+@testset "Segments" begin
+    function segments(args...)
+        segs = UnitRange{Int}[]
+        for seg in iter_segments(args...)
+            push!(segs,seg)
+        end
+        segs
+    end

-    # type T end
-    # @recipe function f(::T)
-    #     line := (3,0.3,:red)
-    #     marker := (20,0.5,:blue,:o)
-    #     bg := :yellow
-    #     rand(10)
-    # end
-    # plot(T())
+    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

-    # plot recipe
-
-    # @recipe function f(::Type{Val{:hiplt}},plt::Plot)
-    #     line := (3,0.3,:red)
-    #     marker := (20,0.5,:blue,:o)
-    #     t := :path
-    #     bg:=:green
-    #     ()
-    # end
-    # plot(rand(10),t=:hiplt)
-
-    # series recipe
-
-    # @recipe function f(::Type{Val{:hi}},x,y,z)
-    #     line := (3,0.3,:red)
-    #     marker := (20,0.5,:blue,:o)
-    #     t := :path
-    #     ()
-    # end
-    # plot(rand(10),t=:hiplt)
-
-# end
-
-
-end # module
+@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(GeometryTypes.Point.(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)
+end
@@ -1,36 +0,0 @@
-import SnoopCompile
-
-### Log the compiles
-# This only needs to be run once (to generate "/tmp/plots_compiles.csv")
-
-# SnoopCompile.@snoop "/tmp/plots_compiles.csv" begin
-#     include(joinpath(dirname(@__FILE__), "runtests.jl"))
-# end
-
-# ----------------------------------------------------------
-
-### Parse the compiles and generate precompilation scripts
-# This can be run repeatedly to tweak the scripts
-
-# IMPORTANT: we must have the module(s) defined for the parcelation
-# step, otherwise we will get no precompiles for the Plots module
-using Plots
-
-data = SnoopCompile.read("/tmp/plots_compiles.csv")
-
-# The Plots tests are run inside a module PlotsTest, so all
-# the precompiles get credited to PlotsTest. Credit them to Plots instead.
-subst = Dict("PlotsTests"=>"Plots")
-
-# Blacklist helps fix problems:
-# - MIME uses type-parameters with symbols like :image/png, which is
-#   not parseable
-blacklist = ["MIME"]
-
-# Use these two lines if you want to create precompile functions for
-# individual packages
-pc, discards = SnoopCompile.parcel(data[end:-1:1,2], subst=subst, blacklist=blacklist)
-SnoopCompile.write("/tmp/precompile", pc)
-
-pdir = joinpath(dirname(@__FILE__), "..")
-run(`cp /tmp/precompile/precompile_Plots.jl $pdir/src/precompile.jl`)
@@ -0,0 +1,14 @@
+using Plots, Test
+
+@testset "Showaxis" begin
+    for value in Plots._allShowaxisArgs
+        @test plot(1:5, showaxis = value)[1][:yaxis][:showaxis] isa Bool
+    end
+    @test plot(1:5, showaxis = :y)[1][:yaxis][:showaxis] == true
+    @test plot(1:5, showaxis = :y)[1][:xaxis][:showaxis] == false
+end
+
+@testset "Magic axis" begin
+    @test plot(1, axis=nothing)[1][:xaxis][:ticks] == []
+    @test plot(1, axis=nothing)[1][:yaxis][:ticks] == []
+end # testset
@@ -0,0 +1,21 @@
+using Plots, HDF5
+
+
+@testset "HDF5_Plots" begin
+	fname = "tmpplotsave.hdf5"
+	hdf5()
+
+	x = 1:10
+	psrc=plot(x, x.*x); #Create some plot
+	Plots.hdf5plot_write(psrc, fname)
+
+	#Read back file:
+	gr() #Choose some fast backend likely to work in test environment.
+	pread = Plots.hdf5plot_read(fname)
+
+	#Make sure data made it through:
+	@test psrc.subplots[1].series_list[1][:x] == pread.subplots[1].series_list[1][:x]
+	@test psrc.subplots[1].series_list[1][:y] == pread.subplots[1].series_list[1][:y]
+
+	#display(pread) #Don't display. Regression env might not support
+end #testset
@@ -0,0 +1,348 @@
+using Plots, Test
+pgfplotsx()
+
+function create_plot(args...; kwargs...)
+   pgfx_plot = plot(args...; kwargs...)
+   return pgfx_plot, repr("application/x-tex", pgfx_plot)
+end
+
+function create_plot!(args...; kwargs...)
+   pgfx_plot = plot!(args...; kwargs...)
+   return pgfx_plot, repr("application/x-tex", pgfx_plot)
+end
+
+@testset "PGFPlotsX" begin
+   pgfx_plot = plot(1:5)
+   Plots._update_plot_object(pgfx_plot)
+   @test pgfx_plot.o.the_plot isa PGFPlotsX.TikzDocument
+   @test pgfx_plot.series_list[1].plotattributes[:quiver] === nothing
+   axis = Plots.pgfx_axes(pgfx_plot.o)[1]
+   @test count(x -> x isa PGFPlotsX.Plot, axis.contents) == 1
+   @test !haskey(axis.contents[1].options.dict, "fill")
+
+   @testset "Legends" begin
+      legends_plot =  plot( rand(5,2), lab = ["1" ""] )
+      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 !haskey(series[1].options.dict, "forget plot")
+      @test haskey(series[2].options.dict, "forget plot")
+      @test !haskey(series[3].options.dict, "forget plot")
+   end # testset
+
+   @testset "3D docs example" begin
+      n = 100
+      ts = range(0, stop = 8π, length = n)
+      x = ts .* map(cos, ts)
+      y = (0.1ts) .* map(sin, ts)
+      z = 1:n
+      pl = plot(
+         x,
+         y,
+         z,
+         zcolor = reverse(z),
+         m = (10, 0.8, :blues, Plots.stroke(0)),
+         leg = false,
+         cbar = true,
+         w = 5,
+      )
+      pgfx_plot = plot!(pl, zeros(n), zeros(n), 1:n, w = 10)
+      Plots._update_plot_object(pgfx_plot)
+      if @test_nowarn(
+         haskey(Plots.pgfx_axes(pgfx_plot.o)[1].options.dict, "colorbar") == true
+      )
+         @test Plots.pgfx_axes(pgfx_plot.o)[1]["colorbar"] === nothing
+      end
+   end # testset
+   @testset "Color docs example" begin
+      y = rand(100)
+      plot(
+         0:10:100,
+         rand(11, 4),
+         lab = "lines",
+         w = 3,
+         palette = :grays,
+         fill = 0,
+         α = 0.6,
+      )
+      pl = scatter!(
+         y,
+         zcolor = abs.(y .- 0.5),
+         m = (:hot, 0.8, Plots.stroke(1, :green)),
+         ms = 10 * abs.(y .- 0.5) .+ 4,
+         lab = ["grad", "", "ient"],
+      )
+      Plots._update_plot_object(pl)
+      axis = Plots.pgfx_axes(pl.o)[1]
+      @test count(x -> x isa PGFPlotsX.LegendEntry, axis.contents) == 6
+      @test count(x -> x isa PGFPlotsX.Plot, axis.contents) == 108 # each marker is its own plot, fillranges create 2 plot-objects
+      marker = axis.contents[15]
+      @test marker isa PGFPlotsX.Plot
+      @test marker.options["mark"] == "*"
+      @test marker.options["mark options"]["color"] ==
+            RGBA{Float64}(colorant"green", 0.8)
+      @test marker.options["mark options"]["line width"] == 0.75 # 1px is 0.75pt
+   end # testset
+   @testset "Plot in pieces" begin
+      pic = plot(rand(100) / 3, reg = true, fill = (0, :green))
+      scatter!(pic, rand(100), markersize = 6, c = :orange)
+      Plots._update_plot_object(pic)
+      axis_contents = Plots.pgfx_axes(pic.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) == 4
+      @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[4].options.dict, "forget plot")
+   end # testset
+   @testset "Marker types" begin
+      markers = filter((m -> begin
+         m in Plots.supported_markers()
+      end), Plots._shape_keys)
+      markers = reshape(markers, 1, length(markers))
+      n = length(markers)
+      x = (range(0, stop = 10, length = n + 2))[2:(end - 1)]
+      y = repeat(reshape(reverse(x), 1, :), n, 1)
+      scatter(
+         x,
+         y,
+         m = (8, :auto),
+         lab = map(string, markers),
+         bg = :linen,
+         xlim = (0, 10),
+         ylim = (0, 10),
+      )
+   end # testset
+   @testset "Layout" begin
+      plot(
+         Plots.fakedata(100, 10),
+         layout = 4,
+         palette = [:grays :blues :hot :rainbow],
+         bg_inside = [:orange :pink :darkblue :black],
+      )
+   end # testset
+   @testset "Polar plots" begin
+      Θ = range(0, stop = 1.5π, length = 100)
+      r = abs.(0.1 * randn(100) + sin.(3Θ))
+      plot(Θ, r, proj = :polar, m = 2)
+   end # testset
+   @testset "Drawing shapes" begin
+      verts = [
+         (-1.0, 1.0),
+         (-1.28, 0.6),
+         (-0.2, -1.4),
+         (0.2, -1.4),
+         (1.28, 0.6),
+         (1.0, 1.0),
+         (-1.0, 1.0),
+         (-0.2, -0.6),
+         (0.0, -0.2),
+         (-0.4, 0.6),
+         (1.28, 0.6),
+         (0.2, -1.4),
+         (-0.2, -1.4),
+         (0.6, 0.2),
+         (-0.2, 0.2),
+         (0.0, -0.2),
+         (0.2, 0.2),
+         (-0.2, -0.6),
+      ]
+      x = 0.1:0.2:0.9
+      y = 0.7 * rand(5) .+ 0.15
+      plot(
+         x,
+         y,
+         line = (3, :dash, :lightblue),
+         marker = (Shape(verts), 30, RGBA(0, 0, 0, 0.2)),
+         bg = :pink,
+         fg = :darkblue,
+         xlim = (0, 1),
+         ylim = (0, 1),
+         leg = false,
+      )
+   end # testset
+   @testset "Histogram 2D" begin
+      histogram2d(randn(10000), randn(10000), nbins = 20)
+   end # testset
+   @testset "Heatmap-like" begin
+      xs = [string("x", i) for i = 1:10]
+      ys = [string("y", i) for i = 1:4]
+      z = float((1:4) * reshape(1:10, 1, :))
+      pgfx_plot = heatmap(xs, ys, z, aspect_ratio = 1)
+      Plots._update_plot_object(pgfx_plot)
+      if @test_nowarn(
+         haskey(Plots.pgfx_axes(pgfx_plot.o)[1].options.dict, "colorbar") == true
+      )
+         @test Plots.pgfx_axes(pgfx_plot.o)[1]["colorbar"] === nothing
+         @test Plots.pgfx_axes(pgfx_plot.o)[1]["colormap name"] == "plots1"
+      end
+
+      pgfx_plot = wireframe(xs, ys, z, aspect_ratio = 1)
+      # TODO: clims are wrong
+   end # testset
+   @testset "Contours" begin
+      x = 1:0.5:20
+      y = 1:0.5:10
+      f(x, y) = begin
+         (3x + y^2) * abs(sin(x) + cos(y))
+      end
+      X = repeat(reshape(x, 1, :), length(y), 1)
+      Y = repeat(y, 1, length(x))
+      Z = map(f, X, Y)
+      p2 = contour(x, y, Z)
+      p1 = contour(x, y, f, fill = true)
+      plot(p1, p2)
+      # TODO: colorbar for filled contours
+   end # testset
+   @testset "Varying colors" begin
+      t = range(0, stop = 1, length = 100)
+      θ = (6π) .* t
+      x = t .* cos.(θ)
+      y = t .* sin.(θ)
+      p1 = plot(x, y, line_z = t, linewidth = 3, legend = false)
+      p2 = scatter(
+         x,
+         y,
+         marker_z = ((x, y) -> begin
+            x + y
+         end),
+         color = :bwr,
+         legend = false,
+      )
+      plot(p1, p2)
+   end # testset
+   @testset "Framestyles" begin
+      scatter(
+         fill(randn(10), 6),
+         fill(randn(10), 6),
+         framestyle = [:box :semi :origin :zerolines :grid :none],
+         title = [":box" ":semi" ":origin" ":zerolines" ":grid" ":none"],
+         color = permutedims(1:6),
+         layout = 6,
+         label = "",
+         markerstrokewidth = 0,
+         ticks = -2:2,
+      )
+      # TODO: support :semi
+   end # testset
+   @testset "Quiver" begin
+      x = (-2pi):0.2:(2 * pi)
+      y = sin.(x)
+
+      u = ones(length(x))
+      v = cos.(x)
+      arrow_plot = plot(x, y, quiver = (u, v), arrow = true)
+      # TODO: could adjust limits to fit arrows if too long, but how?
+      # TODO: get latex available on CI
+      # mktempdir() do path
+      #    @test_nowarn savefig(arrow_plot, path*"arrow.pdf")
+      # end
+   end # testset
+   @testset "Annotations" begin
+      y = rand(10)
+      pgfx_plot = plot(
+         y,
+         annotations = (3, y[3], Plots.text("this is \\#3", :left)),
+         leg = false,
+      )
+      Plots._update_plot_object(pgfx_plot)
+      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 1
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(pgfx_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 1
+         end
+      end
+      annotate!([
+         (5, y[5], Plots.text("this is \\#5", 16, :red, :center)),
+         (10, y[10], Plots.text("this is \\#10", :right, 20, "courier")),
+      ])
+      Plots._update_plot_object(pgfx_plot)
+      axis_content = Plots.pgfx_axes(pgfx_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 3
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(pgfx_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 3
+         end
+      end
+      annotation_plot = scatter!(
+         range(2, stop = 8, length = 6),
+         rand(6),
+         marker = (50, 0.2, :orange),
+         series_annotations = [
+            "series",
+            "annotations",
+            "map",
+            "to",
+            "series",
+            Plots.text("data", :green),
+         ],
+      )
+      Plots._update_plot_object(annotation_plot)
+      axis_content = Plots.pgfx_axes(annotation_plot.o)[1].contents
+      nodes = filter(x -> !isa(x, PGFPlotsX.Plot), axis_content)
+      @test length(nodes) == 9
+      mktempdir() do path
+         file_path =joinpath(path,"annotations.tex")
+         @test_nowarn savefig(annotation_plot, file_path)
+         open(file_path) do io
+            lines = readlines(io)
+            @test count(s -> occursin("node", s), lines) == 9
+         end
+      end
+   end # testset
+   @testset "Ribbon" begin
+      aa = rand(10)
+      bb = rand(10)
+      cc = rand(10)
+      conf = [aa - cc bb - cc]
+      ribbon_plot =
+         plot(collect(1:10), fill(1, 10), ribbon = (conf[:, 1], conf[:, 2]))
+      Plots._update_plot_object(ribbon_plot)
+      axis = Plots.pgfx_axes(ribbon_plot.o)[1]
+      plots = filter(x -> x isa PGFPlotsX.Plot, axis.contents)
+      @test length(plots) == 4
+      @test !haskey(plots[1].options.dict, "fill")
+      @test !haskey(plots[2].options.dict, "fill")
+      @test !haskey(plots[3].options.dict, "fill")
+      @test haskey(plots[4].options.dict, "fill")
+      @test ribbon_plot.o !== nothing
+      @test ribbon_plot.o.the_plot !== nothing
+      #    mktempdir() do path
+      #       @test_nowarn savefig(ribbon_plot, path*"ribbon.svg")
+      #    end
+   end # testset
+end # testset
+
+@testset "Extra kwargs" begin
+   pl = plot(1:5, test = "me")
+   @test pl[1][1].plotattributes[:extra_kwargs][:test] == "me"
+   pl = plot(1:5, test = "me", extra_kwargs = :subplot)
+   @test pl[1].attr[:extra_kwargs][:test] == "me"
+   pl = plot(1:5, test = "me", extra_kwargs = :plot)
+   @test pl.attr[:extra_plot_kwargs][:test] == "me"
+   pl = plot(1:5, extra_kwargs = Dict(:plot => Dict(:test => "me"), :series => Dict(:and => "me too")))
+   @test pl.attr[:extra_plot_kwargs][:test] == "me"
+   @test pl[1][1].plotattributes[:extra_kwargs][:and] == "me too"
+   pl = plot(
+     plot(1:5, title="Line"),
+     scatter(1:5, title="Scatter", extra_kwargs=Dict(:subplot=>Dict("axis line shift" => "10pt")))
+   )
+   Plots._update_plot_object(pl)
+   axes = Plots.pgfx_axes(pl.o)
+   @test !haskey(axes[1].options.dict, "axis line shift")
+   @test haskey(axes[2].options.dict, "axis line shift")
+end # testset