diff --git a/.babelrc b/.babelrc
index fd234626a..21e2dd7fd 100644
--- a/.babelrc
+++ b/.babelrc
@@ -1,8 +1,7 @@
 {
     "plugins": ["transform-class-properties"],
     "presets": [
-        "stage-0",
-        "es2015",
-        "react"
+        "@babel/preset-env",
+        "@babel/preset-react"
     ]
 }
diff --git a/.clang-tidy b/.clang-tidy
index de4303bf8..d1b047f3a 100644
--- a/.clang-tidy
+++ b/.clang-tidy
@@ -1,4 +1,86 @@
 ---
-Checks:          '-clang-analyzer-*,google-*,llvm-*,misc-*,readability-*,-google-build-explicit-make-pair,-google-explicit-constructor,-google-readability-braces-around-statements,-google-readability-casting,-google-readability-namespace-comments,-google-readability-function,-google-readability-todo,-google-runtime-int,-llvm-namespace-comment,-llvm-header-guard,-llvm-twine-local,-misc-argument-comment,-readability-braces-around-statements,-readability-identifier-naming'
-...
+Checks: >
+    bugprone-*,
+    -bugprone-narrowing-conversions,
+    -bugprone-easily-swappable-parameters,
+    -bugprone-branch-clone,
+    -bugprone-misplaced-widening-cast,
+    -bugprone-exception-escape,
+    -bugprone-implicit-widening-of-multiplication-result,
+    -bugprone-integer-division,
+    -bugprone-reserved-identifier,
+    -bugprone-unhandled-self-assignment,
+    -bugprone-forward-declaration-namespace,
+    -bugprone-sizeof-expression,
+    -clang-analyzer-*,
+    -clang-diagnostic-deprecated-declarations,
+    -clang-diagnostic-constant-conversion,
+    cppcoreguidelines-avoid-goto,
+    cppcoreguidelines-no-malloc,
+    cppcoreguidelines-virtual-class-destructor,
+    google-*,
+    -google-build-explicit-make-pair,
+    -google-build-using-namespace,
+    -google-explicit-constructor,
+    -google-default-arguments,
+    -google-readability-braces-around-statements,
+    -google-readability-casting,
+    -google-readability-namespace-comments,
+    -google-readability-function,
+    -google-readability-todo,
+    -google-runtime-int,
+    -google-build-namespaces,
+    -google-runtime-references,
+    -google-readability-function-size,
+    llvm-*,
+    -llvm-namespace-comment,
+    -llvm-qualified-auto,
+    -llvm-include-order,
+    -llvm-else-after-return,
+    -llvm-header-guard,
+    -llvm-twine-local,
+    misc-*,
+    -misc-argument-comment,
+    -misc-non-private-member-variables-in-classes,
+    -misc-unconventional-assign-operator,
+    -misc-no-recursion,
+    -misc-misplaced-const,
+    -misc-definitions-in-headers,
+    -misc-unused-parameters,
+    performance-*,
+    -performance-noexcept-move-constructor,
+    -performance-move-const-arg,
+    -performance-no-int-to-ptr,
+    readability-*,
+    -readability-avoid-const-params-in-decls,
+    -readability-braces-around-statements,
+    -readability-container-size-empty,
+    -readability-convert-member-functions-to-static,
+    -readability-const-return-type,
+    -readability-function-cognitive-complexity,
+    -readability-function-size,
+    -readability-identifier-naming,
+    -readability-implicit-bool-conversion,
+    -readability-magic-numbers,
+    -readability-else-after-return,
+    -readability-inconsistent-declaration-parameter-name,
+    -readability-isolate-declaration,
+    -readability-redundant-declaration,
+    -readability-uppercase-literal-suffix,
+    -readability-named-parameter,
+    -readability-qualified-auto,
+    -readability-suspicious-call-argument,
+    -readability-redundant-access-specifiers,
+    -readability-redundant-member-init,
+    -readability-static-definition-in-anonymous-namespace,
+    -readability-use-anyofallof,
+    -readability-simplify-boolean-expr,
+    -readability-make-member-function-const,
+    -readability-redundant-string-init,
+    -readability-non-const-parameter,
+    -readability-static-accessed-through-instance
+    
+WarningsAsErrors: '*'
+HeaderFilterRegex: '.*'
+
 
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index 1d5fbec2d..5643bb9b7 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -9,7 +9,7 @@ If your PR is still work in progress please attach the relevant label.
 
  - [ ] CHANGELOG.md entry ([How to write a changelog entry](http://keepachangelog.com/en/1.0.0/#how))
  - [ ] update relevant [Wiki pages](https://github.com/Project-OSRM/osrm-backend/wiki)
- - [ ] add tests (see [testing documentation](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/testing.md)
+ - [ ] add tests (see [testing documentation](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/testing.md))
  - [ ] review
  - [ ] adjust for comments
  - [ ] cherry pick to release branch
diff --git a/.github/workflows/osrm-backend-docker.yml b/.github/workflows/osrm-backend-docker.yml
new file mode 100644
index 000000000..e0cf8939d
--- /dev/null
+++ b/.github/workflows/osrm-backend-docker.yml
@@ -0,0 +1,84 @@
+name: build and publish container image
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:       
+      - name: Check out the repo
+        uses: actions/checkout@v2
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v1
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: ghcr.io/${{ github.repository }}
+
+      - name: Docker meta - debug
+        id: metadebug
+        uses: docker/metadata-action@v3
+        with:
+          images: ghcr.io/${{ github.repository }}
+          flavor: |
+            latest=true
+            suffix=-debug,onlatest=true
+
+      - name: Docker meta - assertions
+        id: metaassertions
+        uses: docker/metadata-action@v3
+        with:
+          images: ghcr.io/${{ github.repository }}
+          flavor: |
+            latest=true
+            suffix=-assertions,onlatest=true        
+
+      - name: Log in to GitHub Docker Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build container image - debug
+        uses: docker/build-push-action@v2
+        with:
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: ./docker/Dockerfile
+          tags: ${{ steps.metadebug.outputs.tags  }}
+          build-args: |
+            DOCKER_TAG=${{ join(steps.metadebug.outputs.tags ) }}
+
+
+      - name: Build container image - assertions
+        uses: docker/build-push-action@v2
+        with:
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: ./docker/Dockerfile
+          tags: ${{ steps.metaassertions.outputs.tags  }}
+          build-args: |
+            DOCKER_TAG=${{ join(steps.metaassertions.outputs.tags ) }}
+
+      # build and publish "normal" image as last to get it listed on top
+      - name: Build container image - normal
+        uses: docker/build-push-action@v2
+        with:
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: ./docker/Dockerfile
+          tags:  ${{ steps.meta.outputs.tags  }}
+          build-args: |
+            DOCKER_TAG=${{ join(steps.meta.outputs.tags ) }}            
+
+
+            
diff --git a/.github/workflows/osrm-backend.yml b/.github/workflows/osrm-backend.yml
new file mode 100644
index 000000000..4addd0564
--- /dev/null
+++ b/.github/workflows/osrm-backend.yml
@@ -0,0 +1,665 @@
+name: osrm-backend CI
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - v[1-9]+.[0-9]+.[0-9]+
+      - v[1-9]+.[0-9]+.[0-9]+-[0-9a-zA-Z]+
+      - v[1-9]+.[0-9]+-[0-9a-zA-Z]+
+  pull_request:
+    branches:
+      - master
+
+env:
+  CCACHE_TEMPDIR: /tmp/.ccache-temp
+  CCACHE_COMPRESS: 1
+  CASHER_TIME_OUT: 599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
+  CCACHE_VERSION: 3.3.1
+  CMAKE_VERSION: 3.21.2
+  ENABLE_NODE_BINDINGS: "ON"
+
+jobs:
+  windows:
+    needs: format-taginfo-docs
+    runs-on: windows-2022
+    continue-on-error: false
+    steps:
+    - uses: actions/checkout@v3
+    - run: pip install conan==1.50.0
+    - run: conan --version
+    - run: cmake --version
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 16
+    - run: node --version
+    - run: npm --version
+    - run: npm install --ignore-scripts
+    - run: npm link --ignore-scripts
+    - uses: microsoft/setup-msbuild@v1.1
+    - name: Build
+      run: |
+        .\scripts\ci\windows-build.bat
+
+  format-taginfo-docs:
+    runs-on: ubuntu-20.04
+    steps:
+    - uses: actions/checkout@v2
+    - name: Use Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: 12
+    - name: Enable Node.js cache
+      uses: actions/cache@v2
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
+    - name: Prepare environment
+      run: |
+        npm ci --ignore-scripts
+        export MASON=${GITHUB_WORKSPACE}/scripts/mason.sh
+        ${MASON} install clang-format 10.0.0
+        echo "$(${MASON} prefix clang-format 10.0.0)/bin" >> $GITHUB_PATH
+    - name: Run checks
+      run: |
+        ./scripts/check_taginfo.py taginfo.json profiles/car.lua
+        ./scripts/format.sh && ./scripts/error_on_dirty.sh
+        node ./scripts/validate_changelog.js
+        npm run docs && ./scripts/error_on_dirty.sh
+  
+  docker-image:
+    needs: format-taginfo-docs
+    runs-on: ubuntu-22.04
+    continue-on-error: false
+    steps:       
+      - name: Check out the repo
+        uses: actions/checkout@v3
+      - name: Enable osm.pbf cache
+        uses: actions/cache@v2
+        with:
+          path: berlin-latest.osm.pbf
+          key: v1-berlin-osm-pbf
+          restore-keys: |
+            v1-berlin-osm-pbf
+      - name: Docker build
+        run: |
+          docker build -t osrm-backend-local -f docker/Dockerfile . 
+      - name: Test Docker image
+        run: |
+          if [ ! -f "${PWD}/berlin-latest.osm.pbf" ]; then
+            wget http://download.geofabrik.de/europe/germany/berlin-latest.osm.pbf
+          fi
+          TAG=osrm-backend-local
+          # when `--memory-swap` value equals `--memory` it means container won't use swap
+          # see https://docs.docker.com/config/containers/resource_constraints/#--memory-swap-details
+          MEMORY_ARGS="--memory=1g --memory-swap=1g"
+          docker run $MEMORY_ARGS -t -v "${PWD}:/data" "${TAG}" osrm-extract -p /opt/car.lua /data/berlin-latest.osm.pbf
+          docker run $MEMORY_ARGS -t -v "${PWD}:/data" "${TAG}" osrm-partition /data/berlin-latest.osrm
+          docker run $MEMORY_ARGS -t -v "${PWD}:/data" "${TAG}" osrm-customize /data/berlin-latest.osrm
+          docker run $MEMORY_ARGS --name=osrm-container -t -p 5000:5000 -v "${PWD}:/data" "${TAG}" osrm-routed --algorithm mld /data/berlin-latest.osrm &
+          curl --retry-delay 3 --retry 10 --retry-all-errors "http://127.0.0.1:5000/route/v1/driving/13.388860,52.517037;13.385983,52.496891?steps=true"
+          docker stop osrm-container
+
+  build-test-publish:
+    needs: format-taginfo-docs
+    strategy:
+      matrix:
+        include:
+          - name: gcc-9-debug-cov
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Debug
+            CCOMPILER: gcc-9
+            CUCUMBER_TIMEOUT: 20000
+            CXXCOMPILER: g++-9
+            ENABLE_COVERAGE: ON
+
+          - name: gcc-9-debug-asan-ubsan
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Debug
+            CCOMPILER: gcc-9
+            CUCUMBER_TIMEOUT: 20000
+            CXXCOMPILER: g++-9
+            ENABLE_SANITIZER: ON
+            TARGET_ARCH: x86_64-asan-ubsan
+            OSRM_CONNECTION_RETRIES: 10
+            OSRM_CONNECTION_EXP_BACKOFF_COEF: 1.5
+
+          - name: clang-6.0-debug
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            CUCUMBER_TIMEOUT: 60000
+
+          - name: clang-11.0-debug-clang-tidy
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 11.0.0
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_CLANG_TIDY: ON
+
+          - name: conan-linux-debug-asan-ubsan
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CLANG_VERSION: 11.0.0
+            ENABLE_CONAN: ON
+            ENABLE_SANITIZER: ON
+
+          - name: conan-linux-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_CONAN: ON
+
+          - name: gcc-11-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-11
+            CXXCOMPILER: g++-11
+
+          - name: gcc-10-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-10
+            CXXCOMPILER: g++-10
+
+          - name: gcc-9-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CXXCOMPILER: g++-9
+            CXXFLAGS: -Wno-cast-function-type
+
+          - name: gcc-9-release-i686
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-9
+            CFLAGS: "-m32 -msse2 -mfpmath=sse"
+            CXXCOMPILER: g++-9
+            CXXFLAGS: "-m32 -msse2 -mfpmath=sse"
+            TARGET_ARCH: i686
+
+          - name: gcc-8-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-8
+            CXXCOMPILER: g++-8
+            CXXFLAGS: -Wno-cast-function-type
+
+          - name: gcc-7-release
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: gcc-7
+            CXXCOMPILER: g++-7
+
+          - name: conan-osx-release-node-12
+            build_node_package: true
+            continue-on-error: false
+            node: 12
+            runs-on: macos-11
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: clang
+            CXXCOMPILER: clang++
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_ASSERTIONS: ON
+            ENABLE_CONAN: ON
+
+          - name: conan-osx-release-node-14
+            build_node_package: true
+            continue-on-error: false
+            node: 14
+            runs-on: macos-11
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: clang
+            CXXCOMPILER: clang++
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_ASSERTIONS: ON
+            ENABLE_CONAN: ON
+
+          - name: conan-osx-release-node-16
+            build_node_package: true
+            continue-on-error: false
+            node: 16
+            runs-on: macos-11
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            CCOMPILER: clang
+            CXXCOMPILER: clang++
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_ASSERTIONS: ON
+            ENABLE_CONAN: ON
+
+          - name: gcc-7-release-shared
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TOOLS: ON
+            BUILD_TYPE: Release
+            BUILD_SHARED_LIBS: ON
+            CCOMPILER: gcc-7
+            CXXCOMPILER: g++-7
+
+          - name: node-12-conan-linux-release
+            build_node_package: true
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-12-conan-linux-debug
+            build_node_package: true
+            continue-on-error: false
+            node: 12
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-14-conan-linux-release
+            build_node_package: true
+            continue-on-error: false
+            node: 14
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-14-conan-linux-debug
+            build_node_package: true
+            continue-on-error: false
+            node: 14
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+
+          - name: node-16-conan-linux-release
+            build_node_package: true
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-16-conan-linux-debug
+            build_node_package: true
+            continue-on-error: false
+            node: 16
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: conan-osx-release-node-latest
+            build_node_package: true
+            continue-on-error: true
+            node: latest
+            runs-on: macos-11
+            BUILD_TYPE: Release
+            CCOMPILER: clang
+            CXXCOMPILER: clang++
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_ASSERTIONS: ON
+            ENABLE_CONAN: ON
+
+          - name: node-latest-conan-linux-release
+            build_node_package: true
+            continue-on-error: true
+            node: latest
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-latest-conan-linux-debug
+            build_node_package: true
+            continue-on-error: true
+            node: latest
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: conan-osx-release-node-lts
+            build_node_package: true
+            continue-on-error: true
+            node: "lts/*"
+            runs-on: macos-11
+            BUILD_TYPE: Release
+            CCOMPILER: clang
+            CXXCOMPILER: clang++
+            CUCUMBER_TIMEOUT: 60000
+            ENABLE_ASSERTIONS: ON
+            ENABLE_CONAN: ON
+
+          - name: node-lts-conan-linux-release
+            build_node_package: true
+            continue-on-error: true
+            node: "lts/*"
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Release
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+          - name: node-lts-conan-linux-debug
+            build_node_package: true
+            continue-on-error: true
+            node: "lts/*"
+            runs-on: ubuntu-20.04
+            BUILD_TYPE: Debug
+            CLANG_VERSION: 6.0.0
+            ENABLE_GLIBC_WORKAROUND: ON
+            ENABLE_CONAN: ON
+            NODE_PACKAGE_TESTS_ONLY: ON
+
+
+    name: ${{ matrix.name}}
+    continue-on-error: ${{ matrix.continue-on-error }}
+    runs-on: ${{ matrix.runs-on }}
+    env:
+      BUILD_TOOLS: ${{ matrix.BUILD_TOOLS }}
+      BUILD_TYPE: ${{ matrix.BUILD_TYPE }}
+      BUILD_SHARED_LIBS: ${{ matrix.BUILD_SHARED_LIBS }}
+      CCOMPILER: ${{ matrix.CCOMPILER }}
+      CFLAGS: ${{ matrix.CFLAGS }}
+      CLANG_VERSION: ${{ matrix.CLANG_VERSION }}
+      CUCUMBER_TIMEOUT: ${{ matrix.CUCUMBER_TIMEOUT }}
+      CXXCOMPILER: ${{ matrix.CXXCOMPILER }}
+      CXXFLAGS: ${{ matrix.CXXFLAGS }}
+      ENABLE_ASSERTIONS: ${{ matrix.ENABLE_ASSERTIONS }}
+      ENABLE_CLANG_TIDY: ${{ matrix.ENABLE_CLANG_TIDY }} 
+      ENABLE_COVERAGE: ${{ matrix.ENABLE_COVERAGE }}
+      ENABLE_GLIBC_WORKAROUND: ${{ matrix.ENABLE_GLIBC_WORKAROUND }}
+      ENABLE_CONAN: ${{ matrix.ENABLE_CONAN }}
+      ENABLE_SANITIZER: ${{ matrix.ENABLE_SANITIZER }}
+      NODE_PACKAGE_TESTS_ONLY: ${{ matrix.NODE_PACKAGE_TESTS_ONLY }}
+      TARGET_ARCH: ${{ matrix.TARGET_ARCH }}
+      OSRM_CONNECTION_RETRIES: ${{ matrix.OSRM_CONNECTION_RETRIES }}
+      OSRM_CONNECTION_EXP_BACKOFF_COEF: ${{ matrix.OSRM_CONNECTION_EXP_BACKOFF_COEF }}
+    steps:
+    - uses: actions/checkout@v2
+
+    - name: Use Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node }}
+    - name: Enable Node.js cache
+      uses: actions/cache@v2
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
+    - name: Enable compiler cache
+      uses: actions/cache@v2
+      with:
+        path: ~/.ccache
+        key: ccache-${{ matrix.name }}-${{ github.sha }}
+        restore-keys: |
+          ccache-${{ matrix.name }}-
+    - name: Enable Conan cache
+      uses: actions/cache@v2
+      with:
+        path: ~/.conan
+        key: v2-conan-${{ matrix.name }}-${{ github.sha }}
+        restore-keys: |
+          v2-conan-${{ matrix.name }}-
+    - name: Enable test cache
+      uses: actions/cache@v2
+      with:
+        path: ${{github.workspace}}/test/cache
+        key: v2-test-${{ matrix.name }}-${{ github.sha }}
+        restore-keys: |
+          v2-test-${{ matrix.name }}-
+
+    - name: Prepare environment
+      run: |
+        PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
+        echo PUBLISH=$([[ "${GITHUB_REF:-}" == "refs/tags/v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off") >> $GITHUB_ENV
+
+        echo "OSRM_INSTALL_DIR=${GITHUB_WORKSPACE}/install-osrm" >> $GITHUB_ENV
+        echo "OSRM_BUILD_DIR=${GITHUB_WORKSPACE}/build-osrm" >> $GITHUB_ENV
+
+        if [[ "$ENABLE_SANITIZER" == 'ON' ]]; then
+          # We can only set this after checkout once we know the workspace directory
+          echo "LSAN_OPTIONS=print_suppressions=0:suppressions=${GITHUB_WORKSPACE}/scripts/ci/leaksanitizer.conf" >> $GITHUB_ENV
+          echo "UBSAN_OPTIONS=symbolize=1:halt_on_error=1:print_stacktrace=1:suppressions=${GITHUB_WORKSPACE}/scripts/ci/undefinedsanitizer.conf" >> $GITHUB_ENV
+        fi
+
+        if [[ "${RUNNER_OS}" == "Linux" ]]; then
+          echo "JOBS=$((`nproc` + 1))" >>  $GITHUB_ENV
+          export MASON_OS=linux
+        elif [[ "${RUNNER_OS}" == "macOS" ]]; then
+          echo "JOBS=$((`sysctl -n hw.ncpu` + 1))" >>  $GITHUB_ENV
+          sudo mdutil -i off /
+          export MASON_OS=osx
+        fi
+
+        echo "MASON=${GITHUB_WORKSPACE}/scripts/mason.sh" >> $GITHUB_ENV
+        echo "CMAKE_URL=https://mason-binaries.s3.amazonaws.com/${MASON_OS}-x86_64/cmake/${CMAKE_VERSION}.tar.gz" >> $GITHUB_ENV
+        echo "CMAKE_DIR=mason_packages/${MASON_OS}-x86_64/cmake/${CMAKE_VERSION}" >> $GITHUB_ENV
+
+
+    - name: Install dev dependencies
+      run: |
+        python3 -m pip install conan==1.50.0
+
+        # CMake
+        mkdir -p ${CMAKE_DIR}
+        wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${CMAKE_DIR}
+        echo "${CMAKE_DIR}/bin" >> $GITHUB_PATH
+
+        # TBB
+        ${MASON} install tbb 2017_U7
+        echo "LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_U7)/lib/:${LD_LIBRARY_PATH}" >> $GITHUB_ENV
+
+        # ccache
+        ${MASON} install ccache ${CCACHE_VERSION}
+        echo "$(${MASON} prefix ccache ${CCACHE_VERSION})/bin" >> $GITHUB_PATH
+
+        # clang
+        if [[ -n ${CLANG_VERSION} ]]; then
+          echo "CCOMPILER=clang" >> $GITHUB_ENV
+          echo "CXXCOMPILER=clang++" >> $GITHUB_ENV
+          ${MASON} install clang++ ${CLANG_VERSION}
+          echo "$(${MASON} prefix clang++ ${CLANG_VERSION})/bin" >> $GITHUB_PATH
+          # we only enable lto for release builds
+          # and therefore don't need to us ld.gold or llvm tools for linking
+          # for debug builds
+          if [[ ${BUILD_TYPE} == 'Release' ]]; then
+            ${MASON} install binutils 2.27
+            echo "$(${MASON} prefix binutils 2.27)/bin" >> $GITHUB_PATH
+          fi
+        fi
+
+        # Linux dev packages
+        if [ "${TARGET_ARCH}" != "i686" ] && [ "${ENABLE_CONAN}" != "ON" ]; then
+          sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
+          sudo apt-get update -y
+          sudo apt-get install -y libbz2-dev libxml2-dev libzip-dev liblua5.2-dev libtbb-dev libboost-all-dev
+          if [[ -z "${CLANG_VERSION}" ]]; then
+            sudo apt-get install -y ${CXXCOMPILER}
+          fi
+          if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
+            sudo apt-get install -y lcov
+          fi
+        elif [[ $TARGET_ARCH == "i686" ]]; then
+          source ./scripts/ci/before_install.${TARGET_ARCH}.sh
+          echo "PKG_CONFIG_PATH=/usr/lib/i386-linux-gnu/pkgconfig:${PKG_CONFIG_PATH}" >> $GITHUB_ENV
+        fi
+
+    - name: Prepare build
+      run: |
+        mkdir ${OSRM_BUILD_DIR}
+        ccache --max-size=256M
+        npm ci --ignore-scripts
+        if [[ "${ENABLE_COVERAGE}" == "ON" ]]; then
+          lcov --directory . --zerocounters # clean cached files
+        fi
+        echo "CC=${CCOMPILER}" >> $GITHUB_ENV
+        echo "CXX=${CXXCOMPILER}" >> $GITHUB_ENV
+
+    - name: Build and install OSRM
+      run: |
+        echo "Using ${JOBS} jobs"
+        pushd ${OSRM_BUILD_DIR}
+        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+                 -DENABLE_CONAN=${ENABLE_CONAN:-OFF} \
+                 -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
+                 -DENABLE_CLANG_TIDY=${ENABLE_CLANG_TIDY:-OFF} \
+                 -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} \
+                 -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
+                 -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
+                 -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
+                 -DBUILD_TOOLS=${BUILD_TOOLS:-OFF} \
+                 -DENABLE_CCACHE=ON \
+                 -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
+                 -DENABLE_GLIBC_WORKAROUND=${ENABLE_GLIBC_WORKAROUND:-OFF}
+        make --jobs=${JOBS}
+
+        if [[ "${NODE_PACKAGE_TESTS_ONLY}" != "ON" ]]; then
+          make tests --jobs=${JOBS}
+          make benchmarks --jobs=${JOBS}
+          ccache -s
+          sudo make install
+          if [[ "${RUNNER_OS}" == "Linux" ]]; then
+            echo "LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib" >> $GITHUB_ENV
+          fi
+          echo "PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig" >> $GITHUB_ENV
+        fi
+        popd
+    - name: Build example
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      run: |
+        mkdir example/build && pushd example/build
+        cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
+        make --jobs=${JOBS}
+        popd
+
+    - name: Run all tests
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY != 'ON' }}
+      run: |
+        make -C test/data benchmark
+
+        # macOS SIP strips the linker path. Reset this inside the running shell
+        export LD_LIBRARY_PATH=${{ env.LD_LIBRARY_PATH }}
+        ./example/build/osrm-example test/data/mld/monaco.osrm
+
+        # All tests assume to be run from the build directory
+        pushd ${OSRM_BUILD_DIR}
+        for i in ./unit_tests/*-tests ; do echo Running $i ; $i ; done
+        if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
+          npm run nodejs-tests
+        fi
+        popd
+        npm test
+    - name: Run Node package tests only
+      if: ${{ matrix.NODE_PACKAGE_TESTS_ONLY == 'ON' }}
+      run: |
+        npm run nodejs-tests
+    - name: Upload test logs
+      uses: actions/upload-artifact@v3
+      if: failure()
+      with:
+        name: logs
+        path: test/logs/
+
+    - name: Generate code coverage
+      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+      run: |
+        lcov --directory . --capture --output-file coverage.info # capture coverage info
+        lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
+        lcov --list coverage.info #debug info
+        # Uploading report to CodeCov
+    - name: Upload code coverage
+      if: ${{ matrix.ENABLE_COVERAGE == 'ON' }}
+      uses: codecov/codecov-action@v1
+      with:
+        files: coverage.info
+        name: codecov-osrm-backend
+        fail_ci_if_error: true
+        verbose: true
+
+    - name: Build Node package
+      if: ${{ matrix.build_node_package && env.PUBLISH == 'On' }}
+      run: ./scripts/ci/node_package.sh
+    - name: Publish Node package
+      if: ${{ matrix.build_node_package && env.PUBLISH == 'On' }}
+      uses: ncipollo/release-action@v1
+      with:
+        allowUpdates: true
+        artifactErrorsFailBuild: true
+        artifacts: build/stage/**/*.tar.gz
+        omitBody: true
+        omitBodyDuringUpdate: true
+        omitName: true
+        omitNameDuringUpdate: true
+        replacesArtifacts: true
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+  ci-complete:
+    runs-on: ubuntu-18.04
+    needs: [build-test-publish, docker-image, windows]
+    steps:
+    - run: echo "CI complete"
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 8a62697ae..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,519 +0,0 @@
-language: cpp
-
-git:
-  depth: 10
-
-# sudo:required is needed for trusty images
-sudo: required
-dist: trusty
-
-notifications:
-  email: false
-
-branches:
-  only:
-    - master
-    # enable building tags
-    - /^v\d+\.\d+(\.\d+)?(-\S*)?$/
-
-cache:
-  npm: true
-  ccache: true
-  apt: true
-  directories:
-    - test/cache
-
-env:
-  global:
-   - secure: "hk+32aXXF5t1ApaM2Wjqooz3dx1si907L87WRMkO47WlpJmUUU/Ye+MJk9sViH8MdhOcceocVAmdYl5/WFWOIbDWNlBya9QvXDZyIu2KIre/0QyOCTZbrsif8paBXKIO5O/R4OTvIZ8rvWZsadBdmAT9GSbDhih6FzqXAEgeIYQ="
-   - secure: "VE+cFkseFwW4jK6XwkP0yW3h4DixPJ8+Eb3yKcchGZ5iIJxlZ/8i1vKHYxadgPRwSYwPSB14tF70xj2OmiT2keGzZUfphmPXinBaLEhYk+Bde+GZZkoSl5ND109I/LcyNr0nG9dDgtV6pkvFchgchpyP9JnVOOS0+crEZlAz0RE="
-   - CCACHE_TEMPDIR=/tmp/.ccache-temp
-   - CCACHE_COMPRESS=1
-   - CASHER_TIME_OUT=599 # one second less than 10m to avoid 10m timeout error: https://github.com/Project-OSRM/osrm-backend/issues/2742
-   - CCACHE_VERSION=3.3.1
-   - CMAKE_VERSION=3.7.2
-   - MASON="$(pwd)/scripts/mason.sh"
-   - ENABLE_NODE_BINDINGS=On
-   - NODE="10"
-
-stages:
-  - core
-  - optional
-
-matrix:
-  fast_finish: true
-
-  # We override the compiler names here to yield better ccache behavior, which uses this as key
-  include:
-
-    # Debug Builds
-    - stage: core
-      os: linux
-      compiler: "format-taginfo-docs"
-      env: NODE=10
-      sudo: false
-      before_install:
-      install:
-        - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
-        - source $NVM_DIR/nvm.sh
-        - nvm install $NODE
-        - nvm use $NODE
-        - npm --version
-        - npm ci --ignore-scripts
-      script:
-        - ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-        - ${MASON} install clang-format 3.8.1
-        - PATH=$(${MASON} prefix clang-format 3.8.1)/bin:${PATH} ./scripts/format.sh && ./scripts/error_on_dirty.sh
-        - node ./scripts/validate_changelog.js
-        # See issue 4043
-        #- npm run docs && ./scripts/error_on_dirty.sh
-      after_success:
-
-    - os: linux
-      compiler: "gcc-7-debug-cov"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'lcov']
-      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' ENABLE_COVERAGE=ON CUCUMBER_TIMEOUT=20000
-      before_script:
-        - cd ${TRAVIS_BUILD_DIR}
-        - lcov --directory . --zerocounters # clean cached da files
-      after_success:
-        # Creating report
-        - cd ${TRAVIS_BUILD_DIR}
-        - lcov --directory . --capture --output-file coverage.info # capture coverage info
-        - lcov --remove coverage.info '/usr/*' --output-file coverage.info # filter out system
-        - lcov --list coverage.info #debug info
-        # Uploading report to CodeCov
-        - bash <(curl -s https://codecov.io/bash) || echo "Codecov did not collect coverage reports"
-
-    - os: linux
-      compiler: "gcc-7-debug-asan"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Debug' TARGET_ARCH='x86_64-asan' ENABLE_SANITIZER=ON CUCUMBER_TIMEOUT=20000 LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
-
-    - os: linux
-      compiler: "clang-5.0-debug"
-      addons: &clang50
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-5-dev', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' CUCUMBER_TIMEOUT=60000
-
-    - os: linux
-      compiler: "mason-linux-debug-asan"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_SANITIZER=ON LSAN_OPTIONS="suppressions=$TRAVIS_BUILD_DIR/scripts/travis/leaksanitizer.conf"
-
-    # Release Builds
-    - os: linux
-      compiler: "mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON RUN_CLANG_FORMAT=ON ENABLE_LTO=ON
-
-    - os: linux
-      compiler: "gcc-9-release"
-      addons: &gcc9
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-9', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-9' CXXCOMPILER='g++-9' BUILD_TYPE='Release' CXXFLAGS='-Wno-cast-function-type'
-
-    - os: linux
-      compiler: "gcc-8-release"
-      addons: &gcc8
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-8', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-8' CXXCOMPILER='g++-8' BUILD_TYPE='Release' CXXFLAGS='-Wno-cast-function-type'
-
-    - os: linux
-      compiler: "gcc-7-release"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: "gcc-7-release-i686"
-      env: >
-        TARGET_ARCH='i686' CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release'
-        CFLAGS='-m32 -msse2 -mfpmath=sse' CXXFLAGS='-m32 -msse2 -mfpmath=sse'
-
-    - os: linux
-      compiler: "gcc-5-release"
-      addons: &gcc49
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
-      env: CCOMPILER='gcc-5' CXXCOMPILER='g++-5' BUILD_TYPE='Release'
-
-    - os: linux
-      compiler: "gcc-6-release"
-      addons: &gcc49
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-6', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev', 'ccache']
-      env: CCOMPILER='gcc-6' CXXCOMPILER='g++-6' BUILD_TYPE='Release'
-
-    - os: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-10"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="10"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-8"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="8"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    # Shared Library
-    - os: linux
-      compiler: "gcc-7-release-shared"
-      addons: &gcc7
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-7', 'libbz2-dev', 'libxml2-dev', 'libzip-dev', 'liblua5.2-dev', 'libtbb-dev', 'libboost-all-dev']
-      env: CCOMPILER='gcc-7' CXXCOMPILER='g++-7' BUILD_TYPE='Release' BUILD_SHARED_LIBS=ON
-
-    # Node build jobs. These skip running the tests.
-    - os: linux
-      sudo: false
-      compiler: "node-8-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-8-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="8"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-10-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="10"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-10-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="10"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: osx
-      stage: optional
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-latest"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="node"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-latest-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-latest-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: osx
-      osx_image: xcode9.2
-      compiler: "mason-osx-release-node-lts"
-      # we use the xcode provides clang and don't install our own
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="--lts"
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-lts-mason-linux-release"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-    - os: linux
-      sudo: false
-      compiler: "node-lts-mason-linux-debug"
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['libstdc++-4.9-dev']
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-      install:
-        - pushd ${OSRM_BUILD_DIR}
-        - |
-          cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-              -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-              -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-              -DENABLE_CCACHE=ON \
-              -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-              -DENABLE_GLIBC_WORKAROUND=ON
-        - make --jobs=${JOBS}
-        - popd
-      script:
-        - npm run nodejs-tests
-      after_success:
-        - ./scripts/travis/publish.sh
-
-  allow_failures:
-    - compiler: "mason-osx-release-node-latest"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="node"
-    - compiler: "node-latest-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "node-latest-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="node"
-    - compiler: "mason-osx-release-node-lts"
-      env: ENABLE_MASON=ON BUILD_TYPE='Release' CUCUMBER_TIMEOUT=60000 CCOMPILER='clang' CXXCOMPILER='clang++' ENABLE_ASSERTIONS=ON ENABLE_LTO=ON NODE="--lts"
-    - compiler: "node-lts-mason-linux-release"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Release' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-    - compiler: "node-lts-mason-linux-debug"
-      env: CLANG_VERSION='5.0.0' BUILD_TYPE='Debug' ENABLE_MASON=ON ENABLE_LTO=ON JOBS=3 NODE="--lts"
-
-before_install:
-  - curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.34.0/install.sh | bash
-  - source $NVM_DIR/nvm.sh
-  - nvm install $NODE
-  - nvm use $NODE
-  - node --version
-  - if [[ ! -z $TARGET_ARCH ]] ; then source ./scripts/travis/before_install.$TARGET_ARCH.sh ; fi
-  - |
-    if [[ -z $JOBS ]]; then
-      if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-        export JOBS=$((`nproc` + 1))
-      elif [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-        export JOBS=$((`sysctl -n hw.ncpu` + 1))
-      fi
-    fi
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-      sudo mdutil -i off /
-    fi
-  - export PACKAGE_JSON_VERSION=$(node -e "console.log(require('./package.json').version)")
-  - export PUBLISH=$([[ "${TRAVIS_TAG:-}" == "v${PACKAGE_JSON_VERSION}" ]] && echo "On" || echo "Off")
-  - echo "Using ${JOBS} jobs"
-  - npm ci --ignore-scripts
-    # Bootstrap cmake to be able to run mason
-  - CMAKE_URL="https://mason-binaries.s3.amazonaws.com/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}.tar.gz"
-  - CMAKE_DIR="mason_packages/${TRAVIS_OS_NAME}-x86_64/cmake/${CMAKE_VERSION}"
-  - mkdir -p ${CMAKE_DIR}
-  - travis_retry wget --quiet -O - ${CMAKE_URL} | tar --strip-components=1 -xz -C ${CMAKE_DIR} || travis_terminate 1
-  - export PATH=${CMAKE_DIR}/bin:${PATH}
-  - ${MASON} install tbb 2017_U7 && export LD_LIBRARY_PATH=$(${MASON} prefix tbb 2017_U7)/lib/:${LD_LIBRARY_PATH}
-  - ${MASON} install ccache ${CCACHE_VERSION} && export PATH=$(${MASON} prefix ccache ${CCACHE_VERSION})/bin:${PATH}
-  - |
-    if [[ ! -z ${CLANG_VERSION} ]]; then
-      export CCOMPILER='clang'
-      export CXXCOMPILER='clang++'
-      ${MASON} install clang++ ${CLANG_VERSION} && export PATH=$(${MASON} prefix clang++ ${CLANG_VERSION})/bin:${PATH} || travis_terminate 1
-      # we only enable lto for release builds
-      # and therefore don't need to us ld.gold or llvm tools for linking
-      # for debug builds
-      if [[ ${BUILD_TYPE} == 'Release' ]]; then
-        ${MASON} install binutils 2.27 && export PATH=$(${MASON} prefix binutils 2.27)/bin:${PATH} || travis_terminate 1
-      fi
-    fi
-  - ccache --max-size=256M  # limiting the cache's size to roughly the previous job's object sizes
-  - export OSRM_INSTALL_DIR="$(pwd)/install-osrm"
-  - export OSRM_BUILD_DIR="$(pwd)/build-osrm"
-  - export CC=${CCOMPILER} CXX=${CXXCOMPILER}
-  - mkdir ${OSRM_BUILD_DIR}
-
-install:
-  - pushd ${OSRM_BUILD_DIR}
-  - |
-    cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
-             -DENABLE_MASON=${ENABLE_MASON:-OFF} \
-             -DENABLE_ASSERTIONS=${ENABLE_ASSERTIONS:-OFF} \
-             -DBUILD_SHARED_LIBS=${BUILD_SHARED_LIBS:-OFF} \
-             -DENABLE_COVERAGE=${ENABLE_COVERAGE:-OFF} \
-             -DENABLE_NODE_BINDINGS=${ENABLE_NODE_BINDINGS:-OFF} \
-             -DENABLE_SANITIZER=${ENABLE_SANITIZER:-OFF} \
-             -DBUILD_TOOLS=ON \
-             -DENABLE_CCACHE=ON \
-             -DCMAKE_INSTALL_PREFIX=${OSRM_INSTALL_DIR} \
-             -DENABLE_GLIBC_WORKAROUND=${ENABLE_GLIBC_WORKAROUND:-OFF}
-  - echo "travis_fold:start:MAKE"
-  - make --jobs=${JOBS}
-  - make tests --jobs=${JOBS}
-  - make benchmarks --jobs=${JOBS}
-  - echo "travis_fold:end:MAKE"
-  - ccache -s
-  - sudo make install
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "linux" ]]; then
-      export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${OSRM_INSTALL_DIR}/lib
-    fi
-  - popd
-  - mkdir example/build && pushd example/build
-  - export PKG_CONFIG_PATH=${OSRM_INSTALL_DIR}/lib/pkgconfig
-  - cmake .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE}
-  - make --jobs=${JOBS}
-  - popd
-
-script:
-  - if [[ $TARGET_ARCH == armhf ]] ; then echo "Skip tests for $TARGET_ARCH" && exit 0 ; fi
-  - make -C test/data benchmark
-  - ./example/build/osrm-example test/data/mld/monaco.osrm
-  # All tests assume to be run from the build directory
-  - pushd ${OSRM_BUILD_DIR}
-  - ./unit_tests/library-tests
-  - ./unit_tests/extractor-tests
-  - ./unit_tests/contractor-tests
-  - ./unit_tests/engine-tests
-  - ./unit_tests/util-tests
-  - ./unit_tests/server-tests
-  - ./unit_tests/partitioner-tests
-  - |
-    if [ -z "${ENABLE_SANITIZER}" ] && [ "$TARGET_ARCH" != "i686" ]; then
-      npm run nodejs-tests
-    fi
-  - |
-  - popd
-  - npm test
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cd658ba9b..3b1c3fbd4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,90 @@
 # Unreleased
+  - Changes from 5.26.0
+    - API:
+      - FIXED: Use Boost.Beast to parse HTTP request. [#6294](https://github.com/Project-OSRM/osrm-backend/pull/6294)
+      - FIXED: Fix inefficient osrm-routed connection handling [#6113](https://github.com/Project-OSRM/osrm-backend/pull/6113)
+    - Misc:
+      - CHANGED: missing files list is included in exception message. [#5360](https://github.com/Project-OSRM/osrm-backend/pull/5360)
+      - CHANGED: Do not use deprecated Callback::Call overload in Node bindings. [#6318](https://github.com/Project-OSRM/osrm-backend/pull/6318)
+      - FIXED: Fix distance calculation consistency. [#6315](https://github.com/Project-OSRM/osrm-backend/pull/6315)
+      - FIXED: Fix performance issue after migration to sol2 3.3.0. [#6304](https://github.com/Project-OSRM/osrm-backend/pull/6304)
+      - CHANGED: Pass osm_node_ids by reference in osrm::updater::Updater class. [#6298](https://github.com/Project-OSRM/osrm-backend/pull/6298)
+      - FIXED: Fix bug with reading Set values from Lua scripts. [#6285](https://github.com/Project-OSRM/osrm-backend/pull/6285)
+      - FIXED: Bug in bicycle profile that caused exceptions if there is a highway=bicycle in the data. [#6296](https://github.com/Project-OSRM/osrm-backend/pull/6296)
+    - Build:
+      - CHANGED: Use the latest node on CI. [#6317](https://github.com/Project-OSRM/osrm-backend/pull/6317)
+      - CHANGED: Migrate Windows CI to GitHub Actions. [#6312](https://github.com/Project-OSRM/osrm-backend/pull/6312)
+      - ADDED: Add smoke test for Docker image. [#6313](https://github.com/Project-OSRM/osrm-backend/pull/6313)
+      - CHANGED: Update libosmium to version 2.18.0. [#6303](https://github.com/Project-OSRM/osrm-backend/pull/6303)
+      - CHANGED: Remove EXACT from find_package if using Conan. [#6299](https://github.com/Project-OSRM/osrm-backend/pull/6299)
+      - CHANGED: Configure Undefined Behaviour Sanitizer. [#6290](https://github.com/Project-OSRM/osrm-backend/pull/6290)
+      - CHANGED: Use Conan instead of Mason to install code dependencies. [#6284](https://github.com/Project-OSRM/osrm-backend/pull/6284)
+      - CHANGED: Migrate to C++17. Update sol2 to 3.3.0. [#6279](https://github.com/Project-OSRM/osrm-backend/pull/6279)
+      - CHANGED: Update macOS CI image to macos-11. [#6286](https://github.com/Project-OSRM/osrm-backend/pull/6286)
+      - CHANGED: Enable even more clang-tidy checks. [#6273](https://github.com/Project-OSRM/osrm-backend/pull/6273)
+      - CHANGED: Configure CMake to not build flatbuffers tests and samples. [#6274](https://github.com/Project-OSRM/osrm-backend/pull/6274)
+      - CHANGED: Enable more clang-tidy checks. [#6270](https://github.com/Project-OSRM/osrm-backend/pull/6270)
+      - CHANGED: Configure clang-tidy job on CI. [#6261](https://github.com/Project-OSRM/osrm-backend/pull/6261)
+      - CHANGED: Use Github Actions for building container images [#6138](https://github.com/Project-OSRM/osrm-backend/pull/6138)
+      - CHANGED: Upgrade Boost dependency to 1.70 [#6113](https://github.com/Project-OSRM/osrm-backend/pull/6113)
+      - CHANGED: Upgrade Ubuntu CI builds to 20.04  [#6119](https://github.com/Project-OSRM/osrm-backend/pull/6119)
+      - CHANGED: Make building osrm-routed optional [#6144](https://github.com/Project-OSRM/osrm-backend/pull/6144)
+      - FIXED: Run all unit tests in CI [#5248](https://github.com/Project-OSRM/osrm-backend/pull/5248)
+      - FIXED: Fix installation of Mason CMake and 32 bit CI build [#6170](https://github.com/Project-OSRM/osrm-backend/pull/6170)
+      - FIXED: Fixed Node docs generation check in CI. [#6058](https://github.com/Project-OSRM/osrm-backend/pull/6058)
+      - CHANGED: Docker build, enabled arm64 build layer [#6172](https://github.com/Project-OSRM/osrm-backend/pull/6172)
+      - CHANGED: Docker build, enabled apt-get update/install caching in separate layer for build phase [#6175](https://github.com/Project-OSRM/osrm-backend/pull/6175)
+
+# 5.26.0
+  - Changes from 5.25.0
+    - API:
+      - FIXED: Allow for special characters in the profile/method as part of the HTTP URL. [#6090](https://github.com/Project-OSRM/osrm-backend/pull/6090)
+      - FIXED: Set osrm-routed to immediately close bad connections [#6112](https://github.com/Project-OSRM/osrm-backend/pull/6112)
+    - Build:
+      - CHANGED: Replace Travis with Github Actions for CI builds [#6071](https://github.com/Project-OSRM/osrm-backend/pull/6071)
+      - FIXED: Fixed Boost link flags in pkg-config file. [#6083](https://github.com/Project-OSRM/osrm-backend/pull/6083)
+      - FIXED: Fixed test cache to consider MLD executable changes. [#6129](https://github.com/Project-OSRM/osrm-backend/pull/6129)
+    - Routing:
+      - FIXED: Fix generation of inefficient MLD partitions [#6084](https://github.com/Project-OSRM/osrm-backend/pull/6084)
+      - FIXED: Fix MLD level mask generation to support 64-bit masks. [#6123](https://github.com/Project-OSRM/osrm-backend/pull/6123)
+      - FIXED: Fix metric offset overflow for large MLD partitions. This breaks the **data format** [#6124](https://github.com/Project-OSRM/osrm-backend/pull/6124)
+
+# 5.25.0
+  - Changes from 5.24.0
+    - Build:
+      - CHANGED: Node binaries now use Github Releases for hosting [#6030](https://github.com/Project-OSRM/osrm-backend/pull/6030)
+    - Misc:
+      - FIXED: Upgrade to @mapbox/node-pre-gyp fix various bugs with Node 12/14 [#5991](https://github.com/Project-OSRM/osrm-backend/pull/5991)
+      - FIXED: `valid` type in documentation examples [#5990](https://github.com/Project-OSRM/osrm-backend/issues/5990)
+      - FIXED: Remove redundant loading of .osrm.cell_metrics [#6019](https://github.com/Project-OSRM/osrm-backend/issues/6019)
+      - CHANGED: Increase PackedOSMIDs size to 34 bits. This breaks the **data format** [#6020](https://github.com/Project-OSRM/osrm-backend/issues/6020)
+    - Profile:
+      - FIXED: Add kerb barrier exception to default car profile. [#5999](https://github.com/Project-OSRM/osrm-backend/pull/5999)
+
+# 5.24.0
   - Changes from 5.23.0
+    - Features
+      - ADDED: Added support for multiple via-way restrictions. [#5907](https://github.com/Project-OSRM/osrm-backend/pull/5907)
+      - ADDED: Add node bindings support for Node 12, 14, and publish binaries [#5918](https://github.com/Project-OSRM/osrm-backend/pull/5918)
+      - REMOVED: we no longer publish Node 8 binary modules (they are still buildable from source) [#5918](https://github.com/Project-OSRM/osrm-backend/pull/5918)
+    - Routing:
+      - FIXED: Avoid copying ManyToMany table results [#5923](https://github.com/Project-OSRM/osrm-backend/pull/5923)
+      - FIXED: Reduce copying in API parameter constructors [#5925](https://github.com/Project-OSRM/osrm-backend/pull/5925)
+    - Misc:
+      - CHANGED: Cleanup NodeJS dependencies [#5945](https://github.com/Project-OSRM/osrm-backend/pull/5945)
+      - CHANGED: Unify `.osrm.turn_penalites_index` dump processing same with `.osrm.turn_weight_penalties` and `.osrm.turn_duration_penalties` [#5868](https://github.com/Project-OSRM/osrm-backend/pull/5868)
+      - FIXED: Properly validate source/destination validation in NodeJS table service [#5595](https://github.com/Project-OSRM/osrm-backend/pull/5595/files)
+      - FIXED: turn.roads_on_the_left not containing incoming roads and turn.roads_on_the_right not containing outgoing roads on two-way roads [#5128](https://github.com/Project-OSRM/osrm-backend/issues/5128)
+    - Profile:
+      - ADDED: Profile debug script which fetches a way from OSM then outputs the result of the profile. [#5908](https://github.com/Project-OSRM/osrm-backend/pull/5908)
     - Infrastructure
       - CHANGED: Bundled protozero updated to v1.7.0. [#5858](https://github.com/Project-OSRM/osrm-backend/pull/5858)
-    - Features
-      - CHANGED: missing files list is included in exception message. [#5360](https://github.com/Project-OSRM/osrm-backend/pull/5360)
+    - Windows:
+      - FIXED: Fix bit-shift overflow in MLD partition step. [#5878](https://github.com/Project-OSRM/osrm-backend/pull/5878)
+      - FIXED: Fix vector bool permutation in graph contraction step [#5882](https://github.com/Project-OSRM/osrm-backend/pull/5882)
+    - API:
+      - FIXED: Undo libosrm API break by adding old interface as method overload [#5861](https://github.com/Project-OSRM/osrm-backend/pull/5861)
+      - FIXED: Fixed validation of sources/destinations when accessed via node bindings [#5595](https://github.com/Project-OSRM/osrm-backend/pull/5595)
 
 # 5.23.0
   - Changes from 5.22.0
@@ -85,7 +166,7 @@
 ](https://github.com/Project-OSRM/osrm-backend/pull/5076/)
       - CHANGED: Foot profile now blacklists barriers instead of whitelisting them [#5077
 ](https://github.com/Project-OSRM/osrm-backend/pull/5077/)
-      - CHANGED: Support maxlength and maxweight in car profile [#5101](https://github.com/Project-OSRM/osrm-backend/pull/5101]
+      - CHANGED: Support maxlength and maxweight in car profile [#5101](https://github.com/Project-OSRM/osrm-backend/pull/5101)
     - Bugfixes:
       - FIXED: collapsing of ExitRoundabout instructions [#5114](https://github.com/Project-OSRM/osrm-backend/issues/5114)
     - Misc:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e6feb6de9..41875bbef 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,7 @@
-cmake_minimum_required(VERSION 3.1)
+cmake_minimum_required(VERSION 3.2)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 
 if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR AND NOT MSVC_IDE)
   message(FATAL_ERROR "In-source builds are not allowed.
@@ -18,10 +21,11 @@ if (NOT WIN32 AND NOT DEFINED ENV{OSRM_BUILD_DIR})
   set(ENV{OSRM_BUILD_DIR} ${CMAKE_CURRENT_BINARY_DIR})
 endif()
 
-option(ENABLE_MASON "Use mason for dependencies" OFF)
+option(ENABLE_CONAN "Use conan for dependencies" OFF)
 option(ENABLE_CCACHE "Speed up incremental rebuilds via ccache" ON)
 option(BUILD_TOOLS "Build OSRM tools" OFF)
 option(BUILD_PACKAGE "Build OSRM package" OFF)
+option(BUILD_ROUTED "Build osrm-routed HTTP server" ON)
 option(ENABLE_ASSERTIONS "Use assertions in release mode" OFF)
 option(ENABLE_DEBUG_LOGGING "Use debug logging in release mode" OFF)
 option(ENABLE_COVERAGE "Build with coverage instrumentalisation" OFF)
@@ -31,27 +35,20 @@ option(ENABLE_FUZZING "Fuzz testing using LLVM's libFuzzer" OFF)
 option(ENABLE_GOLD_LINKER "Use GNU gold linker if available" ON)
 option(ENABLE_NODE_BINDINGS "Build NodeJs bindings" OFF)
 option(ENABLE_GLIBC_WORKAROUND "Workaround GLIBC symbol exports" OFF)
+option(ENABLE_CLANG_TIDY "Enables clang-tidy checks" OFF)
+
+if (ENABLE_CLANG_TIDY)
+  find_program(CLANG_TIDY_COMMAND NAMES clang-tidy)
+  if(NOT CLANG_TIDY_COMMAND)
+    message(FATAL_ERROR "ENABLE_CLANG_TIDY is ON but clang-tidy is not found!")
+  else()
+    message(STATUS "Found clang-tidy at ${CLANG_TIDY_COMMAND}")
+    set(CMAKE_CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND};--warnings-as-errors=*")
+  endif()
+endif()
 
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 
-if(ENABLE_MASON)
-  # versions in use
-  set(MASON_BOOST_VERSION "1.65.1")
-  set(MASON_EXPAT_VERSION "2.2.0")
-  set(MASON_LUA_VERSION "5.2.4")
-  set(MASON_BZIP2_VERSION "1.0.6")
-  set(MASON_TBB_VERSION "2017_U7")
-
-  message(STATUS "Enabling mason")
-
-  find_program(CURL_FOUND curl)
-  if(NOT CURL_FOUND)
-    message(FATAL_ERROR "curl command required with -DENABLE_MASON")
-  endif()
-
-  include(mason)
-endif()
-
 # be compatible with version handling before cmake 3.x
 if (POLICY CMP0048)
   cmake_policy(SET CMP0048 OLD)
@@ -132,7 +129,7 @@ endif()
 
 include_directories(BEFORE ${CMAKE_CURRENT_BINARY_DIR}/include/)
 include_directories(BEFORE ${CMAKE_CURRENT_SOURCE_DIR}/include/)
-include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2/)
+include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/sol2-3.3.0/include)
 include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/variant/include)
 
 set(BOOST_COMPONENTS date_time chrono filesystem iostreams program_options regex system thread unit_test_framework)
@@ -162,7 +159,11 @@ add_library(CONTRACTOR OBJECT ${ContractorGlob})
 add_library(UPDATER OBJECT ${UpdaterGlob})
 add_library(STORAGE OBJECT ${StorageGlob})
 add_library(ENGINE OBJECT ${EngineGlob})
-add_library(SERVER OBJECT ${ServerGlob})
+
+if (BUILD_ROUTED) 
+  add_library(SERVER OBJECT ${ServerGlob})
+  add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
+endif()
 
 set_target_properties(UTIL PROPERTIES LINKER_LANGUAGE CXX)
 
@@ -170,7 +171,6 @@ add_executable(osrm-extract src/tools/extract.cpp)
 add_executable(osrm-partition src/tools/partition.cpp)
 add_executable(osrm-customize src/tools/customize.cpp)
 add_executable(osrm-contract src/tools/contract.cpp)
-add_executable(osrm-routed src/tools/routed.cpp $<TARGET_OBJECTS:SERVER> $<TARGET_OBJECTS:UTIL>)
 add_executable(osrm-datastore src/tools/store.cpp $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm src/osrm/osrm.cpp $<TARGET_OBJECTS:ENGINE> $<TARGET_OBJECTS:STORAGE> $<TARGET_OBJECTS:MICROTAR> $<TARGET_OBJECTS:UTIL>)
 add_library(osrm_contract src/osrm/contractor.cpp $<TARGET_OBJECTS:CONTRACTOR> $<TARGET_OBJECTS:UTIL>)
@@ -201,13 +201,6 @@ if(ENABLE_GOLD_LINKER)
     endif()
 endif()
 
-# Disable LTO when mason+gcc is detected before testing for / setting any flags.
-# Mason builds libraries with Clang, mixing does not work in the context of lto.
-if(ENABLE_MASON AND CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND ENABLE_LTO)
-  set(ENABLE_LTO OFF)
-  message(WARNING "Mason and GCC's LTO not work together. Disabling LTO.")
-endif()
-
 # Explicitly set the build type to Release if no other type is specified
 # on the command line.  Without this, cmake defaults to an unoptimized,
 # non-debug build, which almost nobody wants.
@@ -308,9 +301,9 @@ if(CMAKE_BUILD_TYPE MATCHES Release OR CMAKE_BUILD_TYPE MATCHES MinRelSize OR CM
   endif()
 endif()
 
-if(UNIX AND NOT APPLE AND ENABLE_MASON AND (LTO_WORKS OR ENABLE_GOLD_LINKER))
-  message(WARNING "ENABLE_MASON and ENABLE_LTO/ENABLE_GOLD_LINKER may not work on all linux systems currently")
-  message(WARNING "For more details see: https://github.com/Project-OSRM/osrm-backend/issues/3202")
+# TODO: this was added for Mason, we are not sure if it is true after migration to Conan
+if(UNIX AND NOT APPLE AND ENABLE_CONAN AND (LTO_WORKS OR ENABLE_GOLD_LINKER))
+  message(WARNING "ENABLE_CONAN and ENABLE_LTO/ENABLE_GOLD_LINKER may not work on all linux systems currently")
 endif()
 
 set(MAYBE_COVERAGE_LIBRARIES "")
@@ -323,11 +316,14 @@ if (ENABLE_COVERAGE)
   set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -ftest-coverage -fprofile-arcs")
 endif()
 
+
 if (ENABLE_SANITIZER)
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
-  set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -fsanitize=address")
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -fsanitize=address")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -fsanitize=address")
+  set(SANITIZER_FLAGS "-g -fsanitize=address -fsanitize-address-use-after-scope -fsanitize=undefined -fno-omit-frame-pointer")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${SANITIZER_FLAGS}")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${SANITIZER_FLAGS}")
+  set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} ${SANITIZER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${SANITIZER_FLAGS}")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${SANITIZER_FLAGS}")
 endif()
 
 # Configuring compilers
@@ -360,7 +356,6 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Intel")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-intel -wd10237 -Wall -ipo -fPIC")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
   # using Visual Studio C++
-  set(BOOST_COMPONENTS ${BOOST_COMPONENTS} zlib)
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj") # avoid compiler error C1128 from scripting_environment_lua.cpp
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /DWIN32_LEAN_AND_MEAN") # avoid compiler error C2011 from dual #include of winsock.h and winsock2.h
   add_dependency_defines(-DBOOST_LIB_DIAGNOSTIC)
@@ -397,16 +392,13 @@ set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
 
 # Activate C++1y
 if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14")
-  set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -std=c++14")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+  set(OSRM_CXXFLAGS "${OSRM_CXXFLAGS} -std=c++17")
 endif()
 
 # Configuring other platform dependencies
 if(APPLE)
-  set(CMAKE_OSX_DEPLOYMENT_TARGET "10.10")
   execute_process(COMMAND xcrun --sdk macosx --show-sdk-path OUTPUT_VARIABLE CMAKE_OSX_SYSROOT OUTPUT_STRIP_TRAILING_WHITESPACE)
-  set(CMAKE_OSX_ARCHITECTURES "x86_64")
-  message(STATUS "Set Architecture to x64 on OS X")
   exec_program(uname ARGS -v  OUTPUT_VARIABLE DARWIN_VERSION)
   string(REGEX MATCH "[0-9]+" DARWIN_VERSION ${DARWIN_VERSION})
   if(OSXLIBSTD)
@@ -433,7 +425,7 @@ include_directories(SYSTEM ${MICROTAR_INCLUDE_DIR})
 
 set(MBXGEOM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/geometry.hpp-0.9.2/include")
 include_directories(SYSTEM ${MBXGEOM_INCLUDE_DIR})
-set(CHEAPRULER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/cheap-ruler-cpp-2.5.4/include")
+set(CHEAPRULER_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/cheap-ruler-cpp-2778eb8/include")
 include_directories(SYSTEM ${CHEAPRULER_INCLUDE_DIR})
 
 add_library(MICROTAR OBJECT "${CMAKE_CURRENT_SOURCE_DIR}/third_party/microtar/src/microtar.c")
@@ -445,83 +437,98 @@ include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR})
 set(VTZERO_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/vtzero/include")
 include_directories(SYSTEM ${VTZERO_INCLUDE_DIR})
 
+set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "Disable the build of Flatbuffers tests and samples.")
 set(FLATBUFFERS_SRC_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers")
 set(FLATBUFFERS_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/third_party/flatbuffers/include")
-include_directories(${FLATBUFFERS_INCLUDE_DIR})
+include_directories(SYSTEM ${FLATBUFFERS_INCLUDE_DIR})
 add_subdirectory(${FLATBUFFERS_SRC_DIR}
         ${CMAKE_CURRENT_BINARY_DIR}/flatbuffers-build
         EXCLUDE_FROM_ALL)
 
-# if mason is enabled no find_package calls are made
-# to ensure that we are only compiling and linking against
-# fully portable mason packages
-if(ENABLE_MASON)
-  message(STATUS "Installing dependencies via mason")
+# see https://stackoverflow.com/questions/70898030/boost-link-error-using-conan-find-package
+if (MSVC)
+  add_definitions(-DBOOST_ALL_NO_LIB)
+endif()
+
+if(ENABLE_CONAN)
+  message(STATUS "Installing dependencies via Conan")
+
+  # Conan will generate Find*.cmake files to build directory, so we use them with the highest priority 
+  list(INSERT CMAKE_MODULE_PATH 0 ${CMAKE_BINARY_DIR})
+  list(INSERT CMAKE_PREFIX_PATH 0 ${CMAKE_BINARY_DIR})
+
+  include(${CMAKE_CURRENT_LIST_DIR}/cmake/conan.cmake)
+
+  set(CONAN_BOOST_VERSION 1.79.0)
+  set(CONAN_BZIP2_VERSION 1.0.8)
+  set(CONAN_EXPAT_VERSION 2.2.10)
+  set(CONAN_LUA_VERSION 5.4.4)
+  set(CONAN_TBB_VERSION 2020.3)
+  
+  set(CONAN_SYSTEM_INCLUDES ON)
+  
+  # TODO: 
+  # if we link TBB dynamically osrm-extract.exe finishes on the first access to any TBB symbol 
+  # with exit code = -1073741515, which means that program cannot load required DLL.
+  if (MSVC)
+    set(TBB_SHARED False)
+  else()
+    set(TBB_SHARED True)
+  endif()
+
+  conan_cmake_run(
+    REQUIRES 
+    boost/${CONAN_BOOST_VERSION}
+    bzip2/${CONAN_BZIP2_VERSION}
+    expat/${CONAN_EXPAT_VERSION}
+    lua/${CONAN_LUA_VERSION}
+    tbb/${CONAN_TBB_VERSION}
+    BASIC_SETUP 
+    BUILD missing 
+    GENERATORS cmake_find_package
+    KEEP_RPATHS
+    NO_OUTPUT_DIRS
+    OPTIONS boost:filesystem_version=3 # https://stackoverflow.com/questions/73392648/error-with-boost-filesystem-version-in-cmake
+            tbb:shared=${TBB_SHARED}
+  )
+
+  add_dependency_includes(${CONAN_INCLUDE_DIRS_BOOST})
+  add_dependency_includes(${CONAN_INCLUDE_DIRS_BZIP2})
+  add_dependency_includes(${CONAN_INCLUDE_DIRS_EXPAT})
+  add_dependency_includes(${CONAN_INCLUDE_DIRS_LUA})
+  add_dependency_includes(${CONAN_INCLUDE_DIRS_TBB})
 
   set(Boost_USE_STATIC_LIBS ON)
-  mason_use(boost VERSION ${MASON_BOOST_VERSION} HEADER_ONLY)
-  add_dependency_includes(${MASON_PACKAGE_boost_INCLUDE_DIRS})
-  mason_use(boost_libfilesystem VERSION ${MASON_BOOST_VERSION})
-  set(Boost_FILESYSTEM_LIBRARY ${MASON_PACKAGE_boost_libfilesystem_STATIC_LIBS})
-  mason_use(boost_libiostreams VERSION ${MASON_BOOST_VERSION})
-  set(Boost_IOSTREAMS_LIBRARY ${MASON_PACKAGE_boost_libiostreams_STATIC_LIBS})
-  mason_use(boost_libprogram_options VERSION ${MASON_BOOST_VERSION})
-  set(Boost_PROGRAM_OPTIONS_LIBRARY ${MASON_PACKAGE_boost_libprogram_options_STATIC_LIBS})
-  mason_use(boost_libregex VERSION ${MASON_BOOST_VERSION})
-  set(Boost_REGEX_LIBRARY ${MASON_PACKAGE_boost_libregex_STATIC_LIBS})
-  mason_use(boost_libtest VERSION ${MASON_BOOST_VERSION})
-  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY ${MASON_PACKAGE_boost_libtest_STATIC_LIBS})
-  mason_use(boost_libdate_time VERSION ${MASON_BOOST_VERSION})
-  set(Boost_DATE_TIME_LIBRARY ${MASON_PACKAGE_boost_libdate_time_STATIC_LIBS})
-  mason_use(boost_libthread VERSION ${MASON_BOOST_VERSION})
-  set(Boost_THREAD_LIBRARY ${MASON_PACKAGE_boost_libthread_STATIC_LIBS})
-  mason_use(boost_libsystem VERSION ${MASON_BOOST_VERSION})
-  set(Boost_SYSTEM_LIBRARY ${MASON_PACKAGE_boost_libsystem_STATIC_LIBS})
+  find_package(Boost REQUIRED EXACT ${CONAN_BOOST_VERSION} COMPONENTS ${BOOST_COMPONENTS})
+  set(Boost_DATE_TIME_LIBRARY "${Boost_date_time_LIB_TARGETS}")
+  set(Boost_CHRONO_LIBRARY "${Boost_chrono_LIB_TARGETS}")
+  set(Boost_PROGRAM_OPTIONS_LIBRARY "${Boost_program_options_LIB_TARGETS}")
+  set(Boost_FILESYSTEM_LIBRARY "${Boost_filesystem_LIB_TARGETS}")
+  set(Boost_IOSTREAMS_LIBRARY "${Boost_iostreams_LIB_TARGETS}")
+  set(Boost_THREAD_LIBRARY "${Boost_thread_LIB_TARGETS}")
+  set(Boost_SYSTEM_LIBRARY "${Boost_system_LIB_TARGETS}")
+  set(Boost_ZLIB_LIBRARY "${Boost_zlib_LIB_TARGETS}")
+  set(Boost_REGEX_LIBRARY "${Boost_regex_LIB_TARGETS}")
+  set(Boost_UNIT_TEST_FRAMEWORK_LIBRARY "${Boost_unit_test_framework_LIB_TARGETS}")
+  
+  find_package(BZip2 REQUIRED)
+  find_package(EXPAT REQUIRED)
+  find_package(lua REQUIRED)
+  set(LUA_LIBRARIES ${lua_LIBRARIES})
 
-  mason_use(expat VERSION ${MASON_EXPAT_VERSION})
-  add_dependency_includes(${MASON_PACKAGE_expat_INCLUDE_DIRS})
-  set(EXPAT_LIBRARIES ${MASON_PACKAGE_expat_STATIC_LIBS})
+  find_package(TBB REQUIRED)
 
-  mason_use(lua VERSION ${MASON_LUA_VERSION})
-  add_dependency_includes(${MASON_PACKAGE_lua_INCLUDE_DIRS})
-  set(USED_LUA_LIBRARIES ${MASON_PACKAGE_lua_STATIC_LIBS})
-
-  mason_use(bzip2 VERSION ${MASON_BZIP2_VERSION})
-  add_dependency_includes(${MASON_PACKAGE_bzip2_INCLUDE_DIRS})
-  set(BZIP2_LIBRARIES ${MASON_PACKAGE_bzip2_STATIC_LIBS})
-
-  mason_use(tbb VERSION ${MASON_TBB_VERSION})
-  add_dependency_includes(${MASON_PACKAGE_tbb_INCLUDE_DIRS})
-  set(TBB_LIBRARIES ${MASON_PACKAGE_tbb_LDFLAGS})
-
-  if(NOT MASON_PACKAGE_tbb_LIBRARY_DIRS)
-    message(FATAL_ERROR "MASON_PACKAGE_tbb_LIBRARY_DIRS is empty, rpath will not work")
-  endif()
-  set(TBB_LINKER_RPATHS "")
-  foreach(libpath ${MASON_PACKAGE_tbb_LIBRARY_DIRS})
-    set(TBB_LINKER_RPATHS "${TBB_LINKER_RPATHS} -Wl,-rpath -Wl,${libpath}")
-    file(GLOB TBBGlob ${libpath}/*.*)
-    install(FILES ${TBBGlob} DESTINATION lib)
-  endforeach()
-  if(APPLE)
-    set(LINKER_FLAGS "${TBB_LINKER_RPATHS} -Wl,-rpath -Wl,@loader_path")
-  elseif(UNIX)
-    set(LINKER_FLAGS "${TBB_LINKER_RPATHS} '-Wl,-rpath,$ORIGIN' -Wl,-z,origin")
-  endif()
-
-  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
-  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
-
-  # current mason packages target -D_GLIBCXX_USE_CXX11_ABI=0
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_GLIBCXX_USE_CXX11_ABI=0")
 
   # note: we avoid calling find_package(Osmium ...) here to ensure that the
-  # expat and bzip2 are used from mason rather than the system
+  # expat and bzip2 are used from conan rather than the system
   include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}/third_party/libosmium/include)
 else()
-
-  find_package(Boost 1.54 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+  if (BUILD_ROUTED)
+    # osrm-routed requires newer boost:asio 
+    find_package(Boost 1.70 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+  else()
+    find_package(Boost 1.60 REQUIRED COMPONENTS ${BOOST_COMPONENTS})
+  endif()
   add_dependency_includes(${Boost_INCLUDE_DIRS})
 
   find_package(TBB REQUIRED)
@@ -541,7 +548,6 @@ else()
     message(STATUS "Using Lua ${LUA_VERSION_STRING}")
   endif()
 
-  set(USED_LUA_LIBRARIES ${LUA_LIBRARIES})
   add_dependency_includes(${LUA_INCLUDE_DIR})
 
   # add a target to generate API documentation with Doxygen
@@ -575,19 +581,11 @@ if(ENABLE_CCACHE AND (CMAKE_CXX_COMPILER_ID MATCHES "Clang" OR CMAKE_CXX_COMPILE
   endif()
 endif()
 
-# even with mason builds we want to link to system zlib
+# even with conan builds we want to link to system zlib
 # to ensure that osrm binaries play well with other binaries like nodejs
 find_package(ZLIB REQUIRED)
 add_dependency_includes(${ZLIB_INCLUDE_DIRS})
 
-if(NOT WIN32 AND NOT Boost_USE_STATIC_LIBS)
-  add_dependency_defines(-DBOOST_TEST_DYN_LINK)
-endif()
-
-if(NOT WIN32 AND NOT Boost_USE_STATIC_LIBS)
-  add_dependency_defines(-DBOOST_TEST_DYN_LINK)
-endif()
-
 add_dependency_defines(-DBOOST_SPIRIT_USE_PHOENIX_V3)
 add_dependency_defines(-DBOOST_RESULT_OF_USE_DECLTYPE)
 add_dependency_defines(-DBOOST_FILESYSTEM_NO_DEPRECATED)
@@ -614,7 +612,9 @@ target_link_libraries(osrm-extract osrm_extract ${Boost_PROGRAM_OPTIONS_LIBRARY}
 target_link_libraries(osrm-partition osrm_partition ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-customize osrm_customize ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_link_libraries(osrm-contract osrm_contract ${Boost_PROGRAM_OPTIONS_LIBRARY})
-target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+if (BUILD_ROUTED)
+  target_link_libraries(osrm-routed osrm ${Boost_PROGRAM_OPTIONS_LIBRARY} ${OPTIONAL_SOCKET_LIBS} ${ZLIB_LIBRARY})
+endif()
 
 set(EXTRACTOR_LIBRARIES
     ${BZIP2_LIBRARIES}
@@ -622,7 +622,7 @@ set(EXTRACTOR_LIBRARIES
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${EXPAT_LIBRARIES}
-    ${USED_LUA_LIBRARIES}
+    ${LUA_LIBRARIES}
     ${OSMIUM_LIBRARIES}
     ${TBB_LIBRARIES}
     ${ZLIB_LIBRARY}
@@ -630,7 +630,7 @@ set(EXTRACTOR_LIBRARIES
 set(GUIDANCE_LIBRARIES
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${USED_LUA_LIBRARIES}
+    ${LUA_LIBRARIES}
     ${TBB_LIBRARIES}
     ${MAYBE_COVERAGE_LIBRARIES})
 set(PARTITIONER_LIBRARIES
@@ -656,7 +656,7 @@ set(UPDATER_LIBRARIES
 set(CONTRACTOR_LIBRARIES
     ${BOOST_BASE_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${USED_LUA_LIBRARIES}
+    ${LUA_LIBRARIES}
     ${TBB_LIBRARIES}
     ${MAYBE_RT_LIBRARY}
     ${MAYBE_COVERAGE_LIBRARIES})
@@ -697,7 +697,7 @@ install(TARGETS osrm-components DESTINATION bin)
 if(BUILD_TOOLS)
   message(STATUS "Activating OSRM internal tools")
   add_executable(osrm-io-benchmark src/tools/io-benchmark.cpp $<TARGET_OBJECTS:UTIL>)
-  target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES})
+  target_link_libraries(osrm-io-benchmark ${BOOST_BASE_LIBRARIES} ${TBB_LIBRARIES})
 
   install(TARGETS osrm-io-benchmark DESTINATION bin)
 endif()
@@ -719,7 +719,9 @@ set_property(TARGET osrm-extract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-partition PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-contract PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
 set_property(TARGET osrm-datastore PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
-set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+if (BUILD_ROUTED)
+  set_property(TARGET osrm-routed PROPERTY INSTALL_RPATH_USE_LINK_PATH TRUE)
+endif()
 
 file(GLOB VariantGlob third_party/variant/include/mapbox/*.hpp)
 file(GLOB FlatbuffersGlob third_party/flatbuffers/include/flatbuffers/*.h)
@@ -748,7 +750,9 @@ install(TARGETS osrm-partition DESTINATION bin)
 install(TARGETS osrm-customize DESTINATION bin)
 install(TARGETS osrm-contract DESTINATION bin)
 install(TARGETS osrm-datastore DESTINATION bin)
-install(TARGETS osrm-routed DESTINATION bin)
+if (BUILD_ROUTED)
+  install(TARGETS osrm-routed DESTINATION bin)
+endif()
 install(TARGETS osrm DESTINATION lib)
 install(TARGETS osrm_extract DESTINATION lib)
 install(TARGETS osrm_partition DESTINATION lib)
@@ -802,9 +806,26 @@ set(PKGCONFIG_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/include")
 list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}")
 list(APPEND DEPENDENCIES_INCLUDE_DIRS "${PKGCONFIG_INCLUDE_DIR}/osrm")
 JOIN("-I${DEPENDENCIES_INCLUDE_DIRS}" " -I" PKGCONFIG_OSRM_INCLUDE_FLAGS)
-JOIN("${ENGINE_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)
 
-configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in libosrm.pc @ONLY)
+# Boost uses imported targets, we need to use a generator expression to extract
+# the link libraries to be written to the pkg-config file.
+# Conan defines dependencies as CMake targets too, that's why we do the same for them.
+foreach(engine_lib ${ENGINE_LIBRARIES})
+  if("${engine_lib}" MATCHES "^Boost.*" OR "${engine_lib}" MATCHES "^CONAN_LIB.*")
+    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "$<TARGET_LINKER_FILE:${engine_lib}>")
+  else()
+    list(APPEND PKGCONFIG_DEPENDENT_LIBRARIES "${engine_lib}")
+  endif()
+endforeach(engine_lib)
+JOIN("${PKGCONFIG_DEPENDENT_LIBRARIES}" " " PKGCONFIG_OSRM_DEPENDENT_LIBRARIES)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkgconfig.in pkgconfig.configured @ONLY)
+file(GENERATE
+     OUTPUT
+     ${PROJECT_BINARY_DIR}/libosrm.pc
+     INPUT
+     ${PROJECT_BINARY_DIR}/pkgconfig.configured)
+
 install(FILES ${PROJECT_BINARY_DIR}/libosrm.pc DESTINATION ${PKGCONFIG_LIBRARY_DIR}/pkgconfig)
 
 # uninstall target
@@ -862,4 +883,4 @@ if (ENABLE_NODE_BINDINGS)
   endforeach()
   add_library(check-headers STATIC EXCLUDE_FROM_ALL ${sources})
   set_target_properties(check-headers PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${check_headers_dir})
-endif()
\ No newline at end of file
+endif()
diff --git a/README.md b/README.md
index 8435d558f..611b1b9c2 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 | Linux / macOS | Windows | Code Coverage |
 | ------------- | ------- | ------------- |
-| [![Travis](https://travis-ci.org/Project-OSRM/osrm-backend.png?branch=master)](https://travis-ci.org/Project-OSRM/osrm-backend) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/4iuo3s9gxprmcjjh)](https://ci.appveyor.com/project/DennisOSRM/osrm-backend) | [![Codecov](https://codecov.io/gh/Project-OSRM/osrm-backend/branch/master/graph/badge.svg)](https://codecov.io/gh/Project-OSRM/osrm-backend) |
+| [![osrm-backend CI](https://github.com/Project-OSRM/osrm-backend/actions/workflows/osrm-backend.yml/badge.svg)](https://github.com/Project-OSRM/osrm-backend/actions/workflows/osrm-backend.yml) | [![AppVeyor](https://ci.appveyor.com/api/projects/status/4iuo3s9gxprmcjjh)](https://ci.appveyor.com/project/DennisOSRM/osrm-backend) | [![Codecov](https://codecov.io/gh/Project-OSRM/osrm-backend/branch/master/graph/badge.svg)](https://codecov.io/gh/Project-OSRM/osrm-backend) |
 
 High performance routing engine written in C++14 designed to run on OpenStreetMap data.
 
diff --git a/appveyor-build.bat b/appveyor-build.bat
deleted file mode 100644
index c24f92382..000000000
--- a/appveyor-build.bat
+++ /dev/null
@@ -1,183 +0,0 @@
-@ECHO OFF
-SETLOCAL
-SET EL=0
-
-ECHO ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-SET PROJECT_DIR=%CD%
-ECHO PROJECT_DIR^: %PROJECT_DIR%
-ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%
-
-
-:: Check CMake version
-SET CMAKE_VERSION=3.16.3
-SET PATH=%PROJECT_DIR%\cmake-%CMAKE_VERSION%-win32-x86\bin;%PATH%
-ECHO cmake^: && cmake --version
-IF %ERRORLEVEL% NEQ 0 ECHO CMAKE not found && GOTO CMAKE_NOT_OK
-
-cmake --version | findstr /C:%CMAKE_VERSION% && GOTO CMAKE_OK
-
-:CMAKE_NOT_OK
-ECHO CMAKE NOT OK - downloading new CMake %CMAKE_VERSION%
-powershell Invoke-WebRequest https://cmake.org/files/v3.16/cmake-%CMAKE_VERSION%-win32-x86.zip -OutFile $env:PROJECT_DIR\cm.zip
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-IF NOT EXIST cmake-%CMAKE_VERSION%-win32-x86 7z -y x cm.zip | %windir%\system32\FIND "ing archive"
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-:CMAKE_OK
-ECHO CMAKE_OK
-cmake --version
-
-ECHO activating VS command prompt ...
-SET PATH=C:\Program Files (x86)\MSBuild\15.0\Bin;%PATH%
-CALL "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"
-
-ECHO platform^: %platform%
-
-ECHO cl.exe version
-cl
-ECHO msbuild version
-msbuild /version
-
-:: HARDCODE "x64" as it is uppercase on AppVeyor and download from S3 is case sensitive
-SET DEPSPKG=osrm-deps-win-x64-14.2-2019.01.7z
-
-:: local development
-ECHO.
-ECHO LOCAL_DEV^: %LOCAL_DEV%
-IF NOT DEFINED LOCAL_DEV SET LOCAL_DEV=0
-IF DEFINED LOCAL_DEV IF %LOCAL_DEV% EQU 1 IF EXIST %DEPSPKG% ECHO skipping deps download && GOTO SKIPDL
-
-IF EXIST %DEPSPKG% DEL %DEPSPKG%
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO downloading %DEPSPKG%
-powershell Invoke-WebRequest http://project-osrm.wolt.com/windows-build-deps/$env:DEPSPKG -OutFile $env:PROJECT_DIR\$env:DEPSPKG
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-:SKIPDL
-
-IF EXIST osrm-deps ECHO deleting osrm-deps... && RD /S /Q osrm-deps
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-IF EXIST build ECHO deleting build dir... && RD /S /Q build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-7z -y x %DEPSPKG% | %windir%\system32\FIND "ing archive"
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-::tree osrm-deps
-
-MKDIR build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-cd build
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-SET OSRMDEPSDIR=%PROJECT_DIR%/osrm-deps
-set PREFIX=%OSRMDEPSDIR%/libs
-set BOOST_ROOT=%OSRMDEPSDIR%
-set BOOST_LIBRARYDIR=%BOOST_ROOT%/lib
-set TBB_INSTALL_DIR=%OSRMDEPSDIR%
-REM set TBB_ARCH_PLATFORM=intel64/vc17
-
-ECHO OSRMDEPSDIR       ^: %OSRMDEPSDIR%
-ECHO PREFIX            ^: %PREFIX%
-ECHO BOOST_ROOT        ^: %BOOST_ROOT%
-ECHO BOOST_LIBRARYDIR  ^: %BOOST_LIBRARYDIR%
-ECHO TBB_INSTALL_DIR   ^: %TBB_INSTALL_DIR%
-REM ECHO TBB_ARCH_PLATFORM ^: %TBB_ARCH_PLATFORM%
-
-
-ECHO calling cmake ....
-cmake .. ^
--G "Visual Studio 16 2019" ^
--DBOOST_ROOT=%BOOST_ROOT% ^
--DBOOST_LIBRARYDIR=%BOOST_LIBRARYDIR% ^
--DBoost_ADDITIONAL_VERSIONS=1.73.0 ^
--DBoost_USE_MULTITHREADED=ON ^
--DBoost_USE_STATIC_LIBS=ON ^
--DEXPAT_INCLUDE_DIR=%OSRMDEPSDIR% ^
--DEXPAT_LIBRARY=%OSRMDEPSDIR%/lib/libexpat.lib ^
--DBZIP2_INCLUDE_DIR=%OSRMDEPSDIR% ^
--DBZIP2_LIBRARIES=%OSRMDEPSDIR%/lib/libbz2.lib ^
--DLUA_INCLUDE_DIR=%OSRMDEPSDIR% ^
--DLUA_LIBRARIES=%OSRMDEPSDIR%/lib/lua5.3.5.lib ^
--DZLIB_INCLUDE_DIR=%OSRMDEPSDIR% ^
--DZLIB_LIBRARY=%OSRMDEPSDIR%/lib/libz.lib ^
--DCMAKE_BUILD_TYPE=%CONFIGURATION% ^
--DCMAKE_INSTALL_PREFIX=%PREFIX%
-IF %ERRORLEVEL% NEQ 0 GOTO ERROR
-
-ECHO building ...
-msbuild OSRM.sln ^
-/p:Configuration=%Configuration% ^
-/p:Platform=x64 ^
-/t:rebuild ^
-/p:BuildInParallel=true ^
-/m:%NUMBER_OF_PROCESSORS% ^
-/toolsversion:Current ^
-/p:PlatformToolset=v142 ^
-/clp:Verbosity=normal ^
-/nologo ^
-/flp1:logfile=build_errors.txt;errorsonly ^
-/flp2:logfile=build_warnings.txt;warningsonly
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-CD %PROJECT_DIR%\build
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-SET PATH=%PROJECT_DIR%\osrm-deps\lib;%PATH%
-
-ECHO running extractor-tests.exe ...
-unit_tests\%Configuration%\extractor-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running engine-tests.exe ...
-unit_tests\%Configuration%\engine-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running util-tests.exe ...
-unit_tests\%Configuration%\util-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-ECHO running server-tests.exe ...
-unit_tests\%Configuration%\server-tests.exe
-IF %ERRORLEVEL% EQU 1 GOTO ERROR
-
-::TODO: CH processing sometimes mysteriously hangs, need to find why and enable tests below.
-::ECHO running library-tests.exe ...
-::SET test_region=monaco
-::SET test_region_ch=ch\monaco
-::SET test_region_corech=corech\monaco
-::SET test_region_mld=mld\monaco
-::SET test_osm=%test_region%.osm.pbf
-::IF NOT EXIST %test_osm% powershell Invoke-WebRequest http://project-osrm.wolt.com/testing/monaco.osm.pbf -OutFile %test_osm%
-::ECHO running %Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
-::%Configuration%\osrm-extract.exe
-::%Configuration%\osrm-extract.exe -p ../profiles/car.lua %test_osm%
-::MKDIR ch
-::XCOPY %test_region%.osrm.* ch\
-::XCOPY %test_region%.osrm ch\
-::MKDIR corech
-::XCOPY %test_region%.osrm.* corech\
-::XCOPY %test_region%.osrm corech\
-::MKDIR mld
-::XCOPY %test_region%.osrm.* mld\
-::XCOPY %test_region%.osrm mld\
-::%Configuration%\osrm-contract.exe %test_region_ch%.osrm
-::%Configuration%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
-::%Configuration%\osrm-partition.exe %test_region_mld%.osrm
-::%Configuration%\osrm-customize.exe %test_region_mld%.osrm
-::XCOPY /Y ch\*.* ..\test\data\ch\
-::XCOPY /Y corech\*.* ..\test\data\corech\
-::XCOPY /Y mld\*.* ..\test\data\mld\
-::unit_tests\%Configuration%\library-tests.exe
-
-:ERROR
-ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-ECHO ERRORLEVEL^: %ERRORLEVEL%
-SET EL=%ERRORLEVEL%
-
-:DONE
-ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-EXIT /b %EL%
diff --git a/appveyor.yml b/appveyor.yml
index 3fbf89cb6..a1849a9e7 100644
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -1,15 +1,3 @@
-environment:
-  matrix:
-  - configuration: Release
-#  - configuration: Debug
-
-install:
-  - ps: Install-Product node 6
-
-# scripts that are called at very beginning, before repo cloning
-init:
-  - git config --global core.autocrlf input
-
 os: Visual Studio 2019
 
 # clone directory
@@ -17,20 +5,11 @@ clone_folder: c:\projects\osrm
 
 platform: x64
 
+# no-op for the time being until someone with access to GitHub checks settings will remove integration with AppVeyor
+# https://github.com/Project-OSRM/osrm-backend/pull/6312#issuecomment-1217237055 
 build_script:
-  - CALL appveyor-build.bat
-
-before_test:
-  - node --version
-  - npm --version
-  - npm install --ignore-scripts
-  - npm link --ignore-scripts
-  - SET PATH=%CD%\osrm-deps\lib;%PATH%
-  - SET OSRM_BUILD_DIR=build\%Configuration%
-# TODO tests fail with "JavaScript heap out of memory", need a better host?
-#  - npm test
+  - EXIT 0
 
 branches:
   only:
     - master
-
diff --git a/cmake/FindLua.cmake b/cmake/FindLua.cmake
index 2b732ca21..237dca8e6 100644
--- a/cmake/FindLua.cmake
+++ b/cmake/FindLua.cmake
@@ -44,7 +44,7 @@ unset(_lua_append_versions)
 
 # this is a function only to have all the variables inside go away automatically
 function(_lua_set_version_vars)
-    set(LUA_VERSIONS5 5.3 5.2 5.1 5.0)
+    set(LUA_VERSIONS5 5.4 5.3 5.2 5.1 5.0)
 
     if (Lua_FIND_VERSION_EXACT)
         if (Lua_FIND_VERSION_COUNT GREATER 1)
diff --git a/cmake/conan.cmake b/cmake/conan.cmake
new file mode 100644
index 000000000..4f5f67e74
--- /dev/null
+++ b/cmake/conan.cmake
@@ -0,0 +1,1026 @@
+# The MIT License (MIT)
+
+# Copyright (c) 2018 JFrog
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+
+
+# This file comes from: https://github.com/conan-io/cmake-conan. Please refer
+# to this repository for issues and documentation.
+
+# Its purpose is to wrap and launch Conan C/C++ Package Manager when cmake is called.
+# It will take CMake current settings (os, compiler, compiler version, architecture)
+# and translate them to conan settings for installing and retrieving dependencies.
+
+# It is intended to facilitate developers building projects that have conan dependencies,
+# but it is only necessary on the end-user side. It is not necessary to create conan
+# packages, in fact it shouldn't be use for that. Check the project documentation.
+
+# version: 0.18.1
+
+include(CMakeParseArguments)
+
+function(_get_msvc_ide_version result)
+    set(${result} "" PARENT_SCOPE)
+    if(NOT MSVC_VERSION VERSION_LESS 1400 AND MSVC_VERSION VERSION_LESS 1500)
+        set(${result} 8 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1500 AND MSVC_VERSION VERSION_LESS 1600)
+        set(${result} 9 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1600 AND MSVC_VERSION VERSION_LESS 1700)
+        set(${result} 10 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1700 AND MSVC_VERSION VERSION_LESS 1800)
+        set(${result} 11 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1800 AND MSVC_VERSION VERSION_LESS 1900)
+        set(${result} 12 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1900 AND MSVC_VERSION VERSION_LESS 1910)
+        set(${result} 14 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1910 AND MSVC_VERSION VERSION_LESS 1920)
+        set(${result} 15 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1920 AND MSVC_VERSION VERSION_LESS 1930)
+        set(${result} 16 PARENT_SCOPE)
+    elseif(NOT MSVC_VERSION VERSION_LESS 1930 AND MSVC_VERSION VERSION_LESS 1940)
+        set(${result} 17 PARENT_SCOPE)
+    else()
+        message(FATAL_ERROR "Conan: Unknown MSVC compiler version [${MSVC_VERSION}]")
+    endif()
+endfunction()
+
+macro(_conan_detect_build_type)
+    conan_parse_arguments(${ARGV})
+
+    if(ARGUMENTS_BUILD_TYPE)
+        set(_CONAN_SETTING_BUILD_TYPE ${ARGUMENTS_BUILD_TYPE})
+    elseif(CMAKE_BUILD_TYPE)
+        set(_CONAN_SETTING_BUILD_TYPE ${CMAKE_BUILD_TYPE})
+    else()
+        message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)")
+    endif()
+
+    string(TOUPPER ${_CONAN_SETTING_BUILD_TYPE} _CONAN_SETTING_BUILD_TYPE_UPPER)
+    if (_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "DEBUG")
+        set(_CONAN_SETTING_BUILD_TYPE "Debug")
+    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELEASE")
+        set(_CONAN_SETTING_BUILD_TYPE "Release")
+    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "RELWITHDEBINFO")
+        set(_CONAN_SETTING_BUILD_TYPE "RelWithDebInfo")
+    elseif(_CONAN_SETTING_BUILD_TYPE_UPPER STREQUAL "MINSIZEREL")
+        set(_CONAN_SETTING_BUILD_TYPE "MinSizeRel")
+    endif()
+endmacro()
+
+macro(_conan_check_system_name)
+    #handle -s os setting
+    if(CMAKE_SYSTEM_NAME AND NOT CMAKE_SYSTEM_NAME STREQUAL "Generic")
+        #use default conan os setting if CMAKE_SYSTEM_NAME is not defined
+        set(CONAN_SYSTEM_NAME ${CMAKE_SYSTEM_NAME})
+        if(${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
+            set(CONAN_SYSTEM_NAME Macos)
+        endif()
+        if(${CMAKE_SYSTEM_NAME} STREQUAL "QNX")
+            set(CONAN_SYSTEM_NAME Neutrino)
+        endif()
+        set(CONAN_SUPPORTED_PLATFORMS Windows Linux Macos Android iOS FreeBSD WindowsStore WindowsCE watchOS tvOS FreeBSD SunOS AIX Arduino Emscripten Neutrino)
+        list (FIND CONAN_SUPPORTED_PLATFORMS "${CONAN_SYSTEM_NAME}" _index)
+        if (${_index} GREATER -1)
+            #check if the cmake system is a conan supported one
+            set(_CONAN_SETTING_OS ${CONAN_SYSTEM_NAME})
+        else()
+            message(FATAL_ERROR "cmake system ${CONAN_SYSTEM_NAME} is not supported by conan. Use one of ${CONAN_SUPPORTED_PLATFORMS}")
+        endif()
+    endif()
+endmacro()
+
+macro(_conan_check_language)
+    get_property(_languages GLOBAL PROPERTY ENABLED_LANGUAGES)
+    if (";${_languages};" MATCHES ";CXX;")
+        set(LANGUAGE CXX)
+        set(USING_CXX 1)
+    elseif (";${_languages};" MATCHES ";C;")
+        set(LANGUAGE C)
+        set(USING_CXX 0)
+    else ()
+        message(FATAL_ERROR "Conan: Neither C or C++ was detected as a language for the project. Unabled to detect compiler version.")
+    endif()
+endmacro()
+
+macro(_conan_detect_compiler)
+
+    conan_parse_arguments(${ARGV})
+
+    if(ARGUMENTS_ARCH)
+        set(_CONAN_SETTING_ARCH ${ARGUMENTS_ARCH})
+    endif()
+
+    if(USING_CXX)
+        set(_CONAN_SETTING_COMPILER_CPPSTD ${CMAKE_CXX_STANDARD})
+    endif()
+
+    if (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL GNU)
+        # using GCC
+        # TODO: Handle other params
+        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
+        list(GET VERSION_LIST 0 MAJOR)
+        list(GET VERSION_LIST 1 MINOR)
+        set(COMPILER_VERSION ${MAJOR}.${MINOR})
+        if(${MAJOR} GREATER 4)
+            set(COMPILER_VERSION ${MAJOR})
+        endif()
+        set(_CONAN_SETTING_COMPILER gcc)
+        set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
+        if (USING_CXX)
+            conan_cmake_detect_unix_libcxx(_LIBCXX)
+            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
+        endif ()
+    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Intel)
+        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
+        list(GET VERSION_LIST 0 MAJOR)
+        list(GET VERSION_LIST 1 MINOR)
+        set(COMPILER_VERSION ${MAJOR}.${MINOR})
+        set(_CONAN_SETTING_COMPILER intel)
+        set(_CONAN_SETTING_COMPILER_VERSION ${COMPILER_VERSION})
+        if (USING_CXX)
+            conan_cmake_detect_unix_libcxx(_LIBCXX)
+            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
+        endif ()
+    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL AppleClang)
+        # using AppleClang
+        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
+        list(GET VERSION_LIST 0 MAJOR)
+        list(GET VERSION_LIST 1 MINOR)
+        set(_CONAN_SETTING_COMPILER apple-clang)
+        set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
+        if (USING_CXX)
+            conan_cmake_detect_unix_libcxx(_LIBCXX)
+            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
+        endif ()
+    elseif (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang
+                AND NOT "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" 
+                AND NOT "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC")
+
+        string(REPLACE "." ";" VERSION_LIST ${CMAKE_${LANGUAGE}_COMPILER_VERSION})
+        list(GET VERSION_LIST 0 MAJOR)
+        list(GET VERSION_LIST 1 MINOR)
+        set(_CONAN_SETTING_COMPILER clang)
+        set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR}.${MINOR})
+        if(APPLE)
+            cmake_policy(GET CMP0025 APPLE_CLANG_POLICY)
+            if(NOT APPLE_CLANG_POLICY STREQUAL NEW)
+                message(STATUS "Conan: APPLE and Clang detected. Assuming apple-clang compiler. Set CMP0025 to avoid it")
+                set(_CONAN_SETTING_COMPILER apple-clang)
+            endif()
+        endif()
+        if(${_CONAN_SETTING_COMPILER} STREQUAL clang AND ${MAJOR} GREATER 7)
+            set(_CONAN_SETTING_COMPILER_VERSION ${MAJOR})
+        endif()
+        if (USING_CXX)
+            conan_cmake_detect_unix_libcxx(_LIBCXX)
+            set(_CONAN_SETTING_COMPILER_LIBCXX ${_LIBCXX})
+        endif ()
+    elseif(${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL MSVC
+                OR (${CMAKE_${LANGUAGE}_COMPILER_ID} STREQUAL Clang 
+                    AND "${CMAKE_${LANGUAGE}_COMPILER_FRONTEND_VARIANT}" STREQUAL "MSVC" 
+                    AND "${CMAKE_${LANGUAGE}_SIMULATE_ID}" STREQUAL "MSVC"))
+
+        set(_VISUAL "Visual Studio")
+        _get_msvc_ide_version(_VISUAL_VERSION)
+        if("${_VISUAL_VERSION}" STREQUAL "")
+            message(FATAL_ERROR "Conan: Visual Studio not recognized")
+        else()
+            set(_CONAN_SETTING_COMPILER ${_VISUAL})
+            set(_CONAN_SETTING_COMPILER_VERSION ${_VISUAL_VERSION})
+        endif()
+
+        if(NOT _CONAN_SETTING_ARCH)
+            if (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "64")
+                set(_CONAN_SETTING_ARCH x86_64)
+            elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "^ARM")
+                message(STATUS "Conan: Using default ARM architecture from MSVC")
+                set(_CONAN_SETTING_ARCH armv6)
+            elseif (MSVC_${LANGUAGE}_ARCHITECTURE_ID MATCHES "86")
+                set(_CONAN_SETTING_ARCH x86)
+            else ()
+                message(FATAL_ERROR "Conan: Unknown MSVC architecture [${MSVC_${LANGUAGE}_ARCHITECTURE_ID}]")
+            endif()
+        endif()
+
+        conan_cmake_detect_vs_runtime(_vs_runtime ${ARGV})
+        message(STATUS "Conan: Detected VS runtime: ${_vs_runtime}")
+        set(_CONAN_SETTING_COMPILER_RUNTIME ${_vs_runtime})
+
+        if (CMAKE_GENERATOR_TOOLSET)
+            set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
+        elseif(CMAKE_VS_PLATFORM_TOOLSET AND (CMAKE_GENERATOR STREQUAL "Ninja"))
+            set(_CONAN_SETTING_COMPILER_TOOLSET ${CMAKE_VS_PLATFORM_TOOLSET})
+        endif()
+        else()
+        message(FATAL_ERROR "Conan: compiler setup not recognized")
+    endif()
+
+endmacro()
+
+function(conan_cmake_settings result)
+    #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER})
+    #message(STATUS "COMPILER " ${CMAKE_CXX_COMPILER_ID})
+    #message(STATUS "VERSION " ${CMAKE_CXX_COMPILER_VERSION})
+    #message(STATUS "FLAGS " ${CMAKE_LANG_FLAGS})
+    #message(STATUS "LIB ARCH " ${CMAKE_CXX_LIBRARY_ARCHITECTURE})
+    #message(STATUS "BUILD TYPE " ${CMAKE_BUILD_TYPE})
+    #message(STATUS "GENERATOR " ${CMAKE_GENERATOR})
+    #message(STATUS "GENERATOR WIN64 " ${CMAKE_CL_64})
+
+    message(STATUS "Conan: Automatic detection of conan settings from cmake")
+
+    conan_parse_arguments(${ARGV})
+
+    _conan_detect_build_type(${ARGV})
+
+    _conan_check_system_name()
+
+    _conan_check_language()
+
+    _conan_detect_compiler(${ARGV})
+
+    # If profile is defined it is used
+    if(CMAKE_BUILD_TYPE STREQUAL "Debug" AND ARGUMENTS_DEBUG_PROFILE)
+        set(_APPLIED_PROFILES ${ARGUMENTS_DEBUG_PROFILE})
+    elseif(CMAKE_BUILD_TYPE STREQUAL "Release" AND ARGUMENTS_RELEASE_PROFILE)
+        set(_APPLIED_PROFILES ${ARGUMENTS_RELEASE_PROFILE})
+    elseif(CMAKE_BUILD_TYPE STREQUAL "RelWithDebInfo" AND ARGUMENTS_RELWITHDEBINFO_PROFILE)
+        set(_APPLIED_PROFILES ${ARGUMENTS_RELWITHDEBINFO_PROFILE})
+    elseif(CMAKE_BUILD_TYPE STREQUAL "MinSizeRel" AND ARGUMENTS_MINSIZEREL_PROFILE)
+        set(_APPLIED_PROFILES ${ARGUMENTS_MINSIZEREL_PROFILE})
+    elseif(ARGUMENTS_PROFILE)
+        set(_APPLIED_PROFILES ${ARGUMENTS_PROFILE})
+    endif()
+
+    foreach(ARG ${_APPLIED_PROFILES})
+        set(_SETTINGS ${_SETTINGS} -pr=${ARG})
+    endforeach()
+    foreach(ARG ${ARGUMENTS_PROFILE_BUILD})
+        conan_check(VERSION 1.24.0 REQUIRED DETECT_QUIET)
+        set(_SETTINGS ${_SETTINGS} -pr:b=${ARG})
+    endforeach()
+
+    if(NOT _SETTINGS OR ARGUMENTS_PROFILE_AUTO STREQUAL "ALL")
+        set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
+                                   compiler.runtime compiler.libcxx compiler.toolset)
+    endif()
+
+    # remove any manually specified settings from the autodetected settings
+    foreach(ARG ${ARGUMENTS_SETTINGS})
+        string(REGEX MATCH "[^=]*" MANUAL_SETTING "${ARG}")
+        message(STATUS "Conan: ${MANUAL_SETTING} was added as an argument. Not using the autodetected one.")
+        list(REMOVE_ITEM ARGUMENTS_PROFILE_AUTO "${MANUAL_SETTING}")
+    endforeach()
+
+    # Automatic from CMake
+    foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
+        string(TOUPPER ${ARG} _arg_name)
+        string(REPLACE "." "_" _arg_name ${_arg_name})
+        if(_CONAN_SETTING_${_arg_name})
+            set(_SETTINGS ${_SETTINGS} -s ${ARG}=${_CONAN_SETTING_${_arg_name}})
+        endif()
+    endforeach()
+
+    foreach(ARG ${ARGUMENTS_SETTINGS})
+        set(_SETTINGS ${_SETTINGS} -s ${ARG})
+    endforeach()
+
+    message(STATUS "Conan: Settings= ${_SETTINGS}")
+
+    set(${result} ${_SETTINGS} PARENT_SCOPE)
+endfunction()
+
+
+function(conan_cmake_detect_unix_libcxx result)
+    # Take into account any -stdlib in compile options
+    get_directory_property(compile_options DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
+    string(GENEX_STRIP "${compile_options}" compile_options)
+
+    # Take into account any _GLIBCXX_USE_CXX11_ABI in compile definitions
+    get_directory_property(defines DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS)
+    string(GENEX_STRIP "${defines}" defines)
+
+    foreach(define ${defines})
+        if(define MATCHES "_GLIBCXX_USE_CXX11_ABI")
+            if(define MATCHES "^-D")
+                set(compile_options ${compile_options} "${define}")
+            else()
+                set(compile_options ${compile_options} "-D${define}")
+            endif()
+        endif()
+    endforeach()
+
+    # add additional compiler options ala cmRulePlaceholderExpander::ExpandRuleVariable
+    set(EXPAND_CXX_COMPILER ${CMAKE_CXX_COMPILER})
+    if(CMAKE_CXX_COMPILER_ARG1)
+        # CMake splits CXX="foo bar baz" into CMAKE_CXX_COMPILER="foo", CMAKE_CXX_COMPILER_ARG1="bar baz"
+        # without this, ccache, winegcc, or other wrappers might lose all their arguments
+        separate_arguments(SPLIT_CXX_COMPILER_ARG1 NATIVE_COMMAND ${CMAKE_CXX_COMPILER_ARG1})
+        list(APPEND EXPAND_CXX_COMPILER ${SPLIT_CXX_COMPILER_ARG1})
+    endif()
+
+    if(CMAKE_CXX_COMPILE_OPTIONS_TARGET AND CMAKE_CXX_COMPILER_TARGET)
+        # without --target= we may be calling the wrong underlying GCC
+        list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_TARGET}${CMAKE_CXX_COMPILER_TARGET}")
+    endif()
+
+    if(CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN AND CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN)
+        list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_EXTERNAL_TOOLCHAIN}${CMAKE_CXX_COMPILER_EXTERNAL_TOOLCHAIN}")
+    endif()
+
+    if(CMAKE_CXX_COMPILE_OPTIONS_SYSROOT)
+        # without --sysroot= we may find the wrong #include <string>
+        if(CMAKE_SYSROOT_COMPILE)
+            list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT_COMPILE}")
+        elseif(CMAKE_SYSROOT)
+            list(APPEND EXPAND_CXX_COMPILER "${CMAKE_CXX_COMPILE_OPTIONS_SYSROOT}${CMAKE_SYSROOT}")
+        endif()
+    endif()
+
+    separate_arguments(SPLIT_CXX_FLAGS NATIVE_COMMAND ${CMAKE_CXX_FLAGS})
+
+    if(CMAKE_OSX_SYSROOT)
+        set(xcode_sysroot_option "--sysroot=${CMAKE_OSX_SYSROOT}")
+    endif()
+
+    execute_process(
+        COMMAND ${CMAKE_COMMAND} -E echo "#include <string>"
+        COMMAND ${EXPAND_CXX_COMPILER} ${SPLIT_CXX_FLAGS} -x c++ ${xcode_sysroot_option} ${compile_options} -E -dM -
+        OUTPUT_VARIABLE string_defines
+    )
+
+    if(string_defines MATCHES "#define __GLIBCXX__")
+        # Allow -D_GLIBCXX_USE_CXX11_ABI=ON/OFF as argument to cmake
+        if(DEFINED _GLIBCXX_USE_CXX11_ABI)
+            if(_GLIBCXX_USE_CXX11_ABI)
+                set(${result} libstdc++11 PARENT_SCOPE)
+                return()
+            else()
+                set(${result} libstdc++ PARENT_SCOPE)
+                return()
+            endif()
+        endif()
+
+        if(string_defines MATCHES "#define _GLIBCXX_USE_CXX11_ABI 1\n")
+            set(${result} libstdc++11 PARENT_SCOPE)
+        else()
+            # Either the compiler is missing the define because it is old, and so
+            # it can't use the new abi, or the compiler was configured to use the
+            # old abi by the user or distro (e.g. devtoolset on RHEL/CentOS)
+            set(${result} libstdc++ PARENT_SCOPE)
+        endif()
+    else()
+        set(${result} libc++ PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(conan_cmake_detect_vs_runtime result)
+
+    conan_parse_arguments(${ARGV})
+    if(ARGUMENTS_BUILD_TYPE)
+        set(build_type "${ARGUMENTS_BUILD_TYPE}")
+    elseif(CMAKE_BUILD_TYPE)
+        set(build_type "${CMAKE_BUILD_TYPE}")
+    else()
+        message(FATAL_ERROR "Please specify in command line CMAKE_BUILD_TYPE (-DCMAKE_BUILD_TYPE=Release)")
+    endif()
+
+    if(build_type)
+        string(TOUPPER "${build_type}" build_type)
+    endif()
+    set(variables CMAKE_CXX_FLAGS_${build_type} CMAKE_C_FLAGS_${build_type} CMAKE_CXX_FLAGS CMAKE_C_FLAGS)
+    foreach(variable ${variables})
+        if(NOT "${${variable}}" STREQUAL "")
+            string(REPLACE " " ";" flags "${${variable}}")
+            foreach (flag ${flags})
+                if("${flag}" STREQUAL "/MD" OR "${flag}" STREQUAL "/MDd" OR "${flag}" STREQUAL "/MT" OR "${flag}" STREQUAL "/MTd")
+                    string(SUBSTRING "${flag}" 1 -1 runtime)
+                    set(${result} "${runtime}" PARENT_SCOPE)
+                    return()
+                endif()
+            endforeach()
+        endif()
+    endforeach()
+    if("${build_type}" STREQUAL "DEBUG")
+        set(${result} "MDd" PARENT_SCOPE)
+    else()
+        set(${result} "MD" PARENT_SCOPE)
+    endif()
+endfunction()
+
+function(_collect_settings result)
+    set(ARGUMENTS_PROFILE_AUTO arch build_type compiler compiler.version
+                            compiler.runtime compiler.libcxx compiler.toolset
+                            compiler.cppstd)
+    foreach(ARG ${ARGUMENTS_PROFILE_AUTO})
+        string(TOUPPER ${ARG} _arg_name)
+        string(REPLACE "." "_" _arg_name ${_arg_name})
+        if(_CONAN_SETTING_${_arg_name})
+            set(detected_setings ${detected_setings} ${ARG}=${_CONAN_SETTING_${_arg_name}})
+        endif()
+    endforeach()
+    set(${result} ${detected_setings} PARENT_SCOPE)
+endfunction()
+
+function(conan_cmake_autodetect detected_settings)
+    _conan_detect_build_type(${ARGV})
+    _conan_check_system_name()
+    _conan_check_language()
+    _conan_detect_compiler(${ARGV})
+    _collect_settings(collected_settings)
+    set(${detected_settings} ${collected_settings} PARENT_SCOPE)
+endfunction()
+
+macro(conan_parse_arguments)
+  set(options BASIC_SETUP CMAKE_TARGETS UPDATE KEEP_RPATHS NO_LOAD NO_OUTPUT_DIRS OUTPUT_QUIET NO_IMPORTS SKIP_STD)
+  set(oneValueArgs CONANFILE  ARCH BUILD_TYPE INSTALL_FOLDER OUTPUT_FOLDER CONAN_COMMAND)
+  set(multiValueArgs DEBUG_PROFILE RELEASE_PROFILE RELWITHDEBINFO_PROFILE MINSIZEREL_PROFILE
+                     PROFILE REQUIRES OPTIONS IMPORTS SETTINGS BUILD ENV GENERATORS PROFILE_AUTO
+                     INSTALL_ARGS CONFIGURATION_TYPES PROFILE_BUILD BUILD_REQUIRES)
+  cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+endmacro()
+
+function(old_conan_cmake_install)
+    # Calls "conan install"
+    # Argument BUILD is equivalant to --build={missing, PkgName,...} or
+    # --build when argument is 'BUILD all' (which builds all packages from source)
+    # Argument CONAN_COMMAND, to specify the conan path, e.g. in case of running from source
+    # cmake does not identify conan as command, even if it is +x and it is in the path
+    conan_parse_arguments(${ARGV})
+
+    if(CONAN_CMAKE_MULTI)
+        set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake_multi)
+    else()
+        set(ARGUMENTS_GENERATORS ${ARGUMENTS_GENERATORS} cmake)
+    endif()
+
+    set(CONAN_BUILD_POLICY "")
+    foreach(ARG ${ARGUMENTS_BUILD})
+        if(${ARG} STREQUAL "all")
+            set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build)
+            break()
+        else()
+            set(CONAN_BUILD_POLICY ${CONAN_BUILD_POLICY} --build=${ARG})
+        endif()
+    endforeach()
+    if(ARGUMENTS_CONAN_COMMAND)
+       set(CONAN_CMD ${ARGUMENTS_CONAN_COMMAND})
+    else()
+        conan_check(REQUIRED)
+    endif()
+    set(CONAN_OPTIONS "")
+    if(ARGUMENTS_CONANFILE)
+      if(IS_ABSOLUTE ${ARGUMENTS_CONANFILE})
+          set(CONANFILE ${ARGUMENTS_CONANFILE})
+      else()
+          set(CONANFILE ${CMAKE_CURRENT_SOURCE_DIR}/${ARGUMENTS_CONANFILE})
+      endif()
+    else()
+      set(CONANFILE ".")
+    endif()
+    foreach(ARG ${ARGUMENTS_OPTIONS})
+      set(CONAN_OPTIONS ${CONAN_OPTIONS} -o=${ARG})
+    endforeach()
+    if(ARGUMENTS_UPDATE)
+      set(CONAN_INSTALL_UPDATE --update)
+    endif()
+    if(ARGUMENTS_NO_IMPORTS)
+      set(CONAN_INSTALL_NO_IMPORTS --no-imports)
+    endif()
+    set(CONAN_INSTALL_FOLDER "")
+    if(ARGUMENTS_INSTALL_FOLDER)
+      set(CONAN_INSTALL_FOLDER -if=${ARGUMENTS_INSTALL_FOLDER})
+    endif()
+    set(CONAN_OUTPUT_FOLDER "")
+    if(ARGUMENTS_OUTPUT_FOLDER)
+      set(CONAN_OUTPUT_FOLDER -of=${ARGUMENTS_OUTPUT_FOLDER})
+    endif()
+    foreach(ARG ${ARGUMENTS_GENERATORS})
+        set(CONAN_GENERATORS ${CONAN_GENERATORS} -g=${ARG})
+    endforeach()
+    foreach(ARG ${ARGUMENTS_ENV})
+        set(CONAN_ENV_VARS ${CONAN_ENV_VARS} -e=${ARG})
+    endforeach()
+    set(conan_args install ${CONANFILE} ${settings} ${CONAN_ENV_VARS} ${CONAN_GENERATORS} ${CONAN_BUILD_POLICY} ${CONAN_INSTALL_UPDATE} ${CONAN_INSTALL_NO_IMPORTS} ${CONAN_OPTIONS} ${CONAN_INSTALL_FOLDER} ${ARGUMENTS_INSTALL_ARGS})
+
+    string (REPLACE ";" " " _conan_args "${conan_args}")
+    message(STATUS "Conan executing: ${CONAN_CMD} ${_conan_args}")
+
+    if(ARGUMENTS_OUTPUT_QUIET)
+        execute_process(COMMAND ${CONAN_CMD} ${conan_args}
+                        RESULT_VARIABLE return_code
+                        OUTPUT_VARIABLE conan_output
+                        ERROR_VARIABLE conan_output
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    else()
+        execute_process(COMMAND ${CONAN_CMD} ${conan_args}
+                        RESULT_VARIABLE return_code
+                        WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+
+    if(NOT "${return_code}" STREQUAL "0")
+      message(FATAL_ERROR "Conan install failed='${return_code}'")
+    endif()
+
+endfunction()
+
+function(conan_cmake_install)
+    if(DEFINED CONAN_COMMAND)
+        set(CONAN_CMD ${CONAN_COMMAND})
+    else()
+        conan_check(REQUIRED)
+    endif()
+
+    set(installOptions UPDATE NO_IMPORTS OUTPUT_QUIET ERROR_QUIET)
+    set(installOneValueArgs PATH_OR_REFERENCE REFERENCE REMOTE LOCKFILE LOCKFILE_OUT LOCKFILE_NODE_ID INSTALL_FOLDER OUTPUT_FOLDER)
+    set(installMultiValueArgs GENERATOR BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE
+                              PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD)
+    cmake_parse_arguments(ARGS "${installOptions}" "${installOneValueArgs}" "${installMultiValueArgs}" ${ARGN})
+    foreach(arg ${installOptions})
+        if(ARGS_${arg})
+            set(${arg} ${${arg}} ${ARGS_${arg}})
+        endif()
+    endforeach()
+    foreach(arg ${installOneValueArgs})
+        if(DEFINED ARGS_${arg})
+            if("${arg}" STREQUAL "REMOTE")
+                set(flag "--remote")
+            elseif("${arg}" STREQUAL "LOCKFILE")
+                set(flag "--lockfile")
+            elseif("${arg}" STREQUAL "LOCKFILE_OUT")
+                set(flag "--lockfile-out")
+            elseif("${arg}" STREQUAL "LOCKFILE_NODE_ID")
+                set(flag "--lockfile-node-id")
+            elseif("${arg}" STREQUAL "INSTALL_FOLDER")
+                set(flag "--install-folder")
+            elseif("${arg}" STREQUAL "OUTPUT_FOLDER")
+                set(flag "--output-folder")
+            endif()
+            set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
+        endif()
+    endforeach()
+    foreach(arg ${installMultiValueArgs})
+        if(DEFINED ARGS_${arg})
+            if("${arg}" STREQUAL "GENERATOR")
+                set(flag "--generator")
+            elseif("${arg}" STREQUAL "BUILD")
+                set(flag "--build")
+            elseif("${arg}" STREQUAL "ENV")
+                set(flag "--env")
+            elseif("${arg}" STREQUAL "ENV_HOST")
+                set(flag "--env:host")
+            elseif("${arg}" STREQUAL "ENV_BUILD")
+                set(flag "--env:build")
+            elseif("${arg}" STREQUAL "OPTIONS")
+                set(flag "--options")
+            elseif("${arg}" STREQUAL "OPTIONS_HOST")
+                set(flag "--options:host")
+            elseif("${arg}" STREQUAL "OPTIONS_BUILD")
+                set(flag "--options:build")
+            elseif("${arg}" STREQUAL "PROFILE")
+                set(flag "--profile")
+            elseif("${arg}" STREQUAL "PROFILE_HOST")
+                set(flag "--profile:host")
+            elseif("${arg}" STREQUAL "PROFILE_BUILD")
+                set(flag "--profile:build")
+            elseif("${arg}" STREQUAL "SETTINGS")
+                set(flag "--settings")
+            elseif("${arg}" STREQUAL "SETTINGS_HOST")
+                set(flag "--settings:host")
+            elseif("${arg}" STREQUAL "SETTINGS_BUILD")
+                set(flag "--settings:build")
+            endif()
+            list(LENGTH ARGS_${arg} numargs)
+            foreach(item ${ARGS_${arg}})
+                if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
+                    set(${arg} "--build")
+                    break()
+                endif()
+                set(${arg} ${${arg}} ${flag} ${item})
+            endforeach()
+        endif()
+    endforeach()
+    if(DEFINED UPDATE)
+        set(UPDATE --update)
+    endif()
+    if(DEFINED NO_IMPORTS)
+        set(NO_IMPORTS --no-imports)
+    endif()
+    set(install_args install ${PATH_OR_REFERENCE} ${REFERENCE} ${UPDATE} ${NO_IMPORTS} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER} ${OUTPUT_FOLDER}
+                                ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD}
+                                ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
+
+    string(REPLACE ";" " " _install_args "${install_args}")
+    message(STATUS "Conan executing: ${CONAN_CMD} ${_install_args}")
+
+    if(ARGS_OUTPUT_QUIET)
+      set(OUTPUT_OPT OUTPUT_QUIET)
+    endif()
+    if(ARGS_ERROR_QUIET)
+      set(ERROR_OPT ERROR_QUIET)
+    endif()
+
+    execute_process(COMMAND ${CONAN_CMD} ${install_args}
+                    RESULT_VARIABLE return_code
+                    ${OUTPUT_OPT}
+                    ${ERROR_OPT}
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    if(NOT "${return_code}" STREQUAL "0")
+        if (ARGS_ERROR_QUIET)
+            message(WARNING "Conan install failed='${return_code}'")
+        else()
+            message(FATAL_ERROR "Conan install failed='${return_code}'")
+        endif()
+    endif()
+
+endfunction()
+
+function(conan_cmake_lock_create)
+    if(DEFINED CONAN_COMMAND)
+        set(CONAN_CMD ${CONAN_COMMAND})
+    else()
+        conan_check(REQUIRED)
+    endif()
+
+    set(lockCreateOptions UPDATE BASE OUTPUT_QUIET ERROR_QUIET)
+    set(lockCreateOneValueArgs PATH REFERENCE REMOTE LOCKFILE LOCKFILE_OUT)
+    set(lockCreateMultiValueArgs BUILD ENV ENV_HOST ENV_BUILD OPTIONS_HOST OPTIONS OPTIONS_BUILD PROFILE
+                              PROFILE_HOST PROFILE_BUILD SETTINGS SETTINGS_HOST SETTINGS_BUILD)
+    cmake_parse_arguments(ARGS "${lockCreateOptions}" "${lockCreateOneValueArgs}" "${lockCreateMultiValueArgs}" ${ARGN})
+    foreach(arg ${lockCreateOptions})
+        if(ARGS_${arg})
+            set(${arg} ${${arg}} ${ARGS_${arg}})
+        endif()
+    endforeach()
+    foreach(arg ${lockCreateOneValueArgs})
+        if(DEFINED ARGS_${arg})
+            if("${arg}" STREQUAL "REMOTE")
+                set(flag "--remote")
+            elseif("${arg}" STREQUAL "LOCKFILE")
+                set(flag "--lockfile")
+            elseif("${arg}" STREQUAL "LOCKFILE_OUT")
+                set(flag "--lockfile-out")
+            endif()
+            set(${arg} ${${arg}} ${flag} ${ARGS_${arg}})
+        endif()
+    endforeach()
+    foreach(arg ${lockCreateMultiValueArgs})
+        if(DEFINED ARGS_${arg})
+            if("${arg}" STREQUAL "BUILD")
+                set(flag "--build")
+            elseif("${arg}" STREQUAL "ENV")
+                set(flag "--env")
+            elseif("${arg}" STREQUAL "ENV_HOST")
+                set(flag "--env:host")
+            elseif("${arg}" STREQUAL "ENV_BUILD")
+                set(flag "--env:build")
+            elseif("${arg}" STREQUAL "OPTIONS")
+                set(flag "--options")
+            elseif("${arg}" STREQUAL "OPTIONS_HOST")
+                set(flag "--options:host")
+            elseif("${arg}" STREQUAL "OPTIONS_BUILD")
+                set(flag "--options:build")
+            elseif("${arg}" STREQUAL "PROFILE")
+                set(flag "--profile")
+            elseif("${arg}" STREQUAL "PROFILE_HOST")
+                set(flag "--profile:host")
+            elseif("${arg}" STREQUAL "PROFILE_BUILD")
+                set(flag "--profile:build")
+            elseif("${arg}" STREQUAL "SETTINGS")
+                set(flag "--settings")
+            elseif("${arg}" STREQUAL "SETTINGS_HOST")
+                set(flag "--settings:host")
+            elseif("${arg}" STREQUAL "SETTINGS_BUILD")
+                set(flag "--settings:build")
+            endif()
+            list(LENGTH ARGS_${arg} numargs)
+            foreach(item ${ARGS_${arg}})
+                if(${item} STREQUAL "all" AND ${arg} STREQUAL "BUILD")
+                    set(${arg} "--build")
+                    break()
+                endif()
+                set(${arg} ${${arg}} ${flag} ${item})
+            endforeach()
+        endif()
+    endforeach()
+    if(DEFINED UPDATE)
+        set(UPDATE --update)
+    endif()
+    if(DEFINED BASE)
+        set(BASE --base)
+    endif()
+    set(lock_create_Args lock create ${PATH} ${REFERENCE} ${UPDATE} ${BASE} ${REMOTE} ${LOCKFILE} ${LOCKFILE_OUT} ${LOCKFILE_NODE_ID} ${INSTALL_FOLDER}
+                                ${GENERATOR} ${BUILD} ${ENV} ${ENV_HOST} ${ENV_BUILD} ${OPTIONS} ${OPTIONS_HOST} ${OPTIONS_BUILD} 
+                                ${PROFILE} ${PROFILE_HOST} ${PROFILE_BUILD} ${SETTINGS} ${SETTINGS_HOST} ${SETTINGS_BUILD})
+
+    string(REPLACE ";" " " _lock_create_Args "${lock_create_Args}")
+    message(STATUS "Conan executing: ${CONAN_CMD} ${_lock_create_Args}")
+    
+    if(ARGS_OUTPUT_QUIET)
+      set(OUTPUT_OPT OUTPUT_QUIET)
+    endif()
+    if(ARGS_ERROR_QUIET)
+      set(ERROR_OPT ERROR_QUIET)
+    endif()
+
+    execute_process(COMMAND ${CONAN_CMD} ${lock_create_Args}
+                    RESULT_VARIABLE return_code
+                    ${OUTPUT_OPT}
+                    ${ERROR_OPT}
+                    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+    if(NOT "${return_code}" STREQUAL "0")
+        if (ARGS_ERROR_QUIET)
+            message(WARNING "Conan lock create failed='${return_code}'")
+        else()
+            message(FATAL_ERROR "Conan lock create failed='${return_code}'")
+        endif()
+    endif()
+endfunction()
+
+function(conan_cmake_setup_conanfile)
+  conan_parse_arguments(${ARGV})
+  if(ARGUMENTS_CONANFILE)
+    get_filename_component(_CONANFILE_NAME ${ARGUMENTS_CONANFILE} NAME)
+    # configure_file will make sure cmake re-runs when conanfile is updated
+    configure_file(${ARGUMENTS_CONANFILE} ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk COPYONLY)
+    file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${_CONANFILE_NAME}.junk)
+  else()
+    conan_cmake_generate_conanfile(ON ${ARGV})
+  endif()
+endfunction()
+
+function(conan_cmake_configure)
+    conan_cmake_generate_conanfile(OFF ${ARGV})
+endfunction()
+
+# Generate, writing in disk a conanfile.txt with the requires, options, and imports
+# specified as arguments
+# This will be considered as temporary file, generated in CMAKE_CURRENT_BINARY_DIR)
+function(conan_cmake_generate_conanfile DEFAULT_GENERATOR)
+
+    conan_parse_arguments(${ARGV})
+
+    set(_FN "${CMAKE_CURRENT_BINARY_DIR}/conanfile.txt")
+    file(WRITE ${_FN} "")
+
+    if(DEFINED ARGUMENTS_REQUIRES)
+        file(APPEND ${_FN} "[requires]\n")
+        foreach(REQUIRE ${ARGUMENTS_REQUIRES})
+            file(APPEND ${_FN} ${REQUIRE} "\n")
+        endforeach()
+    endif()
+
+    if (DEFAULT_GENERATOR OR DEFINED ARGUMENTS_GENERATORS)
+        file(APPEND ${_FN} "[generators]\n")
+        if (DEFAULT_GENERATOR)
+            file(APPEND ${_FN} "cmake\n")
+        endif()
+        if (DEFINED ARGUMENTS_GENERATORS)
+            foreach(GENERATOR ${ARGUMENTS_GENERATORS})
+                file(APPEND ${_FN} ${GENERATOR} "\n")
+            endforeach()
+        endif()
+    endif()
+
+    if(DEFINED ARGUMENTS_BUILD_REQUIRES)
+        file(APPEND ${_FN} "[build_requires]\n")
+        foreach(BUILD_REQUIRE ${ARGUMENTS_BUILD_REQUIRES})
+            file(APPEND ${_FN} ${BUILD_REQUIRE} "\n")
+        endforeach()
+    endif()
+
+    if(DEFINED ARGUMENTS_IMPORTS)
+        file(APPEND ${_FN} "[imports]\n")
+        foreach(IMPORTS ${ARGUMENTS_IMPORTS})
+            file(APPEND ${_FN} ${IMPORTS} "\n")
+        endforeach()
+    endif()
+
+    if(DEFINED ARGUMENTS_OPTIONS)
+        file(APPEND ${_FN} "[options]\n")
+        foreach(OPTION ${ARGUMENTS_OPTIONS})
+            file(APPEND ${_FN} ${OPTION} "\n")
+        endforeach()
+    endif()
+
+endfunction()
+
+
+macro(conan_load_buildinfo)
+    if(CONAN_CMAKE_MULTI)
+      set(_CONANBUILDINFO conanbuildinfo_multi.cmake)
+    else()
+      set(_CONANBUILDINFO conanbuildinfo.cmake)
+    endif()
+    if(ARGUMENTS_INSTALL_FOLDER)
+        set(_CONANBUILDINFOFOLDER ${ARGUMENTS_INSTALL_FOLDER})
+    else()
+        set(_CONANBUILDINFOFOLDER ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
+    # Checks for the existence of conanbuildinfo.cmake, and loads it
+    # important that it is macro, so variables defined at parent scope
+    if(EXISTS "${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO}")
+      message(STATUS "Conan: Loading ${_CONANBUILDINFO}")
+      include(${_CONANBUILDINFOFOLDER}/${_CONANBUILDINFO})
+    else()
+      message(FATAL_ERROR "${_CONANBUILDINFO} doesn't exist in ${CMAKE_CURRENT_BINARY_DIR}")
+    endif()
+endmacro()
+
+
+macro(conan_cmake_run)
+    conan_parse_arguments(${ARGV})
+
+    if(ARGUMENTS_CONFIGURATION_TYPES AND NOT CMAKE_CONFIGURATION_TYPES)
+        message(WARNING "CONFIGURATION_TYPES should only be specified for multi-configuration generators")
+    elseif(ARGUMENTS_CONFIGURATION_TYPES AND ARGUMENTS_BUILD_TYPE)
+        message(WARNING "CONFIGURATION_TYPES and BUILD_TYPE arguments should not be defined at the same time.")
+    endif()
+
+    if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE AND NOT CONAN_EXPORTED
+            AND NOT ARGUMENTS_BUILD_TYPE)
+        set(CONAN_CMAKE_MULTI ON)
+        if (NOT ARGUMENTS_CONFIGURATION_TYPES)
+            set(ARGUMENTS_CONFIGURATION_TYPES "Release;Debug")
+        endif()
+        message(STATUS "Conan: Using cmake-multi generator")
+    else()
+        set(CONAN_CMAKE_MULTI OFF)
+    endif()
+
+    if(NOT CONAN_EXPORTED)
+        conan_cmake_setup_conanfile(${ARGV})
+        if(CONAN_CMAKE_MULTI)
+            foreach(CMAKE_BUILD_TYPE ${ARGUMENTS_CONFIGURATION_TYPES})
+                set(ENV{CONAN_IMPORT_PATH} ${CMAKE_BUILD_TYPE})
+                conan_cmake_settings(settings ${ARGV})
+                old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
+            endforeach()
+            set(CMAKE_BUILD_TYPE)
+        else()
+            conan_cmake_settings(settings ${ARGV})
+            old_conan_cmake_install(SETTINGS ${settings} ${ARGV})
+        endif()
+    endif()
+
+    if (NOT ARGUMENTS_NO_LOAD)
+      conan_load_buildinfo()
+    endif()
+
+    if(ARGUMENTS_BASIC_SETUP)
+        foreach(_option CMAKE_TARGETS KEEP_RPATHS NO_OUTPUT_DIRS SKIP_STD)
+            if(ARGUMENTS_${_option})
+                if(${_option} STREQUAL "CMAKE_TARGETS")
+                    list(APPEND _setup_options "TARGETS")
+                else()
+                    list(APPEND _setup_options ${_option})
+                endif()
+            endif()
+        endforeach()
+        conan_basic_setup(${_setup_options})
+    endif()
+endmacro()
+
+macro(conan_check)
+    # Checks conan availability in PATH
+    # Arguments REQUIRED, DETECT_QUIET and VERSION are optional
+    # Example usage:
+    #    conan_check(VERSION 1.0.0 REQUIRED)
+    set(options REQUIRED DETECT_QUIET)
+    set(oneValueArgs VERSION)
+    cmake_parse_arguments(CONAN "${options}" "${oneValueArgs}" "" ${ARGN})
+    if(NOT CONAN_DETECT_QUIET)
+        message(STATUS "Conan: checking conan executable")
+    endif()
+
+    find_program(CONAN_CMD conan)
+    if(NOT CONAN_CMD AND CONAN_REQUIRED)
+        message(FATAL_ERROR "Conan executable not found! Please install conan.")
+    endif()
+    if(NOT CONAN_DETECT_QUIET)
+        message(STATUS "Conan: Found program ${CONAN_CMD}")
+    endif()
+    execute_process(COMMAND ${CONAN_CMD} --version
+                    RESULT_VARIABLE return_code
+                    OUTPUT_VARIABLE CONAN_VERSION_OUTPUT
+                    ERROR_VARIABLE CONAN_VERSION_OUTPUT)
+
+    if(NOT "${return_code}" STREQUAL "0")
+      message(FATAL_ERROR "Conan --version failed='${return_code}'")
+    endif()
+
+    if(NOT CONAN_DETECT_QUIET)
+        string(STRIP "${CONAN_VERSION_OUTPUT}" _CONAN_VERSION_OUTPUT)
+        message(STATUS "Conan: Version found ${_CONAN_VERSION_OUTPUT}")
+    endif()
+
+    if(DEFINED CONAN_VERSION)
+        string(REGEX MATCH ".*Conan version ([0-9]+\\.[0-9]+\\.[0-9]+)" FOO
+            "${CONAN_VERSION_OUTPUT}")
+        if(${CMAKE_MATCH_1} VERSION_LESS ${CONAN_VERSION})
+            message(FATAL_ERROR "Conan outdated. Installed: ${CMAKE_MATCH_1}, \
+                required: ${CONAN_VERSION}. Consider updating via 'pip \
+                install conan==${CONAN_VERSION}'.")
+        endif()
+    endif()
+endmacro()
+
+function(conan_add_remote)
+    # Adds a remote
+    # Arguments URL and NAME are required, INDEX, COMMAND and VERIFY_SSL are optional
+    # Example usage:
+    #    conan_add_remote(NAME bincrafters INDEX 1
+    #       URL https://api.bintray.com/conan/bincrafters/public-conan
+    #       VERIFY_SSL True)
+    set(oneValueArgs URL NAME INDEX COMMAND VERIFY_SSL)
+    cmake_parse_arguments(CONAN "" "${oneValueArgs}" "" ${ARGN})
+
+    if(DEFINED CONAN_INDEX)
+        set(CONAN_INDEX_ARG "-i ${CONAN_INDEX}")
+    endif()
+    if(DEFINED CONAN_COMMAND)
+        set(CONAN_CMD ${CONAN_COMMAND})
+    else()
+        conan_check(REQUIRED DETECT_QUIET)
+    endif()
+    set(CONAN_VERIFY_SSL_ARG "True")
+    if(DEFINED CONAN_VERIFY_SSL)
+        set(CONAN_VERIFY_SSL_ARG ${CONAN_VERIFY_SSL})
+    endif()
+    message(STATUS "Conan: Adding ${CONAN_NAME} remote repository (${CONAN_URL}) verify ssl (${CONAN_VERIFY_SSL_ARG})")
+    execute_process(COMMAND ${CONAN_CMD} remote add ${CONAN_NAME} ${CONAN_INDEX_ARG} -f ${CONAN_URL} ${CONAN_VERIFY_SSL_ARG}
+                    RESULT_VARIABLE return_code)
+    if(NOT "${return_code}" STREQUAL "0")
+      message(FATAL_ERROR "Conan remote failed='${return_code}'")
+    endif()
+endfunction()
+
+macro(conan_config_install)
+    # install a full configuration from a local or remote zip file
+    # Argument ITEM is required, arguments TYPE, SOURCE, TARGET and VERIFY_SSL are optional
+    # Example usage:
+    #    conan_config_install(ITEM https://github.com/conan-io/cmake-conan.git
+    #       TYPE git SOURCE source-folder TARGET target-folder VERIFY_SSL false)
+    set(oneValueArgs ITEM TYPE SOURCE TARGET VERIFY_SSL)
+    set(multiValueArgs ARGS)
+    cmake_parse_arguments(CONAN "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
+
+    if(DEFINED CONAN_COMMAND)
+        set(CONAN_CMD ${CONAN_COMMAND})
+    else()
+        conan_check(REQUIRED)
+    endif()
+
+    if(DEFINED CONAN_VERIFY_SSL)
+	set(CONAN_VERIFY_SSL_ARG "--verify-ssl=${CONAN_VERIFY_SSL}")
+    endif()
+
+    if(DEFINED CONAN_TYPE)
+	set(CONAN_TYPE_ARG "--type=${CONAN_TYPE}")
+    endif()
+
+    if(DEFINED CONAN_ARGS)
+	set(CONAN_ARGS_ARGS "--args=\"${CONAN_ARGS}\"")
+    endif()
+
+    if(DEFINED CONAN_SOURCE)
+	set(CONAN_SOURCE_ARGS "--source-folder=${CONAN_SOURCE}")
+    endif()
+
+    if(DEFINED CONAN_TARGET)
+	set(CONAN_TARGET_ARGS "--target-folder=${CONAN_TARGET}")
+    endif()
+
+    set (CONAN_CONFIG_INSTALL_ARGS 	${CONAN_VERIFY_SSL_ARG}
+					${CONAN_TYPE_ARG}
+					${CONAN_ARGS_ARGS}
+					${CONAN_SOURCE_ARGS}
+					${CONAN_TARGET_ARGS})
+
+    message(STATUS "Conan: Installing config from ${CONAN_ITEM}")
+	execute_process(COMMAND ${CONAN_CMD} config install ${CONAN_ITEM} ${CONAN_CONFIG_INSTALL_ARGS}
+                  RESULT_VARIABLE return_code)
+  if(NOT "${return_code}" STREQUAL "0")
+    message(FATAL_ERROR "Conan config failed='${return_code}'")
+  endif()
+endmacro()
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 056f8c7b6..5c06dc8ea 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -1,14 +1,16 @@
-FROM debian:stretch-slim as builder
+FROM debian:bullseye-slim as builder
 ARG DOCKER_TAG
 ARG BUILD_CONCURRENCY
 RUN mkdir -p /src  && mkdir -p /opt
+
+RUN apt-get update && \
+    apt-get -y --no-install-recommends install cmake make git gcc g++ libbz2-dev libxml2-dev \
+    libzip-dev libboost1.74-all-dev lua5.2 liblua5.2-dev libtbb-dev -o APT::Install-Suggests=0 -o APT::Install-Recommends=0
+
 COPY . /src
 WORKDIR /src
 
 RUN NPROC=${BUILD_CONCURRENCY:-$(grep -c ^processor /proc/cpuinfo 2>/dev/null || 1)} && \
-    apt-get update && \
-    apt-get -y --no-install-recommends install cmake make git gcc g++ libbz2-dev libxml2-dev \
-    libzip-dev libboost1.62-all-dev lua5.2 liblua5.2-dev libtbb-dev -o APT::Install-Suggests=0 -o APT::Install-Recommends=0 && \
     echo "Building OSRM ${DOCKER_TAG}" && \
     git show --format="%H" | head -n1 > /opt/OSRM_GITSHA && \
     echo "Building OSRM gitsha $(cat /opt/OSRM_GITSHA)" && \
@@ -27,15 +29,15 @@ RUN NPROC=${BUILD_CONCURRENCY:-$(grep -c ^processor /proc/cpuinfo 2>/dev/null ||
     strip /usr/local/bin/* && \
     rm -rf /src /usr/local/lib/libosrm*
 
-
 # Multistage build to reduce image size - https://docs.docker.com/engine/userguide/eng-image/multistage-build/#use-multi-stage-builds
 # Only the content below ends up in the image, this helps remove /src from the image (which is large)
-FROM debian:stretch-slim as runstage
+FROM debian:bullseye-slim as runstage
 RUN mkdir -p /src  && mkdir -p /opt
 RUN apt-get update && \
-    apt-get install -y --no-install-recommends libboost-program-options1.62.0 libboost-regex1.62.0 \
-        libboost-date-time1.62.0 libboost-chrono1.62.0 libboost-filesystem1.62.0 \
-        libboost-iostreams1.62.0 libboost-thread1.62.0 expat liblua5.2-0 libtbb2 &&\
+    apt-get install -y --no-install-recommends libboost-program-options1.74.0 libboost-regex1.74.0 \
+        libboost-date-time1.74.0 libboost-chrono1.74.0 libboost-filesystem1.74.0 \
+        libboost-iostreams1.74.0 libboost-system1.74.0 libboost-thread1.74.0 \
+        expat liblua5.2-0 libtbb2 &&\
     rm -rf /var/lib/apt/lists/*
 COPY --from=builder /usr/local /usr/local
 COPY --from=builder /opt /opt
diff --git a/docs/http.md b/docs/http.md
index 346e6e2ec..60149856b 100644
--- a/docs/http.md
+++ b/docs/http.md
@@ -299,9 +299,9 @@ curl 'http://router.project-osrm.org/table/v1/driving/13.388860,52.517037;13.397
 
 - `code` if the request was successful `Ok` otherwise see the service dependent and general status codes.
 - `durations` array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from
-  the i-th waypoint to the j-th waypoint. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
+  the i-th source to the j-th destination. Values are given in seconds. Can be `null` if no route between `i` and `j` can be found.
 - `distances` array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel distance from
-  the i-th waypoint to the j-th waypoint. Values are given in meters. Can be `null` if no route between `i` and `j` can be found.
+  the i-th source to the j-th destination. Values are given in meters. Can be `null` if no route between `i` and `j` can be found.
 - `sources` array of `Waypoint` objects describing all sources in order
 - `destinations` array of `Waypoint` objects describing all destinations in order
 - `fallback_speed_cells` (optional) array of arrays containing `i,j` pairs indicating which cells contain estimated values based on `fallback_speed`.  Will be absent if `fallback_speed` is not used.
@@ -762,8 +762,8 @@ step.
       {  "bearings" : [ 10, 92, 184, 270 ],
          "lanes" : [
             { "indications" : [ "left", "straight" ],
-               "valid" : "false" },
-            { "valid" : "true",
+               "valid" : false },
+            { "valid" : true,
                "indications" : [ "right" ] }
          ],
          "out" : 2,
@@ -774,9 +774,9 @@ step.
       {  "out" : 1,
          "lanes" : [
             { "indications" : [ "straight" ],
-               "valid" : "true" },
+               "valid" : true },
             { "indications" : [ "right" ],
-               "valid" : "false" }
+               "valid" : false }
          ],
          "bearings" : [ 60, 240, 330 ],
          "in" : 0,
@@ -884,7 +884,7 @@ A `Lane` represents a turn lane at the corresponding turn location.
 ```json
 {
     "indications": ["left", "straight"],
-    "valid": "false"
+    "valid": false
 }
  ```
 
@@ -919,7 +919,7 @@ location of the StepManeuver. Further intersections are listed for every cross-w
     "classes": ["toll", "restricted"],
     "lanes":{
         "indications": ["left", "straight"],
-        "valid": "false"
+        "valid": false
     }
 }
 ```
diff --git a/docs/nodejs/api.md b/docs/nodejs/api.md
index 9bff3ada8..30358e4e2 100644
--- a/docs/nodejs/api.md
+++ b/docs/nodejs/api.md
@@ -20,23 +20,24 @@ var osrm = new OSRM('network.osrm');
 
 **Parameters**
 
--   `options` **([Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
-    -   `options.algorithm` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
+-   `options` **([Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object) \| [String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String))** Options for creating an OSRM object or string to the `.osrm` file. (optional, default `{shared_memory:true}`)
+    -   `options.algorithm` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The algorithm to use for routing. Can be 'CH', 'CoreCH' or 'MLD'. Default is 'CH'.
                Make sure you prepared the dataset with the correct toolchain.
-    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
+    -   `options.shared_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Connects to the persistent shared memory datastore.
                This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
-    -   `options.dataset_name` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Connects to the persistent shared memory datastore defined by `--dataset_name` option when running `osrm-datastore`
+    -   `options.dataset_name` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Connects to the persistent shared memory datastore defined by `--dataset_name` option when running `osrm-datastore`.
                This requires you to run `osrm-datastore --dataset_name` prior to creating an `OSRM` object.
-    -   `options.memory_file` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** *DEPRECATED*
+    -   `options.memory_file` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** **DEPRECATED**
                Old behaviour: Path to a file on disk to store the memory using mmap.  Current behaviour: setting this value is the same as setting `mmap_memory: true`.
-    -   `options.mmap_memory` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Map on-disk files to virtual memory addresses (mmap), rather than loading into RAM.
-    -   `options.path` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
-    -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
-    -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query (default: unlimited).
-    -   `options.max_locations_distance_table` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in distance table query (default: unlimited).
-    -   `options.max_locations_map_matching` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in map-matching query (default: unlimited).
-    -   `options.max_results_nearest` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. results supported in nearest query (default: unlimited).
-    -   `options.max_alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max.number of alternatives supported in alternative routes query (default: 3).
+    -   `options.mmap_memory` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Map on-disk files to virtual memory addresses (mmap), rather than loading into RAM.
+    -   `options.path` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
+    -   `options.max_locations_trip` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in trip query (default: unlimited).
+    -   `options.max_locations_viaroute` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in viaroute query (default: unlimited).
+    -   `options.max_locations_distance_table` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in distance table query (default: unlimited).
+    -   `options.max_locations_map_matching` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. locations supported in map-matching query (default: unlimited).
+    -   `options.max_radius_map_matching` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. radius size supported in map matching query (default: 5).
+    -   `options.max_results_nearest` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. results supported in nearest query (default: unlimited).
+    -   `options.max_alternatives` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Max. number of alternatives supported in alternative routes query (default: 3).
 
 ### route
 
@@ -44,39 +45,39 @@ Returns the fastest route between two or more coordinates while visiting the way
 
 **Parameters**
 
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the route query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the route query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
-    -   `options.alternatives` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Search for alternative routes. (optional, default `false`)
-    -   `options.alternatives` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Search for up to this many alternative routes.
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
+    -   `options.hints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
+    -   `options.alternatives` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Search for alternative routes. (optional, default `false`)
+    -   `options.alternatives` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** Search for up to this many alternative routes.
         _Please note that even if alternative routes are requested, a result cannot be guaranteed._ (optional, default `0`)
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route leg. (optional, default `false`)
-    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
-    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
-    -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
-    -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
-    -   `options.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route leg. (optional, default `false`)
+    -   `options.annotations` **([Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
+    -   `options.geometries` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
+    -   `options.overview` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
+    -   `options.continue_straight` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
                          `null`/`true`/`false`
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+    -   `options.waypoints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints. If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
+    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
 ```javascript
 var osrm = new OSRM("berlin-latest.osrm");
-osrm.route({coordinates: [[13.438640,52.519930], [13.415852,52.513191]]}, function(err, result) {
+osrm.route({coordinates: [[52.519930,13.438640], [52.513191,13.415852]]}, function(err, result) {
   if(err) throw err;
   console.log(result.waypoints); // array of Waypoint objects representing all waypoints in order
   console.log(result.routes); // array of Route objects ordered by descending recommendation rank
 });
 ```
 
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** An array of [Waypoint](#waypoint) objects representing all waypoints in order AND an array of [`Route`](#route) objects ordered by descending recommendation rank.
+Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** An array of [Waypoint](#waypoint) objects representing all waypoints in order AND an array of [`Route`](#route) objects ordered by descending recommendation rank.
 
 ### nearest
 
@@ -86,18 +87,18 @@ Note: `coordinates` in the general options only supports a single `{longitude},{
 
 **Parameters**
 
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the nearest query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the nearest query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
-    -   `options.number` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
+    -   `options.hints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
+    -   `options.number` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of nearest segments that should be returned.
         Must be an integer greater than or equal to `1`. (optional, default `1`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
@@ -113,37 +114,34 @@ osrm.nearest(options, function(err, response) {
 });
 ```
 
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `waypoints`.
+Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `waypoints`.
 **`waypoints`**: array of [`Ẁaypoint`](#waypoint) objects sorted by distance to the input coordinate.
                  Each object has an additional `distance` property, which is the distance in meters to the supplied input coordinate.
 
 ### table
 
-Computes duration table for the given locations. Allows for both symmetric and asymmetric
-tables. Optionally returns distance table.
+Computes duration table for the given locations. Allows for both symmetric and asymmetric tables.
+Optionally returns distance table.
 
 **Parameters**
 
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the table query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the table query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
-    -   `options.sources` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to
-        use
-        location with given index as source. Default is to use all.
-    -   `options.destinations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer <
-        #coordinates`) to use location with given index as destination. Default is to use all.
-    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
-    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
-    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies diestance between two points.
-    -   `options.scale_factor` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
-    -   `options.annotations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Return the requested table or tables in response. Can be `['duration']` (return the duration matrix, default) or `['duration', distance']` (return both the duration matrix and the distance matrix). 
-     
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
+    -   `options.hints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
+    -   `options.sources` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use
+                                         location with given index as source. Default is to use all.
+    -   `options.destinations` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** An array of `index` elements (`0 <= integer < #coordinates`) to use location with given index as destination. Default is to use all.
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.fallback_speed` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
+    -   `options.fallback_coordinate` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies distance between two points.
+    -   `options.scale_factor` **[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)?** Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
+    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+    -   `options.annotations` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Return the requested table or tables in response. Can be `['duration']` (return the duration matrix, default), `[distance']` (return the distance matrix), or `['duration', distance']` (return both the duration matrix and the distance matrix).
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
@@ -158,14 +156,17 @@ var options = {
 };
 osrm.table(options, function(err, response) {
   console.log(response.durations); // array of arrays, matrix in row-major order
+  console.log(response.distances); // array of arrays, matrix in row-major order
   console.log(response.sources); // array of Waypoint objects
   console.log(response.destinations); // array of Waypoint objects
 });
 ```
 
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `durations`, `sources`, and `destinations`.
+Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `durations`, `distances`, `sources`, and `destinations`.
 **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
                  Values are given in seconds.
+**`distances`**: array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
+                 Values are given in meters.
 **`sources`**: array of [`Ẁaypoint`](#waypoint) objects describing all sources in order.
 **`destinations`**: array of [`Ẁaypoint`](#waypoint) objects describing all destinations in order.
 **`fallback_speed_cells`**: (optional) if `fallback_speed` is used, will be an array of arrays of `row,column` values, indicating which cells contain estimated values.
@@ -181,10 +182,10 @@ and what weights they have applied.
 
 **Parameters**
 
--   `ZXY` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** an array consisting of `x`, `y`, and `z` values representing tile coordinates like
+-   `ZXY` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)** an array consisting of `x`, `y`, and `z` values representing tile coordinates like
            [wiki.openstreetmap.org/wiki/Slippy_map_tilenames](https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames)
            and are supported by vector tile viewers like [Mapbox GL JS](https://www.mapbox.com/mapbox-gl-js/api/).
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
@@ -208,23 +209,23 @@ if they can not be matched successfully.
 
 **Parameters**
 
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the match query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the match query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
-    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
-    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
-    -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
-    -   `options.timestamps` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)&lt;[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)>?** Timestamp of the input location (integers, UNIX-like timestamp).
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
-    -   `options.gaps` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore` (optional, default `split`).
-    -   `options.tidy` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Allows the input track modification to obtain better matching quality for noisy tracks (optional, default `false`).
-    -   `options.waypoints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+    -   `options.hints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
+    -   `options.annotations` **([Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
+    -   `options.geometries` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
+    -   `options.overview` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`). (optional, default `simplified`)
+    -   `options.timestamps` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)&lt;[Number](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Number)>?** Timestamp of the input location (integers, UNIX-like timestamp).
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
+    -   `options.gaps` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore`. (optional, default `split`)
+    -   `options.tidy` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Allows the input track modification to obtain better matching quality for noisy tracks. (optional, default `false`)
+    -   `options.waypoints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
+    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
@@ -241,12 +242,15 @@ osrm.match(options, function(err, response) {
 });
 ```
 
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `tracepoints` and `matchings`.
+Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `tracepoints` and `matchings`.
 **`tracepoints`** Array of [`Ẁaypoint`](#waypoint) objects representing all points of the trace in order.
                   If the trace point was ommited by map matching because it is an outlier, the entry will be null.
-                  Each `Waypoint` object includes two additional properties, 1) `matchings_index`: Index to the
-                  [`Route`](#route) object in matchings the sub-trace was matched to, 2) `waypoint_index`: Index of
+                  Each `Waypoint` object has the following additional properties,
+                  1) `matchings_index`: Index to the
+                  [`Route`](#route) object in matchings the sub-trace was matched to,
+                  2) `waypoint_index`: Index of
                   the waypoint inside the matched route.
+                  3) `alternatives_count`: Number of probable alternative matchings for this trace point. A value of zero indicate that this point was matched unambiguously. Split the trace at these points for incremental map matching.
 **`matchings`** is an array of [`Route`](#route) objects that assemble the trace. Each `Route` object has an additional `confidence` property,
                 which is the confidence of the matching. float value between `0` and `1`. `1` is very confident that the matching is correct.
 
@@ -274,23 +278,23 @@ Right now, the following combinations are possible:
 
 **Parameters**
 
--   `options` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
-    -   `options.coordinates` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
-    -   `options.bearings` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
+    -   `options.coordinates` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** The coordinates this request will use, coordinates as `[{lon},{lat}]` values, in decimal degrees.
+    -   `options.bearings` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
                                           Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
-    -   `options.radiuses` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
-    -   `options.hints` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
-    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)?** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
-    -   `options.steps` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
-    -   `options.annotations` **([Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
-    -   `options.geometries` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
-    -   `options.overview` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` (optional, default `simplified`)
-    -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route is a roundtrip. (optional, default `true`)
-    -   `options.source` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
-    -   `options.destination` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
-    -   `options.approaches` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
-    -   `options.snapping` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
--   `callback` **[Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)**
+    -   `options.radiuses` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
+    -   `options.hints` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Hints for the coordinate snapping. Array of base64 encoded strings.
+    -   `options.generate_hints` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not adds a Hint to the response which can be used in subsequent requests. (optional, default `true`)
+    -   `options.steps` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route steps for each route. (optional, default `false`)
+    -   `options.annotations` **([Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array) \| [Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean))** An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all. (optional, default `false`)
+    -   `options.geometries` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Returned route geometry format (influences overview and per step). Can also be `geojson`. (optional, default `polyline`)
+    -   `options.overview` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Add overview geometry either `full`, `simplified` (optional, default `simplified`)
+    -   `options.roundtrip` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Return route is a roundtrip. (optional, default `true`)
+    -   `options.source` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route starts at `any` or `first` coordinate. (optional, default `any`)
+    -   `options.destination` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)** Return route ends at `any` or `last` coordinate. (optional, default `any`)
+    -   `options.approaches` **[Array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array)?** Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+    -   `options.snapping` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+-   `callback` **[Function](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Statements/function)** 
 
 **Examples**
 
@@ -312,19 +316,28 @@ osrm.trip(options, function(err, response) {
 });
 ```
 
-Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `waypoints` and `trips`.
+Returns **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** containing `waypoints` and `trips`.
 **`waypoints`**: an array of [`Waypoint`](#waypoint) objects representing all waypoints in input order.
                  Each Waypoint object has the following additional properties,
                  1) `trips_index`: index to trips of the sub-trip the point was matched to, and
                  2) `waypoint_index`: index of the point in the trip.
 **`trips`**: an array of [`Route`](#route) objects that assemble the trace.
 
-## Plugin behaviour
+## Configuration
 
-All plugins support a second additional object that is available to configure some NodeJS specific behaviours.
+All plugins support a second additional object that is available to configure some NodeJS
+specific behaviours.
 
--   `plugin_config` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** Object literal containing parameters for the trip query.
-    -   `plugin_config.format` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?** The format of the result object to various API calls.  Valid options are `object` (default), which returns a standard Javascript object, as described above, and `json_buffer`, which will return a NodeJS **[Buffer](https://nodejs.org/api/buffer.html)** object, containing a JSON string.  The latter has the advantage that it can be immediately serialized to disk/sent over the network, and the generation of the string is performed outside the main NodeJS event loop.  This option is ignored by the `tile` plugin.
+**Parameters**
+
+-   `plugin_config` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)?** Object literal containing parameters for the trip query.
+    -   `plugin_config.format` **[String](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String)?** The format of the result object to various API calls.
+                                               Valid options are `object` (default), which returns a
+        standard Javascript object, as described above, and `json_buffer`, which will return a NodeJS
+        **[Buffer](https://nodejs.org/api/buffer.html)** object, containing a JSON string. The latter has
+        the advantage that it can be immediately serialized to disk/sent over the network, and the
+        generation of the string is performed outside the main NodeJS event loop.  This option is ignored
+        by the `tile` plugin.
 
 **Examples**
 
@@ -350,7 +363,7 @@ Represents a route through (potentially multiple) waypoints.
 
 **Parameters**
 
--   **documentation** in
+-   `external` **documentation** in
     [`osrm-backend`](../http.md#route-object)
 
 ### RouteLeg
@@ -359,7 +372,7 @@ Represents a route between two waypoints.
 
 **Parameters**
 
--   **documentation** in
+-   `external` **documentation** in
     [`osrm-backend`](../http.md#routeleg-object)
 
 ### RouteStep
@@ -369,14 +382,14 @@ single way to the subsequent step.
 
 **Parameters**
 
--   **documentation** in
+-   `external` **documentation** in
     [`osrm-backend`](../http.md#routestep-object)
 
 ### StepManeuver
 
 **Parameters**
 
--   **documentation** in
+-   `external` **documentation** in
     [`osrm-backend`](../http.md#stepmaneuver-object)
 
 ### Waypoint
@@ -385,5 +398,5 @@ Object used to describe waypoint on a route.
 
 **Parameters**
 
--   **documentation** in
+-   `external` **documentation** in
     [`osrm-backend`](../http.md#waypoint-object)
diff --git a/docs/releasing.md b/docs/releasing.md
index 9a492cd49..d28374f9e 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -50,7 +50,8 @@ We may introduce forward-compatible changes: query parameters and response prope
 7. Push tags and commits: `git push; git push --tags`
 8. On https://github.com/Project-OSRM/osrm-backend/releases press `Draft a new release`,
    write the release tag `vx.y.z` in the `Tag version` field, write the changelog entries in the `Describe this release` field
-   and press `Publish release`.
+   and press `Publish release`. Note that Travis deployments will create a release when publishing node binaries, so the release
+   may already exist. In which case the description should be updated with the changelog entries.
 9. If not a release-candidate: Write a mailing-list post to osrm-talk@openstreetmap.org to announce the release
 10. Wait until the travis build has been completed and check if the node binaries were published by doing:
     `rm -rf node_modules && npm install` locally.
diff --git a/docs/windows-deps.md b/docs/windows-deps.md
index 47fecc38a..a4965d265 100644
--- a/docs/windows-deps.md
+++ b/docs/windows-deps.md
@@ -12,20 +12,14 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### Bzip2
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/bzip2-1.0.8.tar.gz
-    * https://sourceware.org/pub/bzip2/bzip2-1.0.8.tar.gz
-
+1. Download from https://sourceware.org/pub/bzip2/bzip2-1.0.8.tar.gz
 2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 3. Issue `nmake /f makefile.msc`
 4. Copy bzlib.h to $target\include and libbz2.lib to $target\lib
 
 ### ZLib
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/zlib-1.2.11.tar.gz
-    * https://www.zlib.net/zlib-1.2.11.tar.gz
-
+1. Download https://www.zlib.net/zlib-1.2.11.tar.gz
 2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 3. Switch to `contrib\vstudio\vc14`
 4. If needed, open `zlibvc.sln` with Visual Studio and retarget to your version of compiler and SDK.
@@ -34,10 +28,8 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### ICU
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://wolt-project.wolt.com/deps/icu4c-66_1-src.zip
+1. Download and unpack.
     * https://github.com/unicode-org/icu/releases/download/release-66-1/icu4c-66_1-src.zip
-    * https://wolt-project.wolt.com/deps/icu4c-66_1-data.zip
     * https://github.com/unicode-org/icu/releases/download/release-66-1/icu4c-66_1-data.zip
 2. Do retarget if neededby openinig .\source\allinone\allinone.sln and editing projects
 3. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
@@ -48,10 +40,7 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### Boost
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/boost_1_73_0.zip
-    * https://dl.bintray.com/boostorg/release/1.73.0/source/boost_1_73_0.zip
-
+1. Download and unpack https://dl.bintray.com/boostorg/release/1.73.0/source/boost_1_73_0.zip
 2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 3. Build b2:
     bootstrap.bat --with-toolset=msvc-14.2
@@ -61,9 +50,7 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### Expat
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/libexpat-2_2_9.zip
-    * https://github.com/libexpat/libexpat/archive/R_2_2_9.zip
+1. Download and unpack https://github.com/libexpat/libexpat/archive/R_2_2_9.zip
 2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 3. Configure build my calling cmake:
     mkdir expat\build
@@ -74,9 +61,7 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### LUA
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/lua-5.3.5.tar.gz
-    * https://www.lua.org/ftp/lua-5.3.5.tar.gz
+1. Download and unpack https://www.lua.org/ftp/lua-5.3.5.tar.gz
 2. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 3. Lua doesn't have native MSVC support, so you have to compile it by hand:
     cd src
@@ -88,9 +73,7 @@ Prepare directories for dependencies, build and target file location.Target dire
 
 ### TBB
 
-1. Download either from Wolt OSRM mirror or original distribution and unpack.
-    * https://project-osrm.wolt.com/deps/oneTBB-v2020.2.zip
-    * https://github.com/oneapi-src/oneTBB/archive/v2020.2.zip
+1. Download and unpack https://github.com/oneapi-src/oneTBB/archive/v2020.2.zip
 2. Retarget by opening build\vs2013\makefile.sln
 3. Start 'x64 Native Tools Command Prompt for VS2019' and change directory to unpacked source tree.
 4. Switch to build\vs2013 and build: `msbuild makefle.sln /nologo /p:Configuration=Release /p:Platform=x64`
diff --git a/features/bicycle/exclude.feature b/features/bicycle/exclude.feature
index 6fdcbfb07..f88315408 100644
--- a/features/bicycle/exclude.feature
+++ b/features/bicycle/exclude.feature
@@ -45,7 +45,7 @@ Feature: Bicycle - Exclude flags
 
         When I match I should get
             | trace | matchings | duration |
-            | abcf  | abcf      | 301.2    |
+            | abcf  | abcf      | 301      |
 
         When I request a travel time matrix I should get
             |   | a          | f        |
diff --git a/features/bicycle/maxspeed.feature b/features/bicycle/maxspeed.feature
index a4fc57b3d..72f6a0ed6 100644
--- a/features/bicycle/maxspeed.feature
+++ b/features/bicycle/maxspeed.feature
@@ -9,7 +9,7 @@ Feature: Bike - Max speed restrictions
         Then routability should be
             | highway     | maxspeed | bothw   |
             | residential |          | 15 km/h |
-            | residential | 10       | 9 km/h  |
+            | residential | 10       | 10 km/h |
 
     Scenario: Bicycle - Ignore maxspeed when higher than way speed
         Then routability should be
@@ -65,12 +65,12 @@ Feature: Bike - Max speed restrictions
         Then routability should be
             | maxspeed | maxspeed:forward | maxspeed:backward | forw    | backw   |
             |          |                  |                   | 15 km/h | 15 km/h |
-            | 10       |                  |                   | 9 km/h  | 9 km/h  |
-            |          | 10               |                   | 9 km/h  | 15 km/h |
-            |          |                  | 10                | 14 km/h | 9 km/h  |
-            | 2        | 10               |                   | 9 km/h  | 2 km/h  |
-            | 2        |                  | 10                | 2 km/h  | 9 km/h  |
-            | 2        | 5                | 10                | 5 km/h  | 9 km/h  |
+            | 10       |                  |                   | 10 km/h | 10 km/h |
+            |          | 10               |                   | 10 km/h | 15 km/h |
+            |          |                  | 10                | 15 km/h | 10 km/h |
+            | 2        | 10               |                   | 10 km/h | 2 km/h  |
+            | 2        |                  | 10                | 2 km/h  | 10 km/h |
+            | 2        | 5                | 10                | 5 km/h  | 10 km/h |
 
     Scenario: Bike - Maxspeed should not allow routing on unroutable ways
         Then routability should be
diff --git a/features/bicycle/safety.feature b/features/bicycle/safety.feature
index e45dae500..4561e1a5e 100644
--- a/features/bicycle/safety.feature
+++ b/features/bicycle/safety.feature
@@ -33,7 +33,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | tertiary_link  | track       | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | residential    | track       | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | cycleway       | track       | 15 km/h | 15 km/h |       4.2 |        4.2 |
-            | footway        | track       | 15 km/h | 15 km/h |       4.2 |        4.2 |
+            | footway        | track       | 14 km/h | 14 km/h |       4.2 |        4.2 |
             | motorway       | lane        | 15 km/h |         |       4.2 |            |
             | primary        | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | secondary      | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
@@ -41,7 +41,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | primary_link   | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | secondary_link | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | tertiary_link  | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
-            | residential    | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
+            | residential    | lane        | 14 km/h | 14 km/h |       4.2 |        4.2 |
             | cycleway       | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | footway        | lane        | 15 km/h | 15 km/h |       4.2 |        4.2 |
             | motorway       | shared_lane | 15 km/h |         |       4.2 |            |
@@ -59,7 +59,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | tertiary_link  | track          |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
             | residential    | track          |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
             | cycleway       | track          |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
-            | footway        | track          |               | 15 km/h     | 4 km/h +-1  |       4.2 |        1.1 |
+            | footway        | track          |               | 14 km/h     | 4 km/h +-1  |       4.2 |        1.1 |
             | motorway       |                | track         | 15 km/h     |             |       4.2 |            |
             | primary        |                | track         | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
             | secondary      |                | track         | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
@@ -67,7 +67,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | primary_link   |                | track         | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
             | secondary_link |                | track         | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
             | tertiary_link  |                | track         | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
-            | residential    |                | track         | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
+            | residential    |                | track         | 14 km/h     | 14 km/h     |       4.2 |        4.2 |
             | cycleway       |                | track         | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
             | footway        |                | track         | 4 km/h +-1  | 15 km/h     |       1.1 |        4.2 |
             | motorway       | lane           |               | 15 km/h     |             |       4.2 |            |
@@ -75,7 +75,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | secondary      | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
             | tertiary       | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
             | primary_link   | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
-            | secondary_link | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        2.7 |
+            | secondary_link | lane           |               | 14 km/h     | 14 km/h     |       4.2 |        2.7 |
             | tertiary_link  | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        3.3 |
             | residential    | lane           |               | 15 km/h +-1 | 15 km/h +-1 |       4.2 |        4.2 |
             | cycleway       | lane           |               | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
@@ -84,7 +84,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | primary        |                | lane          | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
             | secondary      |                | lane          | 15 km/h +-1 | 15 km/h +-1 |       2.7 |        4.2 |
             | tertiary       |                | lane          | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
-            | primary_link   |                | lane          | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
+            | primary_link   |                | lane          | 14 km/h     | 14 km/h     |       2.1 |        4.2 |
             | secondary_link |                | lane          | 15 km/h     | 15 km/h     |       2.7 |        4.2 |
             | tertiary_link  |                | lane          | 15 km/h     | 15 km/h     |       3.3 |        4.2 |
             | residential    |                | lane          | 15 km/h     | 15 km/h     |       4.2 |        4.2 |
@@ -92,7 +92,7 @@ Feature: Bicycle - Adds penalties to unsafe roads
             | footway        |                | lane          | 4 km/h +-1  | 15 km/h     |       1.1 |        4.2 |
             | motorway       | shared_lane    |               | 15 km/h     |             |       4.2 |            |
             | primary        | shared_lane    |               | 15 km/h     | 15 km/h     |       4.2 |        2.1 |
-            | motorway       |                | shared_lane   | 15 km/h     |             |       4.2 |            |
+            | motorway       |                | shared_lane   | 14 km/h     |             |       4.2 |            |
             | primary        |                | shared_lane   | 15 km/h     | 15 km/h     |       2.1 |        4.2 |
 
 
diff --git a/features/bicycle/surface.feature b/features/bicycle/surface.feature
index 1a4b5763a..98ec1c250 100644
--- a/features/bicycle/surface.feature
+++ b/features/bicycle/surface.feature
@@ -8,29 +8,29 @@ Feature: Bike - Surfaces
         Then routability should be
             | highway  | surface               | bothw   |
             | cycleway |                       | 48 s    |
-            | cycleway | asphalt               | 48 s    |
+            | cycleway | asphalt               | 47.9 s  |
             | cycleway | cobblestone:flattened | 72 s    |
             | cycleway | paving_stones         | 72 s    |
             | cycleway | compacted             | 72 s    |
             | cycleway | cobblestone           | 120 s   |
             | cycleway | fine_gravel           | 120 s   |
             | cycleway | gravel                | 120 s   |
-            | cycleway | pebblestone           | 120.1 s |
+            | cycleway | pebblestone           | 120 s   |
             | cycleway | dirt                  | 120 s   |
             | cycleway | earth                 | 120 s   |
             | cycleway | grass                 | 120 s   |
             | cycleway | mud                   | 240 s   |
-            | cycleway | sand                  | 240.1 s |
+            | cycleway | sand                  | 240 s   |
             | cycleway | sett                  | 72 s    |
 
     Scenario: Bicycle - Good surfaces on small paths
         Then routability should be
-        | highway  | surface | bothw |
-        | cycleway |         | 48 s  |
-        | path     |         | 60 s  |
-        | track    |         | 60 s  |
-        | track    | asphalt | 60 s  |
-        | path     | asphalt | 60 s  |
+        | highway  | surface | bothw  |
+        | cycleway |         | 48 s   |
+        | path     |         | 59.9 s |
+        | track    |         | 60 s   |
+        | track    | asphalt | 60 s   |
+        | path     | asphalt | 60 s   |
 
     Scenario: Bicycle - Surfaces should not make unknown ways routable
         Then routability should be
diff --git a/features/bicycle/turn_penalty.feature b/features/bicycle/turn_penalty.feature
index d0c144e32..763827527 100644
--- a/features/bicycle/turn_penalty.feature
+++ b/features/bicycle/turn_penalty.feature
@@ -37,6 +37,6 @@ Feature: Turn Penalties
             | from | to | distance  | weight | #                                         |
             | a    | c  | 900m +- 1 | 216    | Going straight has no penalties           |
             | a    | d  | 900m +- 1 | 220.2  | Turning right had penalties               |
-            | e    | g  | 2100m +- 4| 503.9  | Going straght has no penalties            |
-            | e    | h  | 2100m +- 4| 515.1  | Turn sharp right has even higher penalties|
+            | e    | g  | 2100m +- 5| 503.9  | Going straght has no penalties            |
+            | e    | h  | 2100m +- 5| 515.1  | Turn sharp right has even higher penalties|
 
diff --git a/features/car/access.feature b/features/car/access.feature
index 47ac4e3c2..0bebd2589 100644
--- a/features/car/access.feature
+++ b/features/car/access.feature
@@ -185,7 +185,7 @@ Feature: Car - Restricted access
         Then routability should be
             | highway | hov        | bothw | forw_rate  | backw_rate  |
             | primary | designated | x     | 18.2       | 18.2        |
-            | primary | yes        | x     | 18.2       | 18.2        |
+            | primary | yes        | x     | 18.3       | 18.3        |
             | primary | no         | x     | 18.2       | 18.2        |
 
     # Models:
@@ -196,7 +196,7 @@ Feature: Car - Restricted access
         Then routability should be
             | highway  | hov         | hov:lanes                          | lanes | access     | oneway | forw | backw | forw_rate  |
             | motorway | designated  | designated\|designated\|designated | 3     | hov        | yes    | x    |       | 25         |
-            | motorway | lane        |                                    | 3     | designated | yes    | x    |       | 25         |
+            | motorway | lane        |                                    | 3     | designated | yes    | x    |       | 25.3       |
 
     @hov
     Scenario: Car - a way with all lanes HOV-designated is highly penalized by default (similar to hov=designated)
@@ -206,7 +206,7 @@ Feature: Car - Restricted access
             # This test is flaky because non-deterministic turn generation sometimes emits a NoTurn here that is marked as restricted. #3769
             #| primary |                        | designated             |                        |        | x    | x     | 18.2      | 18.2       |
             #| primary | designated             |                        |                        |        | x    | x     | 18.2      | 18.2       |
-            | primary | designated\|designated | designated\|designated |                        |        | x    | x     | 18.2      | 18.2       |
+            | primary | designated\|designated | designated\|designated |                        |        | x    | x     | 18.3      | 18.3       |
             | primary | designated\|no         | designated\|no         |                        |        | x    | x     | 18.2      | 18.2       |
             | primary | yes\|no                | yes\|no                |                        |        | x    | x     | 18.2      | 18.2       |
             | primary |                        |                        |                        |        | x    | x     | 18.2      | 18.2       |
diff --git a/features/car/barrier.feature b/features/car/barrier.feature
index 3f3220602..fd7e7f834 100644
--- a/features/car/barrier.feature
+++ b/features/car/barrier.feature
@@ -46,6 +46,18 @@ Feature: Car - Barriers
             | bollard      | rising        | x     |
             | bollard      | removable     |       |
 
+    # https://github.com/Project-OSRM/osrm-backend/issues/5996
+    Scenario: Car - Kerb exception for barriers
+        Then routability should be
+            | node/barrier | node/highway  | node/kerb  | bothw |
+            | kerb         |               |            |       |
+            | kerb         | crossing      |            |  x    |
+            | kerb         | crossing      | yes        |  x    |
+            | kerb         |               | lowered    |  x    |
+            | kerb         |               | flush      |  x    |
+            | kerb         |               | raised     |       |
+            | kerb         |               | yes        |       |
+
     Scenario: Car - Height restrictions
         Then routability should be
             | node/barrier      | node/maxheight | bothw |
diff --git a/features/car/conditional_restrictions.feature b/features/car/conditional_restrictions.feature
index 23a9e1efe..c2311067c 100644
--- a/features/car/conditional_restrictions.feature
+++ b/features/car/conditional_restrictions.feature
@@ -387,217 +387,37 @@ Feature: Car - Turn restrictions
             | m    | p  | mj,jp,jp       |
 
     @no_turning @conditionals
-    Scenario: Car - only_right_turn
+    Scenario: Car - Multiple conditional restrictions applicable to same turn
         Given the extract extra arguments "--parse-conditional-restrictions"
                                             # time stamp for 10am on Tues, 02 May 2017 GMT
         Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
         Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+
         Given the node map
             """
-              a
-            d j b
-              c
+                j
+                |
+            k - l - m
+                |
+                n
             """
 
         And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
+            | nodes |
+            | kl    |
+            | jl    |
+            | ln    |
+            | lm    |
 
         And the relations
             | type        | way:from | way:to | node:via | restriction:conditional               |
-            | restriction | bj       | aj     | j        | only_right_turn @ (Mo-Su 07:00-14:00) |
+            | restriction | kl       | lj     | l        | only_left_turn @ (Sa-Su 07:00-10:30)  |
+            | restriction | kl       | ln     | l        | only_right_turn @ (Mo-Fr 07:00-10:30) |
 
         When I route I should get
             | from | to | route          |
-            | b    | c  | bj,aj,aj,jc,jc |
-            | b    | a  | bj,aj,aj       |
-            | b    | d  | bj,aj,aj,jd,jd |
+            | k    | m  | kl,ln,ln,lm,lm |
 
-    @no_turning @conditionals
-    Scenario: Car - No right turn
-        Given the extract extra arguments "--parse-conditional-restrictions"
-                                            # time stamp for 10am on Tues, 02 May 2017 GMT
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the node map
-            """
-              a
-            d j b
-              c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional               |
-            | restriction | bj       | aj     | j        | no_right_turn @ (Mo-Fr 07:00-13:00)   |
-
-        When I route I should get
-            | from | to | route          | # |
-            | b    | c  | bj,jc,jc       | normal turn |
-            | b    | a  | bj,jc,jc,aj,aj | avoids right turn |
-            | b    | d  | bj,jd,jd       | normal maneuver |
-
-    @only_turning @conditionals
-    Scenario: Car - only_left_turn
-        Given the extract extra arguments "--parse-conditional-restrictions"
-                                            # time stamp for 10am on Tues, 02 May 2017 GMT
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the node map
-            """
-              a
-            d j b
-              c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional              |
-            | restriction | bj       | jc     | j        | only_left_turn @ (Mo-Fr 07:00-16:00) |
-
-        When I route I should get
-            | from | to | route          |
-            | b    | c  | bj,jc,jc       |
-            | b    | a  | bj,jc,jc,aj,aj |
-            | b    | d  | bj,jc,jc,jd,jd |
-
-    @no_turning @conditionals
-    Scenario: Car - No left turn
-        Given the extract extra arguments "--parse-conditional-restrictions"
-                                            # time stamp for 10am on Tues, 02 May 2017 GMT
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the node map
-            """
-              a
-            d j b
-              c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional            |
-            | restriction | bj       | jc     | j        | no_left_turn @ (Mo-Su 00:00-23:59) |
-
-        When I route I should get
-            | from | to | route          |
-            | b    | c  | bj,aj,aj,jc,jc |
-            | b    | a  | bj,aj,aj       |
-            | b    | d  | bj,jd,jd       |
-
-    @no_turning @conditionals
-    Scenario: Car - Conditional restriction is off
-        Given the extract extra arguments "--parse-conditional-restrictions"
-                                            # time stamp for 10am on Tues, 02 May 2017 GMT
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
-        Given the node map
-            """
-              a
-            d j b
-              c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional             |
-            | restriction | bj       | aj     | j        | no_right_turn @ (Mo-Su 16:00-20:00) |
-
-        When I route I should get
-            | from | to | route    |
-            | b    | c  | bj,jc,jc |
-            | b    | a  | bj,aj,aj |
-            | b    | d  | bj,jd,jd |
-
-    @no_turning @conditionals
-    Scenario: Car - Conditional restriction is on
-        Given the extract extra arguments "--parse-conditional-restrictions"
-        # 10am utc, wed
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493805600"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493805600"
-        Given the node map
-            """
-              a
-            d j b
-              c
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | bj    | yes    |
-            | jd    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional             |
-            | restriction | jb       | aj     | j        | no_right_turn @ (Mo-Fr 07:00-14:00) |
-
-        When I route I should get
-            | from | to | route          |
-            | b    | c  | bj,jc,jc       |
-            | b    | a  | bj,jc,jc,aj,aj |
-            | b    | d  | bj,jd,jd       |
-
-    @no_turning @conditionals
-    Scenario: Car - Conditional restriction with multiple time windows
-        Given the extract extra arguments "--parse-conditional-restrictions"
-        # 5pm Wed 02 May, 2017 GMT
-        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
-        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493744400"
-
-        Given the node map
-            """
-              a
-           p  |
-            \ |
-              j
-              | \
-              c  m
-            """
-
-        And the ways
-            | nodes | oneway |
-            | aj    | no     |
-            | jc    | no     |
-            | jp    | yes    |
-            | mj    | yes    |
-
-        And the relations
-            | type        | way:from | way:to | node:via | restriction:conditional                         |
-            | restriction | aj       | jp     | j        | no_right_turn @ (Mo-Fr 07:00-11:00,16:00-18:30) |
-
-        When I route I should get
-            | from | to | route          |
-            | a    | p  | aj,jc,jc,jp,jp |
-            | m    | p  | mj,jp,jp       |
 
     @restriction-way
     Scenario: Car - prohibit turn
@@ -719,7 +539,7 @@ Feature: Car - Turn restrictions
         When I route I should get
             | from | to | route                                      | turns                                       |
             | a    | e  | cap south,florida nw,florida nw,florida ne | depart,turn right,continue uturn,arrive     |
-            | f    | d  | cap north,florida nw,florida nw               | depart,turn left,arrive                     |
+            | f    | d  | cap north,florida nw,florida nw            | depart,turn left,arrive                     |
             | e    | c  | florida ne,florida nw,cap south,cap south  | depart,continue uturn,turn right,arrive     |
 
     @no_turning @conditionals
@@ -796,8 +616,8 @@ Feature: Car - Turn restrictions
             | nodes | name  |
             | ab    | albic |
             | bc    | albic |
-            | db    | dobe |
-            | be    | dobe |
+            | db    | dobe  |
+            | be    | dobe  |
 
         And the relations
             | type        | way:from  | way:to  | node:via | restriction:conditional               |
@@ -1047,7 +867,7 @@ Feature: Car - Turn restrictions
             | type        | way:from | node:via | way:to | restriction:conditional             |
             | restriction | be       | e        | de     | no_right_turn @ (Mo-Fr 07:00-11:00) |
 
-        # node restrictino is off, way restriction is on
+        # node restriction is off, way restriction is on
         When I route I should get
             | from | to | route             | turns                                                               | locations   |
             | a    | d  | ab,be,ef,ef,de,de | depart,turn right,turn left,continue uturn,new name straight,arrive | a,b,e,f,e,d |
diff --git a/features/car/ferry.feature b/features/car/ferry.feature
index 5a8de7b1b..e5b7d363c 100644
--- a/features/car/ferry.feature
+++ b/features/car/ferry.feature
@@ -46,10 +46,10 @@ Feature: Car - Handle ferry routes
 
         When I route I should get
             | from | to | route           | modes                         | speed   | time    |
-            | a    | g  | abc,cde,efg,efg | driving,ferry,driving,driving | 12 km/h | 173.4s  |
-            | b    | f  | abc,cde,efg,efg | driving,ferry,driving,driving | 9 km/h  | 162.4s  |
-            | c    | e  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.4s  |
-            | e    | c  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.4s  |
+            | a    | g  | abc,cde,efg,efg | driving,ferry,driving,driving | 12 km/h | 173.5s  |
+            | b    | f  | abc,cde,efg,efg | driving,ferry,driving,driving | 9 km/h  | 162.5s  |
+            | c    | e  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.5s  |
+            | e    | c  | cde,cde         | ferry,ferry                   | 5 km/h  | 151.5s  |
 
     Scenario: Car - Properly handle simple durations
         Given the node map
@@ -117,4 +117,4 @@ Feature: Car - Handle ferry routes
         # Note that matching *should* work across unsnappable ferries
         When I match I should get
           | trace | geometry             | duration |
-          | abcdef| 1,1,1.000899,1,1.000899,1,1.002697,1,1.002697,1,1.003596,1,1.003596,1,1.005394,1,1.005394,1,1.006293,1 | 610.9      |
+          | abcdef| 1,1,1.000898,1,1.000898,1,1.002695,1,1.002695,1,1.003594,1,1.003594,1,1.005391,1,1.005391,1,1.006289,1 | 611      |
diff --git a/features/car/maxspeed.feature b/features/car/maxspeed.feature
index c7169b37c..d2b8b4f5f 100644
--- a/features/car/maxspeed.feature
+++ b/features/car/maxspeed.feature
@@ -86,57 +86,57 @@ OSRM will use 4/5 of the projected free-flow speed.
         Then routability should be
 
             | highway | maxspeed | width | maxspeed:forward | maxspeed:backward | forw    | backw   | forw_rate | backw_rate |
-            | primary |          |       |                  |                   | 64 km/h | 64 km/h | 18        | 18         |
+            | primary |          |       |                  |                   | 64 km/h | 64 km/h | 18.1      | 18.1       |
             | primary |          |   3   |                  |                   | 64 km/h | 64 km/h | 9         | 9          |
-            | primary | 60       |       |                  |                   | 47 km/h | 47 km/h | 13.3      | 13.3       |
-            | primary | 60       |   3   |                  |                   | 47 km/h | 47 km/h | 6.7       | 6.7        |
-            | primary |          |       | 60               |                   | 47 km/h | 64 km/h | 13.3      | 18         |
-            | primary |          |   3   | 60               |                   | 47 km/h | 64 km/h | 6.7       | 9          |
-            | primary |          |       |                  | 60                | 64 km/h | 47 km/h | 18        | 13.3       |
-            | primary |          |   3   |                  | 60                | 64 km/h | 47 km/h | 9         | 6.7        |
-            | primary | 15       |       | 60               |                   | 47 km/h | 11 km/h | 13.3      | 3.3        |
+            | primary | 60       |       |                  |                   | 48 km/h | 48 km/h | 13.3      | 13.3       |
+            | primary | 60       |   3   |                  |                   | 48 km/h | 48 km/h | 6.7       | 6.7        |
+            | primary |          |       | 60               |                   | 48 km/h | 64 km/h | 13.3      | 18.1       |
+            | primary |          |   3   | 60               |                   | 48 km/h | 64 km/h | 6.7       | 9          |
+            | primary |          |       |                  | 60                | 64 km/h | 48 km/h | 18.1      | 13.3       |
+            | primary |          |   3   |                  | 60                | 64 km/h | 48 km/h | 9         | 6.7        |
+            | primary | 15       |       | 60               |                   | 48 km/h | 12 km/h | 13.3      | 3.3        |
             | primary | 15       |   3   | 60               |                   | 48 km/h | 12 km/h | 6.7       | 1.7        |
-            | primary | 15       |       |                  | 60                | 12 km/h | 47 km/h | 3.3       | 13.3       |
-            | primary | 15       |   3   |                  | 60                | 12 km/h | 47 km/h | 1.7       | 6.7        |
-            | primary | 15       |       | 30               | 60                | 23 km/h | 47 km/h | 6.7       | 13.3       |
-            | primary | 15       |   3   | 30               | 60                | 23 km/h | 47 km/h | 3.3       | 6.7        |
+            | primary | 15       |       |                  | 60                | 12 km/h | 48 km/h | 3.3       | 13.3       |
+            | primary | 15       |   3   |                  | 60                | 12 km/h | 48 km/h | 1.7       | 6.7        |
+            | primary | 15       |       | 30               | 60                | 24 km/h | 48 km/h | 6.7       | 13.3       |
+            | primary | 15       |   3   | 30               | 60                | 24 km/h | 48 km/h | 3.3       | 6.7        |
 
     Scenario: Car - Single lane streets be ignored or incur a penalty
         Then routability should be
 
             | highway | maxspeed | lanes | maxspeed:forward | maxspeed:backward | forw    | backw   | forw_rate | backw_rate |
-            | primary |          |       |                  |                   | 64 km/h | 64 km/h | 18        | 18         |
+            | primary |          |       |                  |                   | 64 km/h | 64 km/h | 18.1      | 18.1       |
             | primary |          |   1   |                  |                   | 64 km/h | 64 km/h | 9         | 9          |
-            | primary | 60       |       |                  |                   | 47 km/h | 47 km/h | 13.3      | 13.3       |
-            | primary | 60       |   1   |                  |                   | 47 km/h | 47 km/h | 6.7       | 6.7        |
-            | primary |          |       | 60               |                   | 47 km/h | 64 km/h | 13.3      | 18         |
-            | primary |          |   1   | 60               |                   | 47 km/h | 64 km/h | 6.7       | 9          |
-            | primary |          |       |                  | 60                | 64 km/h | 47 km/h | 18        | 13.3       |
-            | primary |          |   1   |                  | 60                | 64 km/h | 47 km/h | 9         | 6.7        |
-            | primary | 15       |       | 60               |                   | 47 km/h | 11 km/h | 13.3      | 3.3        |
+            | primary | 60       |       |                  |                   | 48 km/h | 48 km/h | 13.3      | 13.3       |
+            | primary | 60       |   1   |                  |                   | 48 km/h | 48 km/h | 6.7       | 6.7        |
+            | primary |          |       | 60               |                   | 48 km/h | 64 km/h | 13.3      | 18.1       |
+            | primary |          |   1   | 60               |                   | 48 km/h | 64 km/h | 6.7       | 9          |
+            | primary |          |       |                  | 60                | 64 km/h | 48 km/h | 18.1      | 13.3       |
+            | primary |          |   1   |                  | 60                | 64 km/h | 48 km/h | 9         | 6.7        |
+            | primary | 15       |       | 60               |                   | 48 km/h | 12 km/h | 13.3      | 3.3        |
             | primary | 15       |   1   | 60               |                   | 48 km/h | 12 km/h | 6.7       | 1.7        |
-            | primary | 15       |       |                  | 60                | 12 km/h | 47 km/h | 3.3       | 13.3       |
-            | primary | 15       |   1   |                  | 60                | 12 km/h | 47 km/h | 1.7       | 6.7        |
-            | primary | 15       |       | 30               | 60                | 23 km/h | 47 km/h | 6.7       | 13.3       |
-            | primary | 15       |   1   | 30               | 60                | 23 km/h | 47 km/h | 3.3       | 6.7        |
+            | primary | 15       |       |                  | 60                | 12 km/h | 48 km/h | 3.3       | 13.3       |
+            | primary | 15       |   1   |                  | 60                | 12 km/h | 48 km/h | 1.7       | 6.7        |
+            | primary | 15       |       | 30               | 60                | 24 km/h | 48 km/h | 6.7       | 13.3       |
+            | primary | 15       |   1   | 30               | 60                | 24 km/h | 48 km/h | 3.3       | 6.7        |
 
     Scenario: Car - Single lane streets only incur a penalty for two-way streets
         Then routability should be
             | highway | maxspeed | lanes  | oneway | forw    | backw   | forw_rate | backw_rate |
-            | primary |   30     |   1    | yes    | 23 km/h |         | 6.7       |            |
-            | primary |   30     |   1    | -1     |         | 23 km/h |           | 6.7        |
-            | primary |   30     |   1    |        | 23 km/h | 23 km/h | 3.3       | 3.3        |
-            | primary |   30     |   2    |        | 23 km/h | 23 km/h | 6.7       | 6.7        |
+            | primary |   30     |   1    | yes    | 24 km/h |         | 6.7       |            |
+            | primary |   30     |   1    | -1     |         | 24 km/h |           | 6.7        |
+            | primary |   30     |   1    |        | 24 km/h | 24 km/h | 3.3       | 3.3        |
+            | primary |   30     |   2    |        | 24 km/h | 24 km/h | 6.7       | 6.7        |
 
     Scenario: Car - Forward/backward maxspeed on reverse oneways
         Then routability should be
             | highway | maxspeed | maxspeed:forward | maxspeed:backward | oneway | forw    | backw   | forw_rate | backw_rate |
-            | primary |          |                  |                   | -1     |         | 64 km/h |           | 18         |
-            | primary | 30       |                  |                   | -1     |         | 23 km/h |           | 6.7        |
-            | primary |          | 30               |                   | -1     |         | 64 km/h |           | 18         |
-            | primary |          |                  | 30                | -1     |         | 23 km/h |           | 6.7        |
-            | primary | 20       | 30               |                   | -1     |         | 15 km/h |           | 4.4        |
-            | primary | 20       |                  | 30                | -1     |         | 23 km/h |           | 6.7        |
+            | primary |          |                  |                   | -1     |         | 64 km/h |           | 18.1       |
+            | primary | 30       |                  |                   | -1     |         | 24 km/h |           | 6.7        |
+            | primary |          | 30               |                   | -1     |         | 64 km/h |           | 18.1       |
+            | primary |          |                  | 30                | -1     |         | 24 km/h |           | 6.7        |
+            | primary | 20       | 30               |                   | -1     |         | 16 km/h |           | 4.4        |
+            | primary | 20       |                  | 30                | -1     |         | 24 km/h |           | 6.7        |
 
 
     Scenario: Car - Respect source:maxspeed
diff --git a/features/car/multi_via_restrictions.feature b/features/car/multi_via_restrictions.feature
new file mode 100644
index 000000000..42c6c6d42
--- /dev/null
+++ b/features/car/multi_via_restrictions.feature
@@ -0,0 +1,1033 @@
+@routing @car @restrictions
+
+Feature: Car - Multiple Via Turn restrictions
+
+    Background: Use car routing
+        Given the profile "car"
+        Given a grid size of 200 meters
+
+
+    @restriction-way @no_turning @overlap
+    Scenario: Car - Node restriction inside multiple via restriction
+        Given the node map
+            """
+              1   2   3          4         5
+            a---b---c---d---e---------f---------g
+                            |         |         |
+                            |7        |8        |9
+                            |         |         |
+                        x---h---------i---------j
+            """
+
+        And the ways
+            | nodes | oneway | name    |
+            | ab    | yes    | forward |
+            | bc    | yes    | forward |
+            | cd    | yes    | forward |
+            | de    | yes    | forward |
+            | ef    | yes    | forward |
+            | fg    | yes    | forward |
+            | eh    | yes    | first   |
+            | fi    | yes    | second  |
+            | gj    | yes    | third   |
+            | ih    | yes    | back    |
+            | ji    | yes    | back    |
+            | hx    | yes    | back    |
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction   |
+            | restriction | ab       | bc,cd,de,ef | fi     | no_right_turn |
+
+        And the relations
+            | type        | way:from | node:via | way:to | restriction   |
+            | restriction | de       | e        | eh     | no_right_turn |
+
+        When I route I should get
+            | from | to | route                    |
+            | 1    | x  | forward,third,back,back  |
+            | 2    | x  | forward,second,back,back |
+            | 3    | x  | forward,second,back,back |
+            | 4    | x  | forward,second,back,back |
+            | 5    | x  | forward,third,back,back  |
+            | 7    | x  | first,back,back          |
+            | 8    | x  | second,back,back         |
+            | 9    | x  | third,back,back          |
+
+
+    @restriction-way @no_turning @overlap @conditionals
+    Scenario: Car - Conditional node restriction inside conditional multiple via restriction
+        Given the origin -9.2972,10.3811
+        # coordinate in Guinée, a country that observes GMT year round
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+              1   2   3          4         5
+            a---b---c---d---e---------f---------g
+                            |         |         |
+                            |7        |8        |9
+                            |         |         |
+                        x---h---------i---------j
+            """
+
+        And the ways
+            | nodes | oneway | name    |
+            | ab    | yes    | forward |
+            | bc    | yes    | forward |
+            | cd    | yes    | forward |
+            | de    | yes    | forward |
+            | ef    | yes    | forward |
+            | fg    | yes    | forward |
+            | eh    | yes    | first   |
+            | fi    | yes    | second  |
+            | gj    | yes    | third   |
+            | ih    | yes    | back    |
+            | ji    | yes    | back    |
+            | hx    | yes    | back    |
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction:conditional             |
+            | restriction | ab       | bc,cd,de,ef | fi     | no_right_turn @ (Mo-Fr 07:00-10:30) |
+
+        And the relations
+            | type        | way:from | node:via | way:to | restriction:conditional               |
+            | restriction | de       | e        | eh     | no_right_turn @ (Mo-Fr 07:00-10:30)   |
+            | restriction | de       | e        | eh     | only_right_turn @ (Sa-Su 07:00-10:30) |
+
+        When I route I should get
+            | from | to | route                    |
+            | 1    | x  | forward,third,back,back  |
+            | 2    | x  | forward,second,back,back |
+            | 3    | x  | forward,second,back,back |
+            | 4    | x  | forward,second,back,back |
+            | 5    | x  | forward,third,back,back  |
+            | 7    | x  | first,back,back          |
+            | 8    | x  | second,back,back         |
+            | 9    | x  | third,back,back          |
+
+
+    @restriction-way @no_turning @overlap
+    Scenario: Car - Multiple via restriction inside multiple via restriction
+        Given the node map
+            """
+              1   2   3          4         5
+            a---b---c---d---e---------f---------g
+                            |         |         |
+                            |7        |8        |9
+                            |         |         |
+                        x---h---------i---------j
+            """
+
+        And the ways
+            | nodes | oneway | name    |
+            | ab    | yes    | forward |
+            | bc    | yes    | forward |
+            | cd    | yes    | forward |
+            | de    | yes    | forward |
+            | ef    | yes    | forward |
+            | fg    | yes    | forward |
+            | eh    | yes    | first   |
+            | fi    | yes    | second  |
+            | gj    | yes    | third   |
+            | ih    | yes    | back    |
+            | ji    | yes    | back    |
+            | hx    | yes    | back    |
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction   |
+            | restriction | ab       | bc,cd,de,ef | fi     | no_right_turn |
+            | restriction | bc       | cd,de       | eh     | no_right_turn |
+
+        When I route I should get
+            | from | to | route                    |
+            | 1    | x  | forward,third,back,back  |
+            | 2    | x  | forward,second,back,back |
+            | 3    | x  | forward,first,back,back  |
+            | 4    | x  | forward,second,back,back |
+            | 5    | x  | forward,third,back,back  |
+            | 7    | x  | first,back,back          |
+            | 8    | x  | second,back,back         |
+            | 9    | x  | third,back,back          |
+
+
+    @restriction-way @no_turning @overlap @conditionals
+    Scenario: Car - Conditional multiple via restriction inside conditional multiple via restriction
+
+        Given a grid size of 200 meters
+        Given the origin -9.2972,10.3811
+        # coordinate in Guinée, a country that observes GMT year round
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+
+            """
+              1   2   3          4         5
+            a---b---c---d---e---------f---------g
+                            |         |         |
+                            |7        |8        |9
+                            |         |         |
+                        x---h---------i---------j
+            """
+
+        And the ways
+            | nodes | oneway | name    |
+            | ab    | yes    | forward |
+            | bc    | yes    | forward |
+            | cd    | yes    | forward |
+            | de    | yes    | forward |
+            | ef    | yes    | forward |
+            | fg    | yes    | forward |
+            | eh    | yes    | first   |
+            | fi    | yes    | second  |
+            | gj    | yes    | third   |
+            | ih    | yes    | back    |
+            | ji    | yes    | back    |
+            | hx    | yes    | back    |
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction:conditional               |
+            | restriction | ab       | bc,cd,de,ef | fi     | no_right_turn @ (Mo-Fr 07:00-10:30)   |
+            | restriction | bc       | cd,de       | eh     | no_right_turn @ (Mo-Fr 07:00-10:30)   |
+            | restriction | bc       | cd,de       | eh     | only_right_turn @ (Sa-Su 07:00-10:30) |
+
+        When I route I should get
+            | from | to | route                    |
+            | 1    | x  | forward,third,back,back  |
+            | 2    | x  | forward,second,back,back |
+            | 3    | x  | forward,first,back,back  |
+            | 4    | x  | forward,second,back,back |
+            | 5    | x  | forward,third,back,back  |
+            | 7    | x  | first,back,back          |
+            | 8    | x  | second,back,back         |
+            | 9    | x  | third,back,back          |
+
+
+    @restriction-way @only_turning @overlap
+    Scenario: Car - Overlapping multiple via restrictions
+        Given the node map
+            """
+            a       f       j
+            |       |       |
+            b---d---e---i---k----m
+            |       |       |
+            c       g       l
+            """
+
+        And the ways
+            | nodes | oneway | name    |
+            | ab    | yes    | down    |
+            | cb    | yes    | up      |
+            | bd    | yes    | right   |
+            | de    | yes    | right   |
+            | ef    | yes    | up      |
+            | eg    | yes    | down    |
+            | ei    | yes    | right   |
+            | ik    | yes    | right   |
+            | kj    | yes    | up      |
+            | kl    | yes    | down    |
+            | km    | yes    | right   |
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction      |
+            | restriction | ab       | bd,de       | ei     | only_straight_on |
+            | restriction | de       | ei,ik       | km     | only_straight_on |
+
+        When I route I should get
+            | from | to | route              |
+            | a    | f  |                    |
+            | a    | g  |                    |
+            | a    | j  |                    |
+            | a    | l  |                    |
+            | a    | m  | down,right,right   |
+            | c    | f  | up,right,up,up     |
+            | c    | g  | up,right,down,down |
+            | c    | j  |                    |
+            | c    | l  |                    |
+            | c    | m  | up,right,right     |
+            | i    | j  | right,up,up        |
+            | i    | l  | right,down,down    |
+            | i    | m  | right,right        |
+
+
+    @restriction-way @only_turning @overlap @conditionals
+    Scenario: Car - Overlapping conditional multiple via restrictions
+        Given a grid size of 200 meters
+        Given the origin -9.2972,10.3811
+        # coordinate in Guinée, a country that observes GMT year round
+        Given the extract extra arguments "--parse-conditional-restrictions"
+                                            # time stamp for 10am on Tues, 02 May 2017 GMT
+        Given the contract extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the customize extra arguments "--time-zone-file=test/data/tz/{timezone_names}/guinea.geojson --parse-conditionals-from-now=1493719200"
+        Given the node map
+            """
+            a       f       j
+            |       |       |
+            b---d---e---i---k----m
+            |       |       |
+            c       g       l
+            """
+
+        And the ways
+            | nodes | oneway | name   |
+            | ab    | yes    | down   |
+            | cb    | yes    | up     |
+            | bd    | yes    | right  |
+            | db    | yes    | left   |
+            | de    | yes    | right  |
+            | ed    | yes    | left   |
+            | ef    | yes    | up     |
+            | eg    | yes    | down   |
+            | ei    | yes    | right  |
+            | ie    | yes    | left   |
+            | ik    | yes    | right  |
+            | ki    | yes    | left   |
+            | kj    | yes    | up     |
+            | kl    | yes    | down   |
+            | km    | no     | end    |
+
+        And the relations
+            | type        | way:from | way:via  | way:to | restriction:conditional                |
+            | restriction | ab       | bd,de    | ei     | only_straight_on @ (Mo-Fr 07:00-10:30) |
+            | restriction | ab       | bd,de    | ef     | only_left_turn   @ (Sa-Su 07:00-10:30) |
+            | restriction | de       | ei,ik    | km     | only_straight_on @ (Mo-Fr 07:00-10:30) |
+
+        When I route I should get
+            | from | to | route                             |
+            | a    | f  | down,right,end,end,left,up,up     |
+            | a    | g  | down,right,end,end,left,down,down |
+            | a    | j  | down,right,end,end,up,up          |
+            | a    | l  | down,right,end,end,down,down      |
+            | a    | m  | down,right,end,end                |
+            | c    | f  | up,right,up,up                    |
+            | c    | g  | up,right,down,down                |
+            | c    | j  | up,right,end,end,up,up            |
+            | c    | l  | up,right,end,end,down,down        |
+            | c    | m  | up,right,end,end                  |
+            | i    | j  | right,up,up                       |
+            | i    | l  | right,down,down                   |
+            | i    | m  | right,end,end                     |
+
+
+
+    @restriction-way @only_turning @geometry
+    Scenario: Car - Multiple via restriction with non-compressable via geometry
+        Given the node map
+            """
+            a---b---c---d---e---f---g---h
+                    |       |       |
+                    i       j       k
+            """
+
+        And the ways
+            | nodes | oneway | name   |
+            | ab    | yes    | right  |
+            | bcd   | yes    | right  |
+            | defg  | yes    | right  |
+            | ci    | yes    | down   |
+            | ej    | yes    | down   |
+            | gh    | yes    | end    |
+            | gk    | yes    | down   |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction      |
+            | restriction | ab       | bcd,defg   | gh     | only_straight_on |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | h  | right,end,end  |
+            | a    | k  |                |
+
+    @restriction-way @only_turning @geometry
+    Scenario: Car - Multiple via restriction with non-compressable from/to nodes
+        Given the node map
+            """
+            a---b---c---d---e---f---g---h---i---j---k---l
+                    |       |       |       |       |
+                    m       n       o       p       q
+            """
+
+        And the ways
+            | nodes    | oneway | name   |
+            | abcdefg  | yes    | right  |
+            | ghi      | yes    | right  |
+            | ijkl     | yes    | end    |
+            | cm       | yes    | down   |
+            | en       | yes    | down   |
+            | go       | yes    | down   |
+            | ip       | yes    | down   |
+            | kq       | yes    | down   |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction      |
+            | restriction | abcdefg  | ghi     | ijkl   | only_straight_on |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | l  | right,end,end  |
+            | a    | p  |                |
+
+    @restriction-way @no_turning
+    Scenario: Car - Long unrestricted route and short restricted route
+        Given the node map
+            """
+            a------------------------------------b
+            |                                    |
+            c--d--e--f---------------------------
+            """
+
+        And the ways
+            | nodes    |
+            | ac       |
+            | ab       |
+            | bf       |
+            | cd       |
+            | de       |
+            | ef       |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction    |
+            | restriction | ac       | cd      | de     | no_straight_on |
+
+        When I route I should get
+            | from | to | route     |
+            | a    | f  | ab,bf,bf  |
+
+
+    @restriction-way @overlap @no_turning
+    Scenario: Car - Junction with multiple via u-turn restrictions
+    # Example: https://www.openstreetmap.org/#map=19/52.07399/5.09724
+        Given the node map
+            """
+                a   b
+                |   |
+            c---d---e---f
+                |   |
+            g---h---i---j
+                |   |
+                k   l
+            """
+
+        And the ways
+            | nodes | oneway | name  |
+            | ad    | yes    | down  |
+            | eb    | yes    | up    |
+            | fe    | yes    | left  |
+            | ij    | yes    | right |
+            | li    | yes    | up    |
+            | hk    | yes    | down  |
+            | gh    | yes    | right |
+            | dc    | yes    | left  |
+            | dh    | yes    | down  |
+            | hi    | yes    | right |
+            | ie    | yes    | up    |
+            | ed    | yes    | left  |
+
+        And the relations
+            | type        | way:from | way:via  | way:to | restriction  |
+            | restriction | ad       | dh,hi    | ie     | no_u_turn    |
+            | restriction | li       | ie,ed    | dh     | no_u_turn    |
+
+        When I route I should get
+            | from | to | route                 |
+            | a    | b  |                       |
+            | a    | c  | down,left,left        |
+            | a    | k  | down,down             |
+            | a    | j  | down,right,right      |
+            | f    | b  | left,up,up            |
+            | f    | c  | left,left             |
+            | f    | k  | left,down,down        |
+            | f    | j  | left,down,right,right |
+            | l    | b  | up,up                 |
+            | l    | c  | up,left,left          |
+            | l    | k  |                       |
+            | l    | j  | up,right,right        |
+            | g    | b  | right,up,up           |
+            | g    | c  | right,up,left,left    |
+            | g    | k  | right,down,down       |
+            | g    | j  | right,right           |
+
+
+    @restriction-way @overlap @no_turning
+    Scenario: Car - Junction with multiple via u-turn restrictions, service roads
+    # Example: https://www.openstreetmap.org/#map=19/48.38566/10.88068
+        Given the node map
+            """
+                a     b
+                |     |
+            c---d--e--f---g
+                |   _/|
+                h__/  |
+                |\ \  |
+            i---j-k-l-m---n
+                |     |
+                o     p
+            """
+
+        And the ways
+            | nodes | oneway | name  |
+            | ad    | yes    | down  |
+            | fb    | yes    | up    |
+            | gf    | yes    | left  |
+            | mn    | yes    | right |
+            | pm    | yes    | up    |
+            | jo    | yes    | down  |
+            | ij    | yes    | right |
+            | dc    | yes    | left  |
+            | dh    | yes    | down  |
+            | hj    | yes    | down  |
+            | jkl   | yes    | right |
+            | lm    | yes    | right |
+            | mf    | yes    | up    |
+            | fe    | yes    | left  |
+            | ed    | yes    | left  |
+
+        And the ways
+            | nodes | oneway | name    | highway | access | psv |
+            | kh    | yes    | service | service | no     | yes |
+            | lh    | no     | service | service | no     | yes |
+            | fh    | yes    | service | service | no     | yes |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction |
+            | restriction | hj       | jkl,lm     | mf     | no_u_turn   |
+            | restriction | lm       | mf         | fe     | no_u_turn   |
+            | restriction | mf       | fe,ed      | dh     | no_u_turn   |
+            | restriction | ed       | dh,hj      | jkl    | no_u_turn   |
+
+        When I route I should get
+            | from | to | route            |
+            | a    | b  |                  |
+            | a    | c  | down,left,left   |
+            | a    | o  | down,down        |
+            | a    | n  | down,right,right |
+            | i    | b  | right,up,up      |
+            | i    | c  |                  |
+            | i    | o  | right,down,down  |
+            | i    | n  | right,right      |
+            | p    | b  | up,up            |
+            | p    | c  | up,left,left     |
+            | p    | o  |                  |
+            | p    | n  | up,right,right   |
+            | g    | b  | left,up,up       |
+            | g    | c  | left,left        |
+            | g    | o  | left,down,down   |
+            | g    | n  |                  |
+
+
+    @restriction-way @overlap @no_turning
+    Scenario: Car - Junction with overlapping and duplicate multiple via restrictions
+    # Example: https://www.openstreetmap.org/#map=19/34.66291/33.01711
+        Given the profile file "car" initialized with
+        """
+        profile.properties.left_hand_driving = true
+        """
+
+        And the node map
+            """
+                a   b
+                |   |
+            c---d---e---f
+                |   |
+            g---h---i---j
+                |   |
+                k   l
+            """
+
+        And the nodes
+            | node | highway         |
+            | d    | traffic_signals |
+            | e    | traffic_signals |
+            | h    | traffic_signals |
+            | i    | traffic_signals |
+
+        And the ways
+            | nodes | oneway | name  |
+            | da    | yes    | up    |
+            | be    | yes    | down  |
+            | ef    | yes    | right |
+            | ji    | yes    | left  |
+            | il    | yes    | down  |
+            | kh    | yes    | up    |
+            | hg    | yes    | left  |
+            | cd    | yes    | right |
+            | hd    | yes    | up    |
+            | ih    | yes    | left  |
+            | ei    | yes    | down  |
+            | de    | yes    | right |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction  |
+            | restriction | be       | ei,ih      | hd     | no_u_turn    |
+            | restriction | ji       | ih,hd      | de     | no_u_turn    |
+            | restriction | kh       | hd,de      | ei     | no_u_turn    |
+            | restriction | cd       | de,ei      | ih     | no_u_turn    |
+            | restriction | hd       | de         | ei     | no_u_turn    |
+            | restriction | de       | ei         | ih     | no_u_turn    |
+            | restriction | ei       | ih         | hd     | no_u_turn    |
+            | restriction | ei       | ih,hd      | de     | no_u_turn    |
+            | restriction | ih       | hd         | de     | no_u_turn    |
+            | restriction | ih       | hd,de      | ei     | no_u_turn    |
+
+        When I route I should get
+            | from | to | route             |
+            | b    | a  |                   |
+            | b    | g  | down,left,left    |
+            | b    | l  | down,down         |
+            | b    | f  | down,right,right  |
+            | j    | a  | left,up,up        |
+            | j    | g  | left,left         |
+            | j    | l  | left,down,down    |
+            | j    | f  |                   |
+            | k    | a  | up,up             |
+            | k    | g  | up,left,left      |
+            | k    | l  |                   |
+            | k    | f  | up,right,right    |
+            | c    | a  | right,up,up       |
+            | c    | g  |                   |
+            | c    | l  | right,down,down   |
+            | c    | f  | right,right       |
+
+
+    @restriction-way @no_turning
+    Scenario: Car - Junction with multiple via restriction to side road, traffic lights
+    # Example: https://www.openstreetmap.org/#map=19/48.23662/16.42545
+        Given the node map
+            """
+            e---d
+                |
+            f---c---g
+                |
+            h---b---i
+                |
+                a
+            """
+
+       And the nodes
+            | node | highway         |
+            | c    | traffic_signals |
+            | b    | traffic_signals |
+
+        And the ways
+            | nodes | oneway | name  |
+            | ab    | no     | up    |
+            | bc    | no     | up    |
+            | cd    | no     | up    |
+            | de    | no     | left  |
+            | hb    | yes    | right |
+            | bi    | yes    | right |
+            | gc    | yes    | left  |
+            | cf    | yes    | left  |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction  |
+            | restriction | ab       | bc,cd      | de     | no_left_turn |
+
+        When I route I should get
+            | from | to | route           |
+            | a    | e  |                 |
+            | a    | f  | up,left,left    |
+            | a    | g  |                 |
+            | a    | h  |                 |
+            | a    | i  | up,right,right  |
+
+
+    @restriction-way @overlap @no_turning
+    Scenario: Car - Many overlapping multiple via restrictions, traffic signals
+    # Example: https://www.openstreetmap.org/#map=19/48.76987/11.43410
+        Given the node map
+            """
+             8                        5
+            p______a_______n________o__x
+           1|      |                |
+            |       \              /
+            r___q____b____        m
+            |         \   \___  _/    7
+            \          c      _l____k__w
+             s          \   _/    _/
+              \          _d/   __j
+               \       _/  \ _/
+               |   ___g     e_____i
+            v__t__/       _/ \   4
+             6          2/   3\
+                       f       h
+            """
+
+       And the nodes
+            | node | highway         |
+            | n    | traffic_signals |
+            | m    | traffic_signals |
+            | q    | traffic_signals |
+
+        And the ways
+            | nodes | oneway |
+            | on    | yes    |
+            | na    | yes    |
+            | ap    | yes    |
+            | pr    | yes    |
+            | rqb   | yes    |
+            | bl    | yes    |
+            | oml   | yes    |
+            | ld    | yes    |
+            | lk    | yes    |
+            | ba    | yes    |
+            | bcd   | no     |
+            | de    | no     |
+            | eh    | no     |
+            | ei    | no     |
+            | ejk   | yes    |
+            | rst   | yes    |
+            | dgt   | yes    |
+            | fe    | yes    |
+            | xo    | yes    |
+            | tv    | yes    |
+            | kw    | yes    |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction   |
+            | restriction | pr       | rqb,bcd    | dgt    | no_right_turn |
+            | restriction | rqb      | bcd,de     | ejk    | no_left_turn  |
+            | restriction | rqb      | bcd        | dgt    | no_right_turn |
+            | restriction | fe       | ed         | dgt    | no_u_turn     |
+            | restriction | fe       | ed,dcb     | bl     | no_right_turn |
+            | restriction | he       | ed,dcb     | bl     | no_right_turn |
+            | restriction | oml      | ld,de      | ejk    | no_u_turn     |
+
+        And the relations
+            | type        | way:from | node:via   | way:to | restriction   |
+            | restriction | ap       | p          | pr     | no_u_turn     |
+            | restriction | rqb      | b          | ba     | no_left_turn  |
+            | restriction | ld       | d          | dcb    | no_right_turn |
+            | restriction | oml      | l          | lk     | no_left_turn  |
+            | restriction | na       | a          | ab     | no_left_turn  |
+            | restriction | dcb      | b          | bl     | no_right_turn |
+            | restriction | dcb      | b          | bcd    | no_u_turn     |
+            | restriction | bcd      | d          | dcb    | no_u_turn     |
+            | restriction | bl       | l          | ld     | no_right_turn |
+
+        # Additional relations to prevent u-turns on small roads polluting the results
+        And the relations
+            | type        | way:from | node:via   | way:to | restriction   |
+            | restriction | eh       | h          | he     | no_u_turn     |
+            | restriction | ei       | i          | ie     | no_u_turn     |
+
+        When I route I should get
+            | from | to | route               | locations   |
+            | 1    | 6  | pr,rst,tv,tv        | _,r,t,_     |
+            | 1    | 3  | pr,rqb,bcd,de,eh,eh | _,r,b,d,e,_ |
+            | 1    | 4  | pr,rqb,bcd,de,ei,ei | _,r,b,d,e,_ |
+            | 1    | 7  | pr,rqb,bl,lk,kw,kw  | _,r,b,l,k,_ |
+            | 1    | 8  |                     |             |
+            | 2    | 6  |                     |             |
+            | 2    | 3  | fe,eh,eh            | _,e,_       |
+            | 2    | 4  | fe,ei,ei            | _,e,_       |
+            | 2    | 7  | fe,ejk,kw,kw        | _,e,k,_     |
+            | 2    | 8  | fe,de,bcd,ba,ap,ap  | _,e,d,b,a,_ |
+	    | 3    | 6  | eh,de,dgt,tv,tv     | _,e,d,t,_   |
+	    | 3    | 4  | eh,ei,ei            | _,e,_       |
+	    | 3    | 7  | eh,ejk,kw,kw        | _,e,k,_     |
+	    | 3    | 8  | eh,de,bcd,ba,ap,ap  | _,e,d,b,a,_ |
+	    | 4    | 6  | ei,de,dgt,tv,tv     | _,e,d,t,_   |
+	    | 4    | 3  | ei,eh,eh            | _,e,_       |
+	    | 4    | 7  | ei,ejk,kw,kw        | _,e,k,_     |
+	    | 4    | 8  | ei,de,bcd,ba,ap,ap  | _,e,d,b,a,_ |
+	    | 5    | 6  | xo,oml,ld,dgt,tv,tv | _,o,l,d,t,_ |
+	    | 5    | 3  | xo,oml,ld,de,eh,eh  | _,o,l,d,e,_ |
+	    | 5    | 4  | xo,oml,ld,de,ei,ei  | _,o,l,d,e,_ |
+	    | 5    | 7  |                     |             |
+	    | 5    | 8  | xo,on,na,ap,ap      | _,o,n,a,_   |
+
+
+
+    @restriction-way @overlap @no_turning
+    Scenario: Car - Multiple via restriction with start and end on same node
+    # Example: https://www.openstreetmap.org/#map=19/52.41988/16.96088
+        Given the node map
+            """
+            |--g---f---e
+            a      |   |
+            |--b---c---d
+
+            """
+
+       And the nodes
+            | node | highway         |
+            | b    | traffic_signals |
+
+        And the ways
+            | nodes | oneway | name  |
+            | abc   | yes    | enter |
+            | cd    | yes    | right |
+            | de    | yes    | up    |
+            | ef    | yes    | left  |
+            | fga   | yes    | exit  |
+            | fc    | yes    | down  |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction  |
+            | restriction | abc      | cd,de,ef   | fga    | no_u_turn    |
+
+        When I route I should get
+            | from | to | route                                            | locations           |
+            | a    | g  | enter,right,up,left,down,right,up,left,exit,exit | a,c,d,e,f,c,d,e,f,g |
+            | b    | a  | enter,right,up,left,down,right,up,left,exit,exit | b,c,d,e,f,c,d,e,f,a |
+        # This is a correct but not within the spirit of the restriction.
+        # Does this indicate the restriction is not strong enough?
+
+
+    @restriction-way @no_turning
+    Scenario: Car - Multiple via restriction preventing bypassing main road
+    # Example: https://www.openstreetmap.org/#map=19/48.72429/21.25912
+        Given the node map
+            """
+            a--b--c--d--e--f
+               \           |
+                --g--h--i--j
+                           |
+                           k
+            """
+
+       And the nodes
+            | node | highway         |
+            | d    | traffic_signals |
+            | e    | traffic_signals |
+
+        And the ways
+            | nodes | oneway | name  |
+            | ab    | yes    | main  |
+            | bc    | yes    | main  |
+            | cd    | yes    | main  |
+            | de    | yes    | main  |
+            | ef    | yes    | main  |
+            | bg    | yes    | side  |
+            | gh    | yes    | side  |
+            | hi    | yes    | side  |
+            | ij    | yes    | side  |
+            | fj    | yes    | turn  |
+            | jk    | yes    | turn  |
+
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction   |
+            | restriction | ab       | bg,gh,hi,ij | jk     | no_right_turn |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | k  | main,turn,turn |
+
+
+    @restriction-way @overlap @no_turning @only_turning
+    Scenario: Car - Multiple via restriction with to,via,from sharing same node
+    # Example: https://www.openstreetmap.org/relation/3972923
+        Given the node map
+            """
+                e---d
+                |   |
+            a---b---c
+                |
+                f
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+            | cd    | yes    |
+            | deb   | yes    |
+            | bf    | yes    |
+
+
+        And the relations
+            | type        | way:from | way:via     | way:to | restriction      |
+            | restriction | ab       | bc,cd,deb   | bf     | no_u_turn        |
+
+        And the relations
+            | type        | way:from | node:via    | way:to | restriction      |
+            | restriction | ab       | b           | bc     | only_straight_on |
+            | restriction | deb      | b           | bc     | no_left_turn     |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | f  |                |
+        # The last restriction is missing from OSM. Without it,
+        # it produces the route: ab,bc,cd,deb,bc,cd,deb,bf,bf
+
+
+    @restriction-way @except
+    Scenario: Car - Multiple via restriction, exception applies
+    # Example: https://www.openstreetmap.org/#map=19/50.04920/19.93251
+        Given the node map
+            """
+            a---b---c---d--e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+            | cd    | yes    |
+            | de    | yes    |
+
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction    | except   |
+            | restriction | ab       | bc,cd   | de     | no_straight_on | motorcar |
+
+        When I route I should get
+            | from | to | route          |
+            | a    | e  | ab,bc,cd,de,de |
+
+
+    @restriction-way @except @no_turning
+    Scenario: Car - Multiple via restriction, exception n/a
+    # Example: https://www.openstreetmap.org/#map=19/50.04920/19.93251
+        Given the node map
+            """
+            a---b---c---d--e
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+            | cd    | yes    |
+            | de    | yes    |
+
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction    | except        |
+            | restriction | ab       | bc,cd   | de     | no_straight_on | psv;emergency |
+
+        When I route I should get
+            | from | to | route |
+            | a    | e  |       |
+
+
+    @restriction-way @overlap @only_turning
+    Scenario: Car - Multiple via restriction overlapping single via restriction
+        Given the node map
+            """
+                    e
+                    |
+            a---b---c---d
+                |
+                f - g
+                |
+                h
+            """
+
+        And the ways
+            | nodes | name |
+            | ab    | abcd |
+            | bc    | abcd |
+            | cd    | abcd |
+            | hf    | hfb  |
+            | fb    | hfb  |
+            | gf    | gf   |
+            | ce    | ce   |
+
+        And the relations
+            | type        | way:from | way:via | way:to | restriction    |
+            | restriction | ab       | bc      | ce     | only_left_turn |
+            | restriction | gf       | fb,bc   | cd     | only_u_turn    |
+
+        When I route I should get
+            | from | to | route                  | turns                                                         | locations   |
+            | a    | d  | abcd,ce,ce,abcd,abcd   | depart,turn left,continue uturn,turn left,arrive              | a,c,e,c,d   |
+            | a    | e  | abcd,ce,ce             | depart,turn left,arrive                                       | a,c,e       |
+            | a    | f  | abcd,hfb,hfb           | depart,turn right,arrive                                      | a,b,f       |
+            | g    | e  | gf,hfb,abcd,abcd,ce,ce | depart,turn right,turn right,continue uturn,turn right,arrive | g,f,b,d,c,e |
+            | g    | d  | gf,hfb,abcd,abcd       | depart,turn right,turn right,arrive                           | g,f,b,d     |
+            | h    | e  | hfb,abcd,ce,ce         | depart,end of road right,turn left,arrive                     | h,b,c,e     |
+            | h    | d  | hfb,abcd,abcd          | depart,end of road right,arrive                               | h,b,d       |
+
+
+    @restriction-way
+    Scenario: Ambiguous from/to ways
+        Given the node map
+            """
+            a
+            |
+            b---d---e
+            |       |
+            c       f
+            """
+
+        And the ways
+            | nodes |
+            | abc   |
+            | bd    |
+            | de    |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction    |
+            | restriction | abc      | bd,de      | ef     | no_right_turn  |
+            | restriction | ef       | de,bd      | abc    | no_right_turn  |
+
+        When I route I should get
+            | from | to | route            | locations |
+	    | a    | f  | abc,bd,de,ef,ef  | a,b,d,e,f |
+	    | f    | a  | ef,de,bd,abc,abc | f,e,d,b,a |
+	    | c    | f  | abc,bd,de,ef,ef  | c,b,d,e,f |
+	    | f    | c  | ef,de,bd,abc,abc | f,e,d,b,c |
+
+
+    @restriction-way
+    Scenario: Ambiguous via ways
+        Given the node map
+            """
+            a
+            |
+            b---d---e---c
+                    |
+                    f
+            """
+
+        And the ways
+            | nodes |
+            | ab    |
+            | bd    |
+            | dec   |
+            | ef    |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction    |
+            | restriction | ab       | bd,dec     | ef     | no_right_turn  |
+            | restriction | ef       | dec,bd     | ab     | no_right_turn  |
+
+        When I route I should get
+            | from | to | route           | locations |
+	    | a    | f  | ab,bd,dec,ef,ef | a,b,d,e,f |
+	    | f    | a  | ef,dec,bd,ab,ab | f,e,d,b,a |
+
+
+    @restriction-way @invalid
+    Scenario: Badly tagged restrictions
+        Given the node map
+            """
+            a--b--c--d--e--f
+            """
+
+        And the ways
+            | nodes | oneway |
+            | ab    | yes    |
+            | bc    | yes    |
+            | cd    | yes    |
+            | de    | yes    |
+            | ef    | yes    |
+
+        And the relations
+            | type        | way:from | way:via    | way:to | restriction    |
+            | restriction | ab       | cd,de      | ef     | no_straight_on |
+            | restriction | ab       | bc,de      | ef     | no_straight_on |
+            | restriction | ab       | bc,cd      | ef     | no_straight_on |
+            | restriction | ef       | de,cd      | bc     | no_straight_on |
+
+        When I route I should get
+            | from | to | route             | locations   |
+	    | a    | f  | ab,bc,cd,de,ef,ef | a,b,c,d,e,f |
+
diff --git a/features/car/restrictions.feature b/features/car/restrictions.feature
index 80cb5b95e..da76f4ded 100644
--- a/features/car/restrictions.feature
+++ b/features/car/restrictions.feature
@@ -798,82 +798,6 @@ Feature: Car - Turn restrictions
             | from | to | route       |
             | a    | d  | ab,be,de,de |
 
-    @restriction-way
-    Scenario: Multi Way restriction
-        Given the node map
-            """
-                  k   j
-                  |   |
-            h - - g - f - - e
-                  |   |
-                  |   |
-            a - - b - c - - d
-                  |   |
-                  l   i
-            """
-
-        And the ways
-            | nodes | name  | oneway |
-            | ab    | horiz | yes    |
-            | bc    | horiz | yes    |
-            | cd    | horiz | yes    |
-            | ef    | horiz | yes    |
-            | fg    | horiz | yes    |
-            | gh    | horiz | yes    |
-            | ic    | vert  | yes    |
-            | cf    | vert  | yes    |
-            | fj    | vert  | yes    |
-            | kg    | vert  | yes    |
-            | gb    | vert  | yes    |
-            | bl    | vert  | yes    |
-
-        And the relations
-            | type        | way:from | way:via  | way:to | restriction |
-            | restriction | ab       | bc,cf,fg | gh     | no_u_turn   |
-
-        When I route I should get
-            | from | to | route                  |
-            | a    | h  | horiz,vert,horiz,horiz |
-
-    @restriction-way
-    Scenario: Multi-Way overlapping single-way
-        Given the node map
-            """
-                    e
-                    |
-            a - b - c - d
-                |
-                f - g
-                |
-                h
-            """
-
-        And the ways
-            | nodes | name |
-            | ab    | abcd |
-            | bc    | abcd |
-            | cd    | abcd |
-            | hf    | hfb  |
-            | fb    | hfb  |
-            | gf    | gf   |
-            | ce    | ce   |
-
-        And the relations
-            | type        | way:from | way:via | way:to | restriction    |
-            | restriction | ab       | bc      | ce     | only_left_turn |
-            | restriction | gf       | fb,bc   | cd     | only_u_turn    |
-
-        When I route I should get
-            | from | to | route                | turns                                            | locations |
-            | a    | d  | abcd,ce,ce,abcd,abcd | depart,turn left,continue uturn,turn left,arrive | a,c,e,c,d |
-            | a    | e  | abcd,ce,ce           | depart,turn left,arrive                          | a,c,e     |
-            | a    | f  | abcd,hfb,hfb         | depart,turn right,arrive                         | a,b,f     |
-            | g    | e  | gf,hfb,abcd,ce,ce    | depart,turn right,turn right,turn left,arrive    | g,f,b,c,e |
-            | g    | d  | gf,hfb,abcd,abcd     | depart,turn right,turn right,arrive              | g,f,b,d   |
-            | h    | e  | hfb,abcd,ce,ce       | depart,end of road right,turn left,arrive        | h,b,c,e   |
-            | h    | d  | hfb,abcd,abcd        | depart,end of road right,arrive                  | h,b,d     |
-
-
     @restriction-way
     Scenario: Car - prohibit turn, traffic lights
         Given the node map
@@ -984,8 +908,6 @@ Feature: Car - Turn restrictions
             | restriction | ab       | bge     | de     | no_right_turn |
             | restriction | bc       | bge     | ef     | no_left_turn  |
 
-        # this case is currently not handling the via-way restrictions and we need support for looking across traffic signals.
-        # It is mainly included to show limitations and to prove that we don't crash hard here
         When I route I should get
             | from | to | route              |
             | a    | d  | ab,bge,ef,ef,de,de |
diff --git a/features/car/speed.feature b/features/car/speed.feature
index bbbb67b6f..37d9f3512 100644
--- a/features/car/speed.feature
+++ b/features/car/speed.feature
@@ -9,29 +9,29 @@ Feature: Car - speeds
     Scenario: Car - speed of various way types
         Then routability should be
             | highway        | oneway | bothw   |
-            | motorway       | no     | 89 km/h |
-            | motorway_link  | no     | 44 km/h |
-            | trunk          | no     | 85 km/h |
-            | trunk_link     | no     | 39 km/h |
+            | motorway       | no     | 90 km/h |
+            | motorway_link  | no     | 45 km/h |
+            | trunk          | no     | 84 km/h |
+            | trunk_link     | no     | 40 km/h |
             | primary        | no     | 64 km/h |
-            | primary_link   | no     | 29 km/h |
-            | secondary      | no     | 55 km/h |
-            | secondary_link | no     | 24 km/h |
-            | tertiary       | no     | 39 km/h |
+            | primary_link   | no     | 30 km/h |
+            | secondary      | no     | 54 km/h |
+            | secondary_link | no     | 25 km/h |
+            | tertiary       | no     | 40 km/h |
             | tertiary_link  | no     | 20 km/h |
-            | unclassified   | no     | 24 km/h |
-            | residential    | no     | 24 km/h |
-            | living_street  | no     | 9 km/h  |
+            | unclassified   | no     | 25 km/h |
+            | residential    | no     | 25 km/h |
+            | living_street  | no     | 10 km/h  |
             | service        | no     | 15 km/h |
 
     # Alternating oneways scale rates but not speeds
     Scenario: Car - scaled speeds for oneway=alternating
         Then routability should be
             | highway        | oneway      | junction   | forw    | backw   | #              |
-            | tertiary       |             |            | 39 km/h | 39 km/h |                |
-            | tertiary       | alternating |            | 39 km/h | 39 km/h |                |
-            | motorway       |             |            | 89 km/h |         | implied oneway |
-            | motorway       | alternating |            | 89 km/h |         | implied oneway |
+            | tertiary       |             |            | 40 km/h | 40 km/h |                |
+            | tertiary       | alternating |            | 40 km/h | 40 km/h |                |
+            | motorway       |             |            | 90 km/h |         | implied oneway |
+            | motorway       | alternating |            | 90 km/h |         | implied oneway |
             | motorway       | reversible  |            |         |         | unroutable     |
             | primary        |             | roundabout | 64 km/h |         | implied oneway |
             | primary        | alternating | roundabout | 64 km/h |         | implied oneway |
@@ -42,12 +42,12 @@ Feature: Car - speeds
 
             | highway | maxspeed | forw    | backw    |
             | primary |          | 64 km/h | 64 km/h  |
-            | primary | 60       | 47 km/h | 47 km/h  |
-            | primary | 60       | 47 km/h | 47 km/h  |
-            | primary | 60       | 47 km/h | 47 km/h  |
+            | primary | 60       | 48 km/h | 48 km/h  |
+            | primary | 60       | 48 km/h | 48 km/h  |
+            | primary | 60       | 48 km/h | 48 km/h  |
 
     Scenario: Car - Side road penalties
         Then routability should be
 
             | highway | side_road | forw    | backw    | forw_rate | backw_rate |
-            | primary | yes       | 64 km/h | 64 km/h  | 14.4      | 14.4       |
+            | primary | yes       | 64 km/h | 64 km/h  | 14.5      | 14.5       |
diff --git a/features/car/startpoint.feature b/features/car/startpoint.feature
index 9e753843b..696f1ae31 100644
--- a/features/car/startpoint.feature
+++ b/features/car/startpoint.feature
@@ -53,8 +53,8 @@ Feature: Car - Allowed start/end modes
 
         When I request a travel time matrix I should get
             |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |
+            | 1 | 59.1 | 35.2 |
+            | b | 35   | 11.1 |
 
         When I route I should get
             | from | to | route    |
@@ -121,5 +121,5 @@ Feature: Car - Allowed start/end modes
 
         When I request a travel time matrix I should get
             |   | 2    | c    |
-            | 1 | 59.1 | 35.1 |
-            | b | 35.1 | 11.1 |
\ No newline at end of file
+            | 1 | 59.1 | 35.2 |
+            | b | 35   | 11.1 |
\ No newline at end of file
diff --git a/features/car/surface.feature b/features/car/surface.feature
index 8984a8e06..067e56500 100644
--- a/features/car/surface.feature
+++ b/features/car/surface.feature
@@ -65,7 +65,7 @@ Feature: Car - Surfaces
         Then routability should be
             | highway  | oneway | surface         | forw        | backw       |
             | motorway | no     |                 | 90 km/h     | 90 km/h     |
-            | motorway | no     | asphalt         | 90 km/h     | 90 km/h +-1 |
+            | motorway | no     | asphalt         | 91 km/h     | 90 km/h +-1 |
             | motorway | no     | concrete        | 90 km/h +-1 | 90 km/h +-1 |
             | motorway | no     | concrete:plates | 90 km/h +-1 | 90 km/h +-1 |
             | motorway | no     | concrete:lanes  | 90 km/h +-1 | 90 km/h +-1 |
diff --git a/features/car/traffic_light_penalties.feature b/features/car/traffic_light_penalties.feature
index e5bc313a0..e8961abb1 100644
--- a/features/car/traffic_light_penalties.feature
+++ b/features/car/traffic_light_penalties.feature
@@ -59,7 +59,7 @@ Feature: Car - Handle traffic lights
 
         When I route I should get
             | from | to | route   | geometry       |
-            | a    | c  | abc,abc | _ibE_ibE?gJ?gJ |
+            | a    | c  | abc,abc | _ibE_ibE?gJ?eJ |
 
     @traffic
     Scenario: Traffic update on the edge with a traffic signal
@@ -89,5 +89,5 @@ Feature: Car - Handle traffic lights
 
         When I route I should get
           | from | to | route   | speed   | weights | time  | distances | a:datasources | a:nodes | a:speed | a:duration |  a:weight |
-          | a    | c  | abc,abc | 59 km/h | 24.2,0  | 24.2s | 399.9m,0m |           1:0 |  1:2:3  |   18:18 |  11.1:11.1 | 11.1:11.1 |
-          | c    | a  | abc,abc | 59 km/h | 24.2,0  | 24.2s | 399.9m,0m |           0:1 |  3:2:1  |   18:18 |  11.1:11.1 | 11.1:11.1 |
+          | a    | c  | abc,abc | 60 km/h | 24.2,0  | 24.2s | 400m,0m   |           1:0 |  1:2:3  |   18:18 |  11.1:11.1 | 11.1:11.1 |
+          | c    | a  | abc,abc | 60 km/h | 24.2,0  | 24.2s | 400m,0m   |           0:1 |  3:2:1  |   18:18 |  11.1:11.1 | 11.1:11.1 |
diff --git a/features/car/weight.feature b/features/car/weight.feature
index 6bf7a1d6e..d7f02ac57 100644
--- a/features/car/weight.feature
+++ b/features/car/weight.feature
@@ -83,4 +83,4 @@ Feature: Car - weights
             | waypoints | bearings | route     | distance | weights   | times          |
             | a,b       | 90 90    | abc,abc   | 200m     | 200,0     | 11.1s,0s       |
             | b,c       | 90 90    | abc,abc   | 200m     | 200,0     | 11.1s,0s       |
-            | a,d       | 90 180   | abc,bd,bd | 399.9m   | 200,200,0 | 13.2s,11.1s,0s |
+            | a,d       | 90 180   | abc,bd,bd | 400m     | 200,200,0 | 13.2s,11.1s,0s |
diff --git a/features/foot/names.feature b/features/foot/names.feature
index c14b00b7f..8b8498c26 100644
--- a/features/foot/names.feature
+++ b/features/foot/names.feature
@@ -20,3 +20,20 @@ Feature: Foot - Street names in instructions
         When I route I should get
             | from | to | route    | ref    |
             | a    | c  | My Way,, | ,A7,A7 |
+
+
+    Scenario: Foot - Combines named roads with suffix changes
+        Given the node map
+            """
+            a b c d
+            """
+
+        And the ways
+            | nodes | name           |
+            | ab    | High Street W  |
+            | bc    | High Street E  |
+            | cd    | Market Street  |
+
+        When I route I should get
+            | from | to | route                                     |
+            | a    | d  | High Street W,Market Street,Market Street |
diff --git a/features/foot/restrictions.feature b/features/foot/restrictions.feature
index 5273a47b1..263aa6416 100644
--- a/features/foot/restrictions.feature
+++ b/features/foot/restrictions.feature
@@ -29,7 +29,7 @@ Feature: Foot - Turn restrictions
         When I route I should get
             | from | to | route    |
             | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
+            | s    | n  | sj,nj    |
             | s    | e  | sj,ej,ej |
 
     @only_turning
@@ -55,7 +55,7 @@ Feature: Foot - Turn restrictions
         When I route I should get
             | from | to | route    |
             | s    | w  | sj,wj,wj |
-            | s    | n  | sj,nj,nj |
+            | s    | n  | sj,nj    |
             | s    | e  | sj,ej,ej |
 
     @except
diff --git a/features/guidance/anticipate-lanes.feature b/features/guidance/anticipate-lanes.feature
index c082dc3c1..74f6f7d4c 100644
--- a/features/guidance/anticipate-lanes.feature
+++ b/features/guidance/anticipate-lanes.feature
@@ -103,7 +103,7 @@ Feature: Turn Lane Guidance
 
        When I route I should get
             | waypoints | route          | turns                                           | lanes                                                                 |
-            | a,d       | On,Hwy,Off,Off | depart,merge slight right,off ramp right,arrive | ,slight left:false slight left:true,straight:false slight right:true, |
+            | a,d       | On,Hwy,Off,Off | depart,merge slight right,off ramp right,arrive | ,slight left:true slight left:true,straight:false slight right:true,  |
 
 
     @anticipate
@@ -364,8 +364,8 @@ Feature: Turn Lane Guidance
 
           When I route I should get
                | waypoints | route            | turns                           | lanes                                                                                                                                                         |
-               | a,d       | main,left,left   | depart,end of road left,arrive  | ;left:false straight:false straight:true straight:false straight:false right:false;left:false straight:true straight:false right:false,left:true right:false, |
-               | a,e       | main,right,right | depart,end of road right,arrive | ;left:false straight:false straight:false straight:true straight:false right:false;left:false straight:false straight:true right:false,left:false right:true, |
+               | a,d       | main,left,left   | depart,end of road left,arrive  | ;left:false straight:true straight:true straight:true straight:true right:false;left:false straight:true straight:true right:false,left:true right:false,     |
+               | a,e       | main,right,right | depart,end of road right,arrive | ;left:false straight:true straight:true straight:true straight:true right:false;left:false straight:true straight:true right:false,left:false right:true,     |
 
        @anticipate
        Scenario: Anticipate Lanes for through with turn before / after
@@ -390,15 +390,15 @@ Feature: Turn Lane Guidance
                | il    |                                                              | il    |        |
 
           When I route I should get
-               | waypoints | route          | turns                                      | lanes                                                                                                                                                                                               | #           |
-               | a,f       | ab,bdehi,ef,ef | depart,turn right,turn right,arrive        | ,right:false right:false right:true right:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                             |             |
-               | a,g       | ab,bdehi,eg,eg | depart,turn right,turn left,arrive         | ,right:true right:true right:false right:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                             |             |
-               | a,j       | ab,bdehi,ij,ij | depart,turn right,end of road right,arrive | ,right:true right:true right:false right:false;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true, |             |
-               | a,l       | ab,bdehi,il,il | depart,turn right,end of road left,arrive  | ,right:false right:false right:true right:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false, | not perfect |
-               | c,g       | cb,bdehi,eg,eg | depart,turn left,turn left,arrive          | ,left:true left:true left:false left:false,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                                 |             |
-               | c,f       | cb,bdehi,ef,ef | depart,turn left,turn right,arrive         | ,left:false left:false left:true left:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                                 |             |
-               | c,l       | cb,bdehi,il,il | depart,turn left,end of road left,arrive   | ,left:false left:false left:true left:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false,     |             |
-               | c,j       | cb,bdehi,ij,ij | depart,turn left,end of road right,arrive  | ,left:true left:true left:false left:false;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true,     | not perfect |
+               | waypoints | route          | turns                                      | lanes                                                                                                                                                                                             | #           |
+               | a,f       | ab,bdehi,ef,ef | depart,turn right,turn right,arrive        | ,right:true right:true right:true right:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                             |             |
+               | a,g       | ab,bdehi,eg,eg | depart,turn right,turn left,arrive         | ,right:true right:true right:true right:true,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                             |             |
+               | a,j       | ab,bdehi,ij,ij | depart,turn right,end of road right,arrive | ,right:true right:true right:true right:true;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true, |             |
+               | a,l       | ab,bdehi,il,il | depart,turn right,end of road left,arrive  | ,right:true right:true right:true right:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false, | not perfect |
+               | c,g       | cb,bdehi,eg,eg | depart,turn left,turn left,arrive          | ,left:true left:true left:true left:true,left:true left:true straight:false straight:false straight:false straight:false right:false right:false,                                                 |             |
+               | c,f       | cb,bdehi,ef,ef | depart,turn left,turn right,arrive         | ,left:true left:true left:true left:true,left:false left:false straight:false straight:false straight:false straight:false right:true right:true,                                                 |             |
+               | c,l       | cb,bdehi,il,il | depart,turn left,end of road left,arrive   | ,left:true left:true left:true left:true;left:false left:false straight:true straight:true straight:false straight:false right:false right:false,left:true left:true right:false right:false,     |             |
+               | c,j       | cb,bdehi,ij,ij | depart,turn left,end of road right,arrive  | ,left:true left:true left:true left:true;left:false left:false straight:false straight:false straight:true straight:true right:false right:false,left:false left:false right:true right:true,     | not perfect |
 
        @anticipate
        Scenario: Anticipate Lanes for turns with through before and after
@@ -811,9 +811,9 @@ Feature: Turn Lane Guidance
             | hj    | 7th  |                    | no     |
 
         When I route I should get
-            | waypoints | route        | turns                    | locations | lanes                                                                                                                                                                                                                                                                                        |
-            | a,i       | road,road    | depart,arrive            | a,i       | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:false;none:true none:true right:false,     |
-            | a,j       | road,7th,7th | depart,turn right,arrive | a,h,j     | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:false none:false none:true;left:false none:false none:false none:true,none:false none:false right:true, |
+            | waypoints | route        | turns                    | locations | lanes                                                                                                                                                                                                                                                                                      |
+            | a,i       | road,road    | depart,arrive            | a,i       | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;none:true none:true right:false,    |
+            | a,j       | road,7th,7th | depart,turn right,arrive | a,h,j     | ;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:true none:true none:true;left:false none:false none:false none:true,none:false none:false right:true, |
 
     @anticipate
     Scenario: Oak St, Franklin St
diff --git a/features/guidance/dedicated-turn-roads.feature b/features/guidance/dedicated-turn-roads.feature
index 03213bd70..055f2af88 100644
--- a/features/guidance/dedicated-turn-roads.feature
+++ b/features/guidance/dedicated-turn-roads.feature
@@ -687,7 +687,7 @@ Feature: Slipways and Dedicated Turn Lanes
 
        When I route I should get
             | waypoints | route             | turns                                      | locations |
-            | s,f       | sabc,ae,dbef,dbef | depart,fork slight right,turn right,arrive | s,a,e,f   |
+            | s,f       | sabc,ae,dbef,dbef | depart,turn straight,turn right,arrive     | s,a,e,f   |
 
     @sliproads
     Scenario: Traffic Signal on Sliproad
diff --git a/features/guidance/merge-segregated-roads.feature b/features/guidance/merge-segregated-roads.feature
index 8134a2fc0..c802d4ade 100644
--- a/features/guidance/merge-segregated-roads.feature
+++ b/features/guidance/merge-segregated-roads.feature
@@ -64,7 +64,7 @@ Feature: Merge Segregated Roads
 
         When I route I should get
             | waypoints | route               | intersections                                                                                      |
-            | a,f       | road,road,road,road | true:90,false:45 true:135 false:270;true:45 true:180 false:315;true:90 false:225 true:315;true:270 |
+            | a,f       | road,road,road      | true:90,false:45 true:135 false:270;true:45 true:180 false:315,true:90 false:225 true:315;true:270 |
 
     #https://www.openstreetmap.org/#map=19/52.50003/13.33915
     @negative
@@ -193,7 +193,7 @@ Feature: Merge Segregated Roads
 
         When I route I should get
             | waypoints | route     | intersections                                                           |
-            | a,g       | road,road | true:90,false:90 true:150 false:270,true:90 false:270 true:345;true:270 |
+            | a,g       | road,road | true:90,false:90 true:165 false:270,true:90 false:270 true:345;true:270 |
 
     Scenario: Merging parallel roads with intermediate bridges
     # https://www.mapillary.com/app/?lat=52.466483333333336&lng=13.431908333333332&z=17&focus=photo&pKey=LWXnKqoGqUNLnG0lofiO0Q
diff --git a/features/guidance/obvious-turn-discovery.feature b/features/guidance/obvious-turn-discovery.feature
index fd846acef..0ad8a0845 100644
--- a/features/guidance/obvious-turn-discovery.feature
+++ b/features/guidance/obvious-turn-discovery.feature
@@ -277,7 +277,7 @@ Feature: Simple Turns
     When I route I should get
         | from | to | route       | turns                        |
         | a    | c  | menz,rem    | depart,arrive                |
-        | d    | c  | rem,rem,rem | depart,continue left,arrive  |
+        | d    | c  | rem,rem     | depart,arrive                |
         | c    | d  | rem,rem,rem | depart,continue right,arrive |
         | c    | a  | rem,menz    | depart,arrive                |
 
diff --git a/features/guidance/ramp.feature b/features/guidance/ramp.feature
index a4e823ded..560952d0b 100644
--- a/features/guidance/ramp.feature
+++ b/features/guidance/ramp.feature
@@ -160,8 +160,8 @@ Feature: Ramp Guidance
 
        When I route I should get
             | waypoints | route    | turns                          |
-            | a,d       | ab,bd,bd | depart,on ramp right,arrive |
-            | a,c       | ab,bc,bc | depart,turn left,arrive        |
+            | a,d       | ab,bd,bd | depart,on ramp right,arrive    |
+            | a,c       | ab,bc    | depart,arrive                  |
 
     Scenario: Fork Slight Ramp
         Given the node map
@@ -179,8 +179,8 @@ Feature: Ramp Guidance
 
        When I route I should get
             | waypoints | route    | turns                                 |
-            | a,d       | ab,bd,bd | depart,on ramp slight right,arrive |
-            | a,c       | ab,bc,bc | depart,turn slight left,arrive        |
+            | a,d       | ab,bd,bd | depart,on ramp slight right,arrive    |
+            | a,c       | ab,bc    | depart,arrive                         |
 
     Scenario: Fork Slight Ramp on Through Street
         Given the node map
diff --git a/features/guidance/roundabout.feature b/features/guidance/roundabout.feature
index 3b5610dcd..5245c310a 100644
--- a/features/guidance/roundabout.feature
+++ b/features/guidance/roundabout.feature
@@ -791,10 +791,10 @@ Feature: Basic Roundabout
         # the turn angles here are quite strange, so we do get uturns for exiting
         When I route I should get
             | from | to | route       | turns                                                 | distance |
-            | e    | f  | ed,af,af,af | depart,roundabout-exit-1,exit roundabout left,arrive  | 80.1m    |
-            | f    | e  | af,ed,ed,ed | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120.1m   |
-            | k    | l  | kg,hl,hl,hl | depart,roundabout-exit-1,exit roundabout right,arrive | 80.1m    |
-            | l    | k  | hl,kg,kg,kg | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120.1m   |
+            | e    | f  | ed,af,af,af | depart,roundabout-exit-1,exit roundabout left,arrive  | 80m      |
+            | f    | e  | af,ed,ed,ed | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120m     |
+            | k    | l  | kg,hl,hl,hl | depart,roundabout-exit-1,exit roundabout right,arrive | 80m      |
+            | l    | k  | hl,kg,kg,kg | depart,roundabout-exit-1,exit roundabout uturn,arrive | 120m     |
 
     @4030 @4075
     Scenario: Service roundabout with service exits
@@ -846,5 +846,5 @@ Feature: Basic Roundabout
 
         When I route I should get
             | from | to | route                      | turns                                                   | distance |
-            | e    | k  | ebds,ufghl,ufghl,jhik,jhik | depart,rstur-exit-2,exit rotary right,turn right,arrive | 189.1m   |
+            | e    | k  | ebds,ufghl,ufghl,jhik,jhik | depart,rstur-exit-2,exit rotary right,turn right,arrive | 189.2m   |
             | 1    | k  | ebds,ufghl,ufghl,jhik,jhik | depart,rstur-exit-2,exit rotary right,turn right,arrive | 159.1m   |
diff --git a/features/guidance/turn-lanes.feature b/features/guidance/turn-lanes.feature
index f34774e9e..1db63bfcb 100644
--- a/features/guidance/turn-lanes.feature
+++ b/features/guidance/turn-lanes.feature
@@ -836,9 +836,9 @@ Feature: Turn Lane Guidance
             | cf    | secondary | bottom |                    |
 
         When I route I should get
-            | waypoints | turns                                       | route               | lanes                        |
-            | a,d       | depart,continue right,continue right,arrive | road,road,road,road | ,straight:false right:true,, |
-            | d,a       | depart,continue left,continue left,arrive   | road,road,road,road | ,left:true straight:false,,  |
+            | waypoints | turns                        | route          | lanes                        |
+            | a,d       | depart,continue uturn,arrive | road,road,road | ,straight:false right:true;, |
+            | d,a       | depart,continue uturn,arrive | road,road,road | ,left:true straight:false;,  |
 
     @simple
     Scenario: Merge Lanes Onto Freeway
diff --git a/features/lib/osrm_loader.js b/features/lib/osrm_loader.js
index a29d53b8e..9d409f3d6 100644
--- a/features/lib/osrm_loader.js
+++ b/features/lib/osrm_loader.js
@@ -45,11 +45,12 @@ class OSRMBaseLoader{
         var retryCount = 0;
         let retry = (err) => {
           if (err) {
-            if (retryCount < 10) {
+            if (retryCount < this.scope.OSRM_CONNECTION_RETRIES) {
+              const timeoutMs = 10 * Math.pow(this.scope.OSRM_CONNECTION_EXP_BACKOFF_COEF, retryCount);
               retryCount++;
-              setTimeout(() => { tryConnect(this.scope.OSRM_IP, this.scope.OSRM_PORT, retry); }, 10);
+              setTimeout(() => { tryConnect(this.scope.OSRM_IP, this.scope.OSRM_PORT, retry); }, timeoutMs);
             } else {
-              callback(new Error("Could not connect to osrm-routed after ten retries."));
+              callback(new Error(`Could not connect to osrm-routed after ${this.scope.OSRM_CONNECTION_RETRIES} retries.`));
             }
           }
           else
diff --git a/features/options/extract/turn_function.feature b/features/options/extract/turn_function.feature
index a1db9339f..eecb29604 100644
--- a/features/options/extract/turn_function.feature
+++ b/features/options/extract/turn_function.feature
@@ -180,3 +180,30 @@ Feature: Turn Function Information
         And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 3, access_turn_classification: 0/
         # turning abc, give information about about db
         And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: false, highway_turn_classification: 0, access_turn_classification: 1/
+
+    Scenario: Turns should have correct information of two-way roads at intersection
+        Given the node map
+            """
+              b
+              |
+            a-c-d
+              |
+              e
+            """
+        And the ways
+            | nodes | highway       | oneway |
+            | ac    | motorway      | yes    |
+            | cd    | motorway_link | yes    |
+            | bc    | trunk         | yes    |
+            | cb    | trunk_link    | yes    |
+            | ce    | primary       | yes    |
+            | ec    | primary_link  | yes    |
+        And the data has been saved to disk
+
+        When I run "osrm-extract --profile {profile_file} {osm_file}"
+        Then it should exit successfully
+        # Turn acd
+        # on the left there should be cb (and bc)
+        And stdout should contain /roads_on_the_left \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: true, highway_turn_classification: [0-9]+, access_turn_classification: 0, priority_class: 3/
+        # on the right there should be ce and ec
+        And stdout should contain /roads_on_the_right \[1\] speed: [0-9]+, is_incoming: true, is_outgoing: true, highway_turn_classification: [0-9]+, access_turn_classification: 0, priority_class: 4/
diff --git a/features/raster/extract.feature b/features/raster/extract.feature
index 8f2514aef..ad35b9bac 100644
--- a/features/raster/extract.feature
+++ b/features/raster/extract.feature
@@ -20,6 +20,6 @@ Feature: osrm-extract with a profile containing raster source
         And the data has been saved to disk
         When I run "osrm-extract {osm_file} -p {profile_file}"
         Then stdout should contain "source loader"
-        Then stdout should contain "slope: 0.0899"
-        Then stdout should contain "slope: -0.0899"
+        Then stdout should contain "slope: 0.0904"
+        Then stdout should contain "slope: -0.0904"
         And it should exit successfully
diff --git a/features/step_definitions/routability.js b/features/step_definitions/routability.js
index 93aa9e41c..7c9c55d8f 100644
--- a/features/step_definitions/routability.js
+++ b/features/step_definitions/routability.js
@@ -1,6 +1,6 @@
-var util = require('util');
-var d3 = require('d3-queue');
-var classes = require('../support/data_classes');
+const util = require('util');
+const d3 = require('d3-queue');
+const classes = require('../support/data_classes');
 
 module.exports = function () {
     this.Then(/^routability should be$/, (table, callback) => {
@@ -115,8 +115,11 @@ module.exports = function () {
         var result = {};
 
         var testDirection = (dir, callback) => {
-            var a = new classes.Location(this.origin[0] + (1+this.WAY_SPACING*i) * this.zoom, this.origin[1]),
-                b = new classes.Location(this.origin[0] + (3+this.WAY_SPACING*i) * this.zoom, this.origin[1]),
+            const coordA = this.offsetOriginBy(1+this.WAY_SPACING*i, 0);
+            const coordB = this.offsetOriginBy(3+this.WAY_SPACING*i, 0);
+
+            var a = new classes.Location(coordA[0], coordA[1]),
+                b = new classes.Location(coordB[0], coordB[1]),
                 r = {};
 
             r.which = dir;
diff --git a/features/support/cache.js b/features/support/cache.js
index 2d9f99239..ccf6a8568 100644
--- a/features/support/cache.js
+++ b/features/support/cache.js
@@ -114,9 +114,12 @@ module.exports = function() {
         let dependencies = [
             this.OSRM_EXTRACT_PATH,
             this.OSRM_CONTRACT_PATH,
+            this.OSRM_CUSTOMIZE_PATH,
+            this.OSRM_PARTITION_PATH,
             this.LIB_OSRM_EXTRACT_PATH,
-            this.LIB_OSRM_GUIDANCE_PATH,
-            this.LIB_OSRM_CONTRACT_PATH
+            this.LIB_OSRM_CONTRACT_PATH,
+            this.LIB_OSRM_CUSTOMIZE_PATH,
+            this.LIB_OSRM_PARTITION_PATH
         ];
 
         var addLuaFiles = (directory, callback) => {
diff --git a/features/support/data.js b/features/support/data.js
index e9e1f06f4..6dd5fc545 100644
--- a/features/support/data.js
+++ b/features/support/data.js
@@ -9,17 +9,27 @@ const classes = require('./data_classes');
 const tableDiff = require('../lib/table_diff');
 const ensureDecimal = require('../lib/utils').ensureDecimal;
 const errorReason = require('../lib/utils').errorReason;
+const CheapRuler = require('cheap-ruler');
 
 module.exports = function () {
     this.setGridSize = (meters) => {
+        this.gridSize = parseFloat(meters);
+
         // the constant is calculated (with BigDecimal as: 1.0/(DEG_TO_RAD*EARTH_RADIUS_IN_METERS
         // see ApproximateDistance() in ExtractorStructs.h
         // it's only accurate when measuring along the equator, or going exactly north-south
-        this.zoom = parseFloat(meters) * 0.8990679362704610899694577444566908445396483347536032203503E-5;
+        this.zoom = this.gridSize * 0.8990679362704610899694577444566908445396483347536032203503E-5;
     };
 
     this.setOrigin = (origin) => {
         this.origin = origin;
+        // we use C++ version of `cheap-ruler` inside OSRM in order to do distance calculations,
+        // so here we use it too to have a bit more precise assertions
+        this.ruler = new CheapRuler(this.origin[1], 'meters');
+    };
+
+    this.offsetOriginBy = (xCells, yCells) => {
+        return this.ruler.offset(this.origin, xCells * this.gridSize, yCells * this.gridSize);
     };
 
     this.buildWaysFromTable = (table, callback) => {
@@ -35,9 +45,10 @@ module.exports = function () {
             // add some nodes
 
             var makeFakeNode = (namePrefix, offset) => {
+                const coord = this.offsetOriginBy(offset + this.WAY_SPACING * ri, 0);
                 return new OSM.Node(this.makeOSMId(), this.OSM_USER, this.OSM_TIMESTAMP,
-                    this.OSM_UID, this.origin[0]+(offset + this.WAY_SPACING * ri) * this.zoom,
-                    this.origin[1], {name: util.format('%s%d', namePrefix, ri)});
+                    this.OSM_UID, coord[0],
+                    coord[1], {name: util.format('%s%d', namePrefix, ri)});
             };
 
             var nodes = ['a','b','c','d','e'].map((l, i) => makeFakeNode(l, i));
@@ -98,7 +109,7 @@ module.exports = function () {
     };
 
     this.tableCoordToLonLat = (ci, ri) => {
-        return [this.origin[0] + ci * this.zoom, this.origin[1] - ri * this.zoom].map(ensureDecimal);
+        return this.offsetOriginBy(ci, -ri).map(ensureDecimal);
     };
 
     this.addOSMNode = (name, lon, lat, id) => {
diff --git a/features/support/env.js b/features/support/env.js
index 9b4c5acc9..eaa25fbc5 100644
--- a/features/support/env.js
+++ b/features/support/env.js
@@ -40,6 +40,9 @@ module.exports = function () {
 
         this.OSRM_PORT = process.env.OSRM_PORT && parseInt(process.env.OSRM_PORT) || 5000;
         this.OSRM_IP = process.env.OSRM_IP || '127.0.0.1';
+        this.OSRM_CONNECTION_RETRIES = process.env.OSRM_CONNECTION_RETRIES && parseInt(process.env.OSRM_CONNECTION_RETRIES) || 10;
+        this.OSRM_CONNECTION_EXP_BACKOFF_COEF = process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF && parseFloat(process.env.OSRM_CONNECTION_EXP_BACKOFF_COEF) || 1.0;
+        
         this.HOST = `http://${this.OSRM_IP}:${this.OSRM_PORT}`;
 
         this.OSRM_PROFILE = process.env.OSRM_PROFILE;
@@ -67,10 +70,13 @@ module.exports = function () {
 
         this.OSRM_EXTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-extract', this.EXE));
         this.OSRM_CONTRACT_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-contract', this.EXE));
+        this.OSRM_CUSTOMIZE_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-customize', this.EXE));
+        this.OSRM_PARTITION_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-partition', this.EXE));
         this.OSRM_ROUTED_PATH = path.resolve(util.format('%s/%s%s', this.BIN_PATH, 'osrm-routed', this.EXE));
         this.LIB_OSRM_EXTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_extract'),
-        this.LIB_OSRM_GUIDANCE_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_guidance'),
         this.LIB_OSRM_CONTRACT_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_contract'),
+        this.LIB_OSRM_CUSTOMIZE_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_customize'),
+        this.LIB_OSRM_PARTITION_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm_partition'),
         this.LIB_OSRM_PATH = util.format('%s/' + this.LIB, this.BIN_PATH, 'osrm');
 
         // eslint-disable-next-line no-console
@@ -111,7 +117,7 @@ module.exports = function () {
         };
 
         var q = d3.queue();
-        [this.OSRM_EXTRACT_PATH, this.OSRM_CONTRACT_PATH, this.OSRM_ROUTED_PATH].forEach(bin => { q.defer(verify, bin); });
+        [this.OSRM_EXTRACT_PATH, this.OSRM_CONTRACT_PATH, this.OSRM_CUSTOMIZE_PATH, this.OSRM_PARTITION_PATH, this.OSRM_ROUTED_PATH].forEach(bin => { q.defer(verify, bin); });
         q.awaitAll(callback);
     };
 
diff --git a/features/testbot/annotations.feature b/features/testbot/annotations.feature
index 706eb9504..5e31be73a 100644
--- a/features/testbot/annotations.feature
+++ b/features/testbot/annotations.feature
@@ -115,4 +115,4 @@ Feature: Annotations
 
         When I route I should get
             | from | to | route    | a:speed | a:distance            | a:duration | a:nodes |
-            | a    | c  | abc,abc  | 10:10   | 249.998641:299.931643 | 25:30      | 1:2:3   |
+            | a    | c  | abc,abc  | 10:10   | 249.987619:299.962882 | 25:30      | 1:2:3   |
diff --git a/features/testbot/bearing_param.feature b/features/testbot/bearing_param.feature
index ec6708a70..227324bff 100644
--- a/features/testbot/bearing_param.feature
+++ b/features/testbot/bearing_param.feature
@@ -108,12 +108,12 @@ Feature: Bearing parameter
             | ha    | yes    | ring |
 
         When I route I should get
-            | from | to | bearings | route                       | bearing                                   |
-            |    0 | q  | 0 90     | ia,ring,ring,ring,ring,ring | 0->0,0->90,180->270,270->0,0->90,90->0    |
-            |    0 | a  | 45 90    | jb,ring,ring,ring,ring,ring | 0->45,45->180,180->270,270->0,0->90,90->0 |
-            |    0 | q  | 90 90    | kc,ring,ring,ring,ring      | 0->90,90->180,270->0,0->90,90->0          |
-            |    0 | a  | 135 90   | ld,ring,ring,ring,ring      | 0->135,135->270,270->0,0->90,90->0        |
-            |    0 | a  | 180 90   | me,ring,ring,ring,ring      | 0->180,180->270,270->0,0->90,90->0        |
-            |    0 | a  | 225 90   | nf,ring,ring,ring           | 0->225,225->0,0->90,90->0                 |
-            |    0 | a  | 270 90   | og,ring,ring,ring           | 0->270,270->0,0->90,90->0                 |
-            |    0 | a  | 315 90   | ph,ring,ring                | 0->315,315->90,90->0                      |
+            | from | to | bearings | route                            | bearing                                        |
+            |    0 | q  | 0 90     | ia,ring,ring,ring,ring,ring,ring | 0->0,0->90,90->180,180->270,270->0,0->90,90->0 |
+            |    0 | a  | 45 90    | jb,ring,ring,ring,ring,ring      | 0->45,45->180,180->270,270->0,0->90,90->0      |
+            |    0 | q  | 90 90    | kc,ring,ring,ring,ring,ring      | 0->90,90->180,180->270,270->0,0->90,90->0      |
+            |    0 | a  | 135 90   | ld,ring,ring,ring,ring           | 0->135,135->270,270->0,0->90,90->0             |
+            |    0 | a  | 180 90   | me,ring,ring,ring                | 0->180,180->270,0->90,90->0                    |
+            |    0 | a  | 225 90   | nf,ring,ring,ring                | 0->225,225->0,0->90,90->0                      |
+            |    0 | a  | 270 90   | og,ring,ring                     | 0->270,270->0,90->0                            |
+            |    0 | a  | 315 90   | ph,ring,ring                     | 0->315,315->90,90->0                           |
diff --git a/features/testbot/compression.feature b/features/testbot/compression.feature
index 033cc3335..da8c0cdef 100644
--- a/features/testbot/compression.feature
+++ b/features/testbot/compression.feature
@@ -20,5 +20,5 @@ Feature: Geometry Compression
 
         When I route I should get
             | from | to | route         | distance | speed   |
-            | b    | e  | abcdef,abcdef | 588.5m   | 36 km/h |
-            | e    | b  | abcdef,abcdef | 588.5m   | 36 km/h |
+            | b    | e  | abcdef,abcdef | 588.7m   | 36 km/h |
+            | e    | b  | abcdef,abcdef | 588.7m   | 36 km/h |
diff --git a/features/testbot/distance.feature b/features/testbot/distance.feature
index 1b76f45a6..50595b087 100644
--- a/features/testbot/distance.feature
+++ b/features/testbot/distance.feature
@@ -90,8 +90,8 @@ Feature: Distance calculation
             | b    | a  | abc,abc | 100m     |
             | b    | c  | abc,abc | 100m     |
             | c    | b  | abc,abc | 100m     |
-            | a    | c  | abc,abc | 200m     |
-            | c    | a  | abc,abc | 200m     |
+            | a    | c  | abc,abc | 199.9m   |
+            | c    | a  | abc,abc | 199.9m   |
 
     Scenario: 1km distance
         Given a grid size of 1000 meters
@@ -134,7 +134,7 @@ Feature: Distance calculation
             | a    | c  | abcdefgh,abcdefgh | 20m      |
             | a    | d  | abcdefgh,abcdefgh | 30m      |
             | a    | e  | abcdefgh,abcdefgh | 40m      |
-            | a    | f  | abcdefgh,abcdefgh | 50m      |
+            | a    | f  | abcdefgh,abcdefgh | 50.1m    |
             | a    | g  | abcdefgh,abcdefgh | 60m +-1  |
             | a    | h  | abcdefgh,abcdefgh | 70m +-1  |
 
@@ -154,9 +154,9 @@ Feature: Distance calculation
             | from | to | route             | distance |
             | a    | b  | abcdefgh,abcdefgh | 10m      |
             | a    | c  | abcdefgh,abcdefgh | 20m      |
-            | a    | d  | abcdefgh,abcdefgh | 30m      |
-            | a    | e  | abcdefgh,abcdefgh | 40m      |
-            | a    | f  | abcdefgh,abcdefgh | 50m      |
+            | a    | d  | abcdefgh,abcdefgh | 29.9m    |
+            | a    | e  | abcdefgh,abcdefgh | 39.9m    |
+            | a    | f  | abcdefgh,abcdefgh | 49.9m    |
             | a    | g  | abcdefgh,abcdefgh | 60m +-1  |
             | a    | h  | abcdefgh,abcdefgh | 70m +-1  |
 
diff --git a/features/testbot/distance_matrix.feature b/features/testbot/distance_matrix.feature
index 6ac1ce21b..c1340146f 100644
--- a/features/testbot/distance_matrix.feature
+++ b/features/testbot/distance_matrix.feature
@@ -22,10 +22,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   |    a    |    b    |     e   |   f    |
-            | a |    0    |  100.1  |  199.5  |  299.5 |
-            | b |  100.1  |   0     |  99.4   |  199.5 |
-            | e |  199.5  |  99.4   |   0     |  100.1 |
-            | f |  299.5  |  199.5  |  100.1  |   0    |
+            | a |    0    |  100    |  199.9  |  300   |
+            | b |  100    |   0     |  100    |  200   |
+            | e |  199.9  |  100    |   0     |  100.1 |
+            | f |  300    |  200    |  100.1  |   0    |
 
     Scenario: Testbot - Travel distance matrix of minimal network exact distances
         Given the node map
@@ -43,11 +43,11 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   |   a    |   z     |   b     |   c     |   d     |
-            | a |   0    |  100.1  |  199.5  |  298.9  |  398.3  |
-            | z |  100.1 |  0      |  99.4   |  198.8  |  298.2  |
-            | b |  199.5 |  99.4   |  0      |  99.4   |  198.8  |
-            | c |  298.9 |  198.8  |  99.4   |  0      |  99.4   |
-            | d |  398.3 |  298.2  |  198.8  |  99.4   |  0      |
+            | a |   0    |  100    |  199.9  |  300    |  399.9  |
+            | z |  100   |  0      |  100    |  200    |  300    |
+            | b |  199.9 |  100    |  0      |  100.1  |  200    |
+            | c |  300   |  200    |  100.1  |  0      |  100    |
+            | d |  399.9 |  300    |  200    |  100    |  0      |
 
     Scenario: Testbot - Travel distance matrix of minimal network with toll exclude
         Given the query options
@@ -68,10 +68,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a     | b     | c     | d     |
-            | a | 0     | 100.1 |       |       |
-            | b | 100.1 | 0     |       |       |
-            | c |       |       | 0     | 100.1 |
-            | d |       |       | 100.1 | 0     |
+            | a | 0     | 100   |       |       |
+            | b | 100   | 0     |       |       |
+            | c |       |       | 0     | 100   |
+            | d |       |       | 100   | 0     |
 
     Scenario: Testbot - Travel distance matrix of minimal network with motorway exclude
         Given the query options
@@ -92,7 +92,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a |   b    |  c   |   d   |
-            | a | 0 |  298.9 | 99.4 | 199.5 |
+            | a | 0 |  299.9 | 100  | 199.9 |
 
     Scenario: Testbot - Travel distance matrix of minimal network disconnected motorway exclude
         Given the query options
@@ -113,7 +113,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b    | e |
-            | a | 0 | 50.1 |   |
+            | a | 0 | 50   |   |
 
     Scenario: Testbot - Travel distance matrix of minimal network with motorway and toll excludes
         Given the query options
@@ -134,7 +134,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b      | e | g |
-            | a | 0 | 100.1  |   |   |
+            | a | 0 | 100    |   |   |
 
     Scenario: Testbot - Travel distance matrix with different way speeds
         Given the node map
@@ -150,21 +150,21 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a     | b     | c     | d     |
-            | a | 0     | 100.1 | 200.1 | 300.2 |
-            | b | 100.1 | 0     | 100.1 | 200.1 |
-            | c | 200.1 | 100.1 | 0     | 100.1 |
-            | d | 300.2 | 200.1 | 100.1 | 0     |
+            | a | 0     | 100   | 200   | 300   |
+            | b | 100   | 0     | 100.1 | 200   |
+            | c | 200   | 100.1 | 0     | 100   |
+            | d | 300   | 200   | 100   | 0     |
 
         When I request a travel distance matrix I should get
             |   | a | b     | c     | d     |
-            | a | 0 | 100.1 | 200.1 | 300.2 |
+            | a | 0 | 100   | 200   | 300   |
 
         When I request a travel distance matrix I should get
             |   | a     |
             | a | 0     |
-            | b | 100.1 |
-            | c | 200.1 |
-            | d | 300.2 |
+            | b | 100   |
+            | c | 200   |
+            | d | 300   |
 
     Scenario: Testbot - Travel distance matrix of small grid
         Given the node map
@@ -183,10 +183,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a     | b     | e     | f     |
-            | a | 0     | 100.1 | 199.5 | 299.5 |
-            | b | 100.1 | 0     | 99.4  | 199.5 |
-            | e | 199.5 | 99.4  | 0     | 100.1 |
-            | f | 299.5 | 199.5 | 100.1 | 0     |
+            | a | 0     | 100   | 199.9 | 300   |
+            | b | 100   | 0     | 100   | 200   |
+            | e | 199.9 | 100   | 0     | 100.1 |
+            | f | 300   | 200   | 100.1 | 0     |
 
     Scenario: Testbot - Travel distance matrix of network with unroutable parts
         Given the node map
@@ -200,7 +200,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b      |
-            | a | 0 | 100.1  |
+            | a | 0 | 100    |
             | b |   | 0      |
 
     Scenario: Testbot - Travel distance matrix of network with oneways
@@ -218,10 +218,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | x     | y     | d     | e     |
-            | x | 0     | 300.2 | 399.6 | 299.5 |
-            | y | 499   | 0     | 299.5 | 199.5 |
-            | d | 199.5 | 299.5 | 0     | 298.9 |
-            | e | 299.5 | 399.6 | 100.1 | 0     |
+            | x | 0     | 300   | 400   | 300   |
+            | y | 499.9 | 0     | 300   | 199.9 |
+            | d | 199.9 | 300   | 0     | 300   |
+            | e | 300   | 400   | 100.1 | 0     |
 
     Scenario: Testbot - Rectangular travel distance matrix
         Given the node map
@@ -240,53 +240,53 @@ Feature: Basic Distance Matrix
 
         When I route I should get
             | from | to | distance  |
-            | e    | a  | 200m      |
+            | e    | a  | 199.9m    |
             | e    | b  | 100m      |
-            | f    | a  | 299.9m    |
+            | f    | a  | 300m      |
             | f    | b  | 200m      |
 
         When I request a travel distance matrix I should get
             |   | a | b      | e      | f      |
-            | a | 0 |  100.1 |  199.5 |  299.5 |
+            | a | 0 |  100   | 199.9  |  300   |
 
         When I request a travel distance matrix I should get
             |   | a     |
             | a | 0     |
-            | b | 100.1 |
-            | e | 199.5 |
-            | f | 299.5 |
+            | b | 100   |
+            | e | 199.9 |
+            | f | 300   |
 
         When I request a travel distance matrix I should get
             |   | a     | b     | e     | f     |
-            | a | 0     | 100.1 | 199.5 | 299.5 |
-            | b | 100.1 | 0     | 99.4  | 199.5 |
+            | a | 0     | 100   | 199.9 | 300   |
+            | b | 100   | 0     | 100   | 200   |
 
         When I request a travel distance matrix I should get
             |   | a     | b     |
-            | a | 0     | 100.1 |
-            | b | 100.1 | 0     |
-            | e | 199.5 | 99.4  |
-            | f | 299.5 | 199.5 |
+            | a | 0     | 100   |
+            | b | 100   | 0     |
+            | e | 199.9 | 100   |
+            | f | 300   | 200   |
 
         When I request a travel distance matrix I should get
             |   | a     | b     | e     | f     |
-            | a | 0     | 100.1 | 199.5 | 299.5 |
-            | b | 100.1 | 0     | 99.4  | 199.5 |
-            | e | 199.5 | 99.4  | 0     | 100.1 |
+            | a | 0     | 100   | 199.9 | 300   |
+            | b | 100   | 0     | 100   | 200   |
+            | e | 199.9 | 100   | 0     | 100.1 |
 
         When I request a travel distance matrix I should get
              |   | a     | b     | e     |
-             | a | 0     | 100.1 | 199.5 |
-             | b | 100.1 | 0     | 99.4  |
-             | e | 199.5 | 99.4  | 0     |
-             | f | 299.5 | 199.5 | 100.1 |
+             | a | 0     | 100   | 199.9 |
+             | b | 100   | 0     | 100   |
+             | e | 199.9 | 100   | 0     |
+             | f | 300   | 200   | 100.1 |
 
         When I request a travel distance matrix I should get
              |   | a     | b     | e     | f     |
-             | a | 0     | 100.1 | 199.5 | 299.5 |
-             | b | 100.1 | 0     | 99.4  | 199.5 |
-             | e | 199.5 | 99.4  | 0     | 100.1 |
-             | f | 299.5 | 199.5 | 100.1 | 0     |
+             | a | 0     | 100   | 199.9 | 300   |
+             | b | 100   | 0     | 100   | 200   |
+             | e | 199.9 | 100   | 0     | 100.1 |
+             | f | 300   | 200   | 100.1 | 0     |
 
      Scenario: Testbot - Travel distance 3x2 matrix
         Given the node map
@@ -306,8 +306,8 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | b     | e     | f     |
-            | a | 100.1 | 199.5 | 299.5 |
-            | b | 0     | 99.4  | 199.5 |
+            | a | 100   | 199.9 | 300   |
+            | b | 0     | 100   | 200   |
 
     Scenario: Testbot - All coordinates are from same small component
         Given a grid size of 300 meters
@@ -328,8 +328,8 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | f     | g     |
-            | f | 0     | 298.2 |
-            | g | 298.2 | 0     |
+            | f | 0     | 300   |
+            | g | 300   | 0     |
 
     Scenario: Testbot - Coordinates are from different small component and snap to big CC
         Given a grid size of 300 meters
@@ -362,10 +362,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | f     | g     | h     | i     |
-            | f | 0     | 298.2 | 0     | 298.2 |
-            | g | 298.2 | 0     | 298.2 | 0     |
-            | h | 0     | 298.2 | 0     | 298.2 |
-            | i | 298.2 | 0     | 298.2 | 0     |
+            | f | 0     | 300   | 0     | 300   |
+            | g | 300   | 0     | 300   | 0     |
+            | h | 0     | 300   | 0     | 300   |
+            | i | 300   | 0     | 300   | 0     |
 
     Scenario: Testbot - Travel distance matrix with loops
         Given the node map
@@ -383,10 +383,10 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | 1     | 2     | 3     | 4     |
-            | 1 | 0     | 100.1 | 399.6 | 499.7 |
-            | 2 | 699.1 | 0     | 299.5 | 399.6 |
-            | 3 | 399.6 | 499.7 | 0     | 100.1 |
-            | 4 | 299.5 | 399.6 | 699.1 | 0     |
+            | 1 | 0     | 100.1 | 399.9 | 500   |
+            | 2 | 699.8 | 0     | 299.9 | 399.9 |
+            | 3 | 399.9 | 500   | 0     | 100.1 |
+            | 4 | 299.9 | 399.9 | 699.8 | 0     |
 
 
     Scenario: Testbot - Travel distance matrix based on segment durations
@@ -424,11 +424,11 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a     | b     | c     | d     | e     |
-            | a | 0     | 100.1 | 200.1 | 300.2 | 398.9 |
-            | b | 100.1 | 0     | 100.1 | 200.1 | 298.9 |
-            | c | 200.1 | 100.1 | 0     | 100.1 | 198.8 |
-            | d | 300.2 | 200.1 | 100.1 | 0     | 298.9 |
-            | e | 398.9 | 298.9 | 198.8 | 298.9 | 0     |
+            | a | 0     | 100   | 200   | 300   | 400   |
+            | b | 100   | 0     | 100.1 | 200   | 300.1 |
+            | c | 200   | 100.1 | 0     | 100   | 200   |
+            | d | 300   | 200   | 100   | 0     | 300   |
+            | e | 400   | 300.1 | 200   | 300   | 0     |
 
     Scenario: Testbot - Travel distance matrix for alternative loop paths
         Given the profile file
@@ -468,25 +468,25 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
              |   | 1     | 2      | 3     | 4      | 5     | 6      | 7     | 8      |
-             | 1 | 0     | 1096.7 | 298.9 | 199.5  | 598.4 | 498.3  | 897.3 | 797.9  |
-             | 2 | 100.1 | 0      | 398.9 | 299.5  | 698.5 | 598.4  | 997.3 | 897.9  |
-             | 3 | 897.9 | 797.9  | 0     | 1097.4 | 299.5 | 199.5  | 598.4 | 499    |
-             | 4 | 997.3 | 897.3  | 99.4  | 0      | 398.9 | 298.9  | 697.8 | 598.4  |
-             | 5 | 598.4 | 498.3  | 897.3 | 797.9  | 0     | 1096.7 | 298.9 | 199.5  |
-             | 6 | 698.5 | 598.4  | 997.3 | 897.9  | 100.1 | 0      | 398.9 | 299.5  |
-             | 7 | 299.5 | 199.5  | 598.4 | 499    | 897.9 | 797.9  | 0     | 1097.4 |
-             | 8 | 398.9 | 298.9  | 697.8 | 598.4  | 997.3 | 897.3  | 99.4  | 0      |
+             | 1 | 0     | 1099.8 | 300   | 199.9  | 600   | 499.9  | 899.9 | 799.9  |
+             | 2 | 100.1 | 0      | 400   | 300    | 700   | 600    | 1000  | 899.9  |
+             | 3 | 899.9 | 799.9  | 0     | 1099.8 | 300   | 199.9  | 600   | 499.9  |
+             | 4 | 1000  | 899.9  | 100.1 | 0      | 400   | 300    | 700   | 600    |
+             | 5 | 600   | 499.9  | 899.9 | 799.9  | 0     | 1099.8 | 300   | 199.9  |
+             | 6 | 700   | 600    | 1000  | 899.9  | 100.1 | 0      | 400   | 300    |
+             | 7 | 300   | 199.9  | 600   | 499.9  | 899.9 | 799.9  | 0     | 1099.8 |
+             | 8 | 400   | 300    | 700   | 600    | 1000  | 899.9  | 100.1 | 0      |
 
         When I request a travel distance matrix I should get
              |   | 1     |
              | 1 | 0     |
              | 2 | 100.1 |
-             | 3 | 897.9 |
-             | 4 | 997.3 |
-             | 5 | 598.4 |
-             | 6 | 698.5 |
-             | 7 | 299.5 |
-             | 8 | 398.9 |
+             | 3 | 899.9 |
+             | 4 | 1000  |
+             | 5 | 600   |
+             | 6 | 700   |
+             | 7 | 300   |
+             | 8 | 400   |
 
     Scenario: Testbot - Travel distance matrix with ties
         Given the node map
@@ -511,23 +511,23 @@ Feature: Basic Distance Matrix
             | from | to | route    | distance |
             | a    | b  | ab,ab    | 450m     |
             | a    | c  | ac,ac    | 200m     |
-            | a    | d  | ac,dc,dc | 499.9m   |
+            | a    | d  | ac,dc,dc | 500m     |
 
         When I request a travel distance matrix I should get
             |   | a | b     | c     | d   |
-            | a | 0 | 450.3 | 198.8 | 499 |
+            | a | 0 | 450   | 200   | 500 |
 
         When I request a travel distance matrix I should get
             |   | a     |
             | a | 0     |
-            | b | 450.3 |
-            | c | 198.8 |
-            | d | 499   |
+            | b | 450   |
+            | c | 200   |
+            | d | 500   |
 
         When I request a travel distance matrix I should get
             |   | a     | c     |
-            | a | 0     | 198.8 |
-            | c | 198.8 | 0     |
+            | a | 0     | 200   |
+            | c | 200   | 0     |
 
 
     # Check rounding errors
@@ -544,7 +544,7 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a | b      | c      | d      |
-            | a | 0 | 1000.7 | 2001.4 | 3002.1 |
+            | a | 0 | 1000.1 | 2000 | 3000.1 |
 
 
     Scenario: Testbot - OneToMany vs ManyToOne
@@ -562,12 +562,12 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   |   a   | b      |
-            | b | 240.4 | 0      |
+            | b | 241.3 | 0      |
 
         When I request a travel distance matrix I should get
             |   |   a   |
             | a |   0   |
-            | b | 240.4 |
+            | b | 241.3 |
 
     Scenario: Testbot - Varying distances between nodes
         Given the node map
@@ -589,12 +589,13 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a      | b     | c      | d      | e      | f      |
-            | a | 0      | 100.1 | 300.2  | 650.5  | 1930.6 | 1533   |
-            | b | 759    | 0     | 200.1  | 550.4  | 1830.5 | 1432.9 |
-            | c | 558.8  | 658.9 | 0      | 350.3  | 1630.4 | 1232.8 |
-            | d | 1478.9 | 1579  | 1779.1 | 0      | 1280.1 | 882.5  |
-            | e | 198.8  | 298.9 | 499    | 710.3  | 0      | 1592.8 |
-            | f | 596.4  | 696.5 | 896.6  | 1107.9 | 397.6  | 0      |
+            | a | 0      | 100   | 300    | 650    | 1934.5 | 1534.6 |
+            | b | 760.6  | 0     | 200    | 550.1  | 1834.6 | 1434.6 |
+            | c | 560.6  | 660.5 | 0      | 350    | 1634.6 | 1234.6 |
+            | d | 1484.6 | 1584.5| 1784.5 | 0      | 1284.5 | 884.6  |
+            | e | 200    | 300   | 500    | 710.6  | 0      | 1595.2 |
+            | f | 600    | 699.9 | 899.9  | 1110.5 | 399.9  | 0      |
+
 
     Scenario: Testbot - Filling in noroutes with estimates (defaults to input coordinate location)
         Given a grid size of 300 meters
@@ -614,21 +615,21 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a      | b      | f     | 1      |
-            | a | 0      | 300.2  | 900.7 | 1501.1 |
-            | b | 300.2  | 0      | 600.5 | 1200.9 |
-            | f | 900.7  | 600.5  | 0     | 300.2  |
-            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |
+            | a | 0      | 300    | 900   | 1500   |
+            | b | 300    | 0      | 600   | 1200.1 |
+            | f | 900    | 600    | 0     | 300    |
+            | 1 | 1500   | 1200.1 | 300   | 0      |
 
         When I request a travel distance matrix I should get
             |   | a      | b      | f     | 1      |
-            | a | 0      | 300.2  | 900.7 | 1501.1 |
+            | a | 0      | 300    | 900   | 1500   |
 
         When I request a travel distance matrix I should get
             |   | a      |
             | a | 0      |
-            | b | 300.2  |
-            | f | 900.7  |
-            | 1 | 1501.1 |
+            | b | 300    |
+            | f | 900    |
+            | 1 | 1500   |
 
     Scenario: Testbot - Fise input coordinate
         Given a grid size of 300 meters
@@ -649,21 +650,21 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a      | b      | f     | 1      |
-            | a | 0      | 300.2  | 900.7 | 1501.1 |
-            | b | 300.2  | 0      | 600.5 | 1200.9 |
-            | f | 900.7  | 600.5  | 0     | 300.2  |
-            | 1 | 1501.1 | 1200.9 | 300.2 | 0      |
+            | a | 0      | 300    | 900   | 1500   |
+            | b | 300    | 0      | 600   | 1200.1 |
+            | f | 900    | 600    | 0     | 300    |
+            | 1 | 1500   | 1200.1 | 300   | 0      |
 
         When I request a travel distance matrix I should get
             |   | a      | b     | f     | 1      |
-            | a | 0      | 300.2 | 900.7 | 1501.1 |
+            | a | 0      | 300   | 900   | 1500   |
 
         When I request a travel distance matrix I should get
             |   | a      |
             | a | 0      |
-            | b | 300.2  |
-            | f | 900.7  |
-            | 1 | 1501.1 |
+            | b | 300    |
+            | f | 900    |
+            | 1 | 1500   |
 
 
     Scenario: Testbot - Filling in noroutes with estimates - use snapped coordinate
@@ -685,28 +686,28 @@ Feature: Basic Distance Matrix
 
         When I request a travel distance matrix I should get
             |   | a      | b     | f     | 1      |
-            | a | 0      | 300.2 | 900.7 | 1200.9 |
-            | b | 300.2  | 0     | 600.5 | 900.7  |
-            | f | 900.7  | 600.5 | 0     | 300.2  |
-            | 1 | 1200.9 | 900.7 | 300.2 | 0      |
+            | a | 0      | 300   | 900   | 1200   |
+            | b | 300    | 0     | 600   | 900    |
+            | f | 900    | 600   | 0     | 300  |
+            | 1 | 1200   | 900   | 300   | 0      |
 
         When I request a travel distance matrix I should get
             |   | a      | b     | f     | 1      |
-            | a | 0      | 300.2 | 900.7 | 1200.9 |
+            | a | 0      | 300   | 900   | 1200   |
 
         When I request a travel distance matrix I should get
             |   | a      |
             | a | 0      |
-            | b | 300.2  |
-            | f | 900.7  |
-            | 1 | 1200.9 |
+            | b | 300    |
+            | f | 900    |
+            | 1 | 1200   |
 
     Scenario: Ensure consistency with route, and make sure offsets work in both directions
         Given a grid size of 100 meters
         Given the node map
             """
             a   b   c   d   e   f   g   h  i  j
-                  1                   2
+                  1                   2       3
             """
 
         And the ways
@@ -715,11 +716,14 @@ Feature: Basic Distance Matrix
             | fghij  |
 
         When I route I should get
-            | from | to | route              | distance |
-            | 1    | 2  | abcdef,fghij,fghij | 999.9m  |
+            | from | to | route              | distance   |
+            | 1    | 2  | abcdef,fghij,fghij | 1000.1m    |
+            | 1    | 3  | abcdef,fghij,fghij | 1400.1m    |
+            | 2    | 3  | fghij,fghij        | 400m       |
+            
 
-        # TODO: this is "correct", but inconsistent with viaroute
         When I request a travel distance matrix I should get
-            |   |   1    | 2      |
-            | 1 |   0    | 1000.7 |
-            | 2 | 1000.7 | 0      |
\ No newline at end of file
+            |   |   1    | 2      | 3      |   
+            | 1 |   0    | 1000.1 | 1400.1 |
+            | 2 | 1000.1 | 0      | 400    |
+            | 3 | 1400.1 | 400    | 0      |
\ No newline at end of file
diff --git a/features/testbot/duration_matrix.feature b/features/testbot/duration_matrix.feature
index 94e0a6414..28ffaaed3 100644
--- a/features/testbot/duration_matrix.feature
+++ b/features/testbot/duration_matrix.feature
@@ -446,15 +446,15 @@ Feature: Basic Duration Matrix
             | ca    | yes    |
 
         When I request a travel time matrix I should get
-          |   |   1 |   2 |   3 |   4 |    5 |   6 |   7 |   8 |
-          | 1 |   0 |  11 |   3 |   2 |    6 |   5 | 8.9 | 7.9 |
-          | 2 |   1 |   0 |   4 |   3 |    7 |   6 | 9.9 | 8.9 |
-          | 3 |   9 |   8 |   0 |  11 |    3 |   2 | 5.9 | 4.9 |
-          | 4 |  10 |   9 |   1 |   0 |    4 |   3 | 6.9 | 5.9 |
-          | 5 |   6 |   5 |   9 |   8 |    0 |  11 | 2.9 | 1.9 |
-          | 6 |   7 |   6 |  10 |   9 |    1 |   0 | 3.9 | 2.9 |
-          | 7 | 3.1 | 2.1 | 6.1 | 5.1 |  9.1 | 8.1 |   0 |  11 |
-          | 8 | 4.1 | 3.1 | 7.1 | 6.1 | 10.1 | 9.1 |   1 | 0   |
+          |   | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    |
+          | 1 | 0    | 10.9 | 3    | 1.9  | 6    | 4.9  | 9    | 7.9  |
+          | 2 | 1.1  | 0    | 4.1  | 3    | 7.1  | 6    | 10.1 | 9    |
+          | 3 | 9    | 7.9  | 0    | 10.9 | 3    | 1.9  | 6    | 4.9  |
+          | 4 | 10.1 | 9    | 1.1  | 0    | 4.1  | 3    | 7.1  | 6    |
+          | 5 | 6    | 4.9  | 9    | 7.9  | 0    | 10.9 | 3    | 1.9  |
+          | 6 | 7.1  | 6    | 10.1 | 9    | 1.1  | 0    | 4.1  | 3    |
+          | 7 | 3    | 1.9  | 6    | 4.9  | 9    | 7.9  | 0    | 10.9 |
+          | 8 | 4.1  | 3    | 7.1  | 6    | 10.1 | 9    | 1.1  | 0    |
 
 
     Scenario: Testbot - Travel time matrix with ties
@@ -543,22 +543,22 @@ Feature: Basic Duration Matrix
             | fhigf |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
-            | b | 30 | 0  | 12 | 24 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 30 | 24 | 30 | 0  |
+            |   | a    | b  | f    | 1  |
+            | a | 0    | 30 | 17.9 | 30 |
+            | b | 30   | 0  | 12   | 24 |
+            | f | 17.9 | 12 | 0    | 30 |
+            | 1 | 30   | 24 | 30   | 0  |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
+            |   | a  | b  | f    | 1  |
+            | a | 0  | 30 | 17.9 | 30 |
 
         When I request a travel time matrix I should get
-            |   | a  |
-            | a | 0  |
-            | b | 30 |
-            | f | 18 |
-            | 1 | 30 |
+            |   | a    |
+            | a | 0    |
+            | b | 30   |
+            | f | 17.9 |
+            | 1 | 30   |
 
         When I request a travel time matrix I should get estimates for
             |   | a | b | f | 1 |
@@ -596,22 +596,22 @@ Feature: Basic Duration Matrix
             | fhigf |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
-            | b | 30 | 0  | 12 | 24 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 30 | 24 | 30 | 0  |
+            |   | a    | b  | f    | 1  |
+            | a | 0    | 30 | 17.9 | 30 |
+            | b | 30   | 0  | 12   | 24 |
+            | f | 17.9 | 12 | 0    | 30 |
+            | 1 | 30   | 24 | 30   | 0  |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 30 |
+            |   | a  | b  | f    | 1  |
+            | a | 0  | 30 | 17.9 | 30 |
 
         When I request a travel time matrix I should get
-            |   | a  |
-            | a | 0  |
-            | b | 30 |
-            | f | 18 |
-            | 1 | 30 |
+            |   | a    |
+            | a | 0    |
+            | b | 30   |
+            | f | 17.9 |
+            | 1 | 30   |
 
         When I request a travel time matrix I should get estimates for
             |   | a | b | f | 1 |
@@ -650,22 +650,22 @@ Feature: Basic Duration Matrix
             | fhigf |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 24 |
-            | b | 30 | 0  | 12 | 18 |
-            | f | 18 | 12 | 0  | 30 |
-            | 1 | 24 | 18 | 30 | 0  |
+            |   | a    | b    | f    | 1    |
+            | a | 0    | 30   | 17.9 | 23.9 |
+            | b | 30   | 0    | 12   | 17.9 |
+            | f | 17.9 | 12   | 0    | 30   |
+            | 1 | 23.9 | 17.9 | 30   | 0    |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 30 | 18 | 24 |
+            |   | a  | b  | f    | 1    |
+            | a | 0  | 30 | 17.9 | 23.9 |
 
         When I request a travel time matrix I should get
-            |   | a  |
-            | a | 0  |
-            | b | 30 |
-            | f | 18 |
-            | 1 | 24 |
+            |   | a    |
+            | a | 0    |
+            | b | 30   |
+            | f | 17.9 |
+            | 1 | 23.9 |
 
         When I request a travel time matrix I should get estimates for
             |   | a | b | f | 1 |
@@ -719,22 +719,22 @@ Feature: Basic Duration Matrix
             | fhigf |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 60 | 36 | 48 |
-            | b | 60 | 0  | 24 | 36 |
-            | f | 36 | 24 | 0  | 60 |
-            | 1 | 48 | 36 | 60 | 0  |
+            |   | a    | b    | f    | 1    |
+            | a | 0    | 60   | 35.8 | 47.8 |
+            | b | 60   | 0    | 24   | 35.8 |
+            | f | 35.8 | 24   | 0    | 60   |
+            | 1 | 47.8 | 35.8 | 60   | 0    |
 
         When I request a travel time matrix I should get
-            |   | a  | b  | f  | 1  |
-            | a | 0  | 60 | 36 | 48 |
+            |   | a  | b  | f    | 1    |
+            | a | 0  | 60 | 35.8 | 47.8 |
 
         When I request a travel time matrix I should get
-            |   | a  |
-            | a | 0  |
-            | b | 60 |
-            | f | 36 |
-            | 1 | 48 |
+            |   | a    |
+            | a | 0    |
+            | b | 60   |
+            | f | 35.8 |
+            | 1 | 47.8 |
 
         When I request a travel time matrix I should get estimates for
             |   | a | b | f | 1 |
diff --git a/features/testbot/matching.feature b/features/testbot/matching.feature
index 599afcb1d..f8e1b2738 100644
--- a/features/testbot/matching.feature
+++ b/features/testbot/matching.feature
@@ -279,8 +279,8 @@ Feature: Basic Map Matching
             | fb    | yes    |
 
         When I match I should get
-            | trace | matchings | geometry                                      |
-            | efbc  | efbc      | 1,0.99964,1.00036,0.99964,1.00036,1,1.000719,1 |
+            | trace | matchings | geometry                                           |
+            | efbc  | efbc      | 1,0.999638,1.000359,0.999638,1.000359,1,1.000719,1 |
 
     Scenario: Testbot - Geometry details using geojson
         Given the query options
@@ -356,7 +356,7 @@ Feature: Basic Map Matching
 
         When I match I should get
             | trace  | matchings | alternatives         |
-            | abcdef | abcde     | 0,0,0,0,1,1          |
+            | abcdef | abcde     | 0,0,0,1,1,1          |
 
     Scenario: Testbot - Speed greater than speed threshold
         Given a grid size of 100 meters
@@ -652,7 +652,7 @@ Feature: Basic Map Matching
 
         When I match I should get
             | trace    | geometry                           | code |
-            | defgh    | 1,1,1,0.999461,1.000674,0.999461   | Ok   |
+            | defgh    | 1,1,1,0.999457,1.000674,0.999457   | Ok   |
 
     @match @testbot
     Scenario: Regression test - waypoints trimming too much geometry
@@ -682,8 +682,8 @@ Feature: Basic Map Matching
           | waypoints | 0;3  |
           | overview  | full |
         When I match I should get
-          | trace | geometry                                      | code |
-          | bgkj  | 1.000135,1,1.000135,0.99964,1.000387,0.999137 | Ok   |
+          | trace | geometry                                       | code |
+          | bgkj  | 1.000135,1,1.000135,0.999638,1.000386,0.999132 | Ok   |
 
 
     @match @testbot
@@ -712,12 +712,12 @@ Feature: Basic Map Matching
           | overview  | full |
           | steps     | true |
         When I match I should get
-          | trace | geometry                                   | turns                    | code |
-          | abc   | 1,0.99973,1.00027,0.99973,1.000539,0.99973 | depart,arrive            | Ok   |
-          | abd   | 1,0.99973,1.00027,0.99973,1.00027,0.999461 | depart,turn right,arrive | Ok   |
-          | abe   | 1,0.99973,1.00027,0.99973,1.00027,1        | depart,turn left,arrive  | Ok   |
-          | ahd   | 1,0.99973,1.00027,0.99973,1.00027,0.999461 | depart,turn right,arrive | Ok   |
-          | ahe   | 1,0.99973,1.00027,0.99973,1.00027,1        | depart,turn left,arrive  | Ok   |
+          | trace | geometry                                       | turns                    | code |
+          | abc   | 1,0.999729,1.000269,0.999729,1.000539,0.999729 | depart,arrive            | Ok   |
+          | abd   | 1,0.999729,1.000269,0.999729,1.000269,0.999457 | depart,turn right,arrive | Ok   |
+          | abe   | 1,0.999729,1.000269,0.999729,1.000269,1        | depart,turn left,arrive  | Ok   |
+          | ahd   | 1,0.999729,1.000269,0.999729,1.000269,0.999457 | depart,turn right,arrive | Ok   |
+          | ahe   | 1,0.999729,1.000269,0.999729,1.000269,1        | depart,turn left,arrive  | Ok   |
 
     @match @testbot
     Scenario: Regression test - add source phantoms properly (one phantom on one edge)
@@ -740,9 +740,9 @@ Feature: Basic Map Matching
           | annotations    | duration,weight |
           | generate_hints | false           |
         When I match I should get
-          | trace | geometry                                             | a:duration    | a:weight      | duration |
-          | 123   | 1.000135,1,1.000225,1,1.00036,1,1.000405,1,1.00045,1 | 1:1.5:0.5:0.5 | 1:1.5:0.5:0.5 | 3.5      |
-          | 321   | 1.00045,1,1.000405,1,1.00036,1,1.000225,1,1.000135,1 | 0.5:0.5:1.5:1 | 0.5:0.5:1.5:1 | 3.5      |
+          | trace | geometry                                               | a:duration    | a:weight      | duration |
+          | 123   | 1.000135,1,1.000225,1,1.000359,1,1.000404,1,1.000449,1 | 1:1.5:0.5:0.4 | 1:1.5:0.5:0.4 | 3.4      |
+          | 321   | 1.000449,1,1.000404,1,1.000359,1,1.000225,1,1.000135,1 | 0.4:0.5:1.5:1 | 0.4:0.5:1.5:1 | 3.4      |
 
     @match @testbot
     Scenario: Regression test - add source phantom properly (two phantoms on one edge)
@@ -765,9 +765,9 @@ Feature: Basic Map Matching
           | annotations    | duration,weight |
           | generate_hints | false           |
         When I match I should get
-          | trace | geometry                                   | a:duration | a:weight | duration |
-          | 1234  | 1.000135,1,1.000225,1,1.000405,1,1.00045,1 | 1:2:0.5    | 1:2:0.5  | 3.5      |
-          | 4321  | 1.00045,1,1.000405,1,1.000225,1,1.000135,1 | 0.5:2:1    | 0.5:2:1  | 3.5      |
+          | trace | geometry                                    | a:duration | a:weight | duration |
+          | 1234  | 1.000135,1,1.000225,1,1.000404,1,1.000449,1 | 1:2:0.4    | 1:2:0.4  | 3.4      |
+          | 4321  | 1.000449,1,1.000404,1,1.000225,1,1.000135,1 | 0.4:2:1    | 0.4:2:1  | 3.4      |
 
     @match @testbot
     Scenario: Regression test - add source phantom properly (two phantoms on one edge)
@@ -791,5 +791,5 @@ Feature: Basic Map Matching
         # These should have the same weights/duration in either direction
         When I match I should get
           | trace | geometry             | a:distance | a:duration | a:weight | duration |
-          | 2345  | 1.00018,1,1.000315,1 | 15.013264  | 1.5        | 1.5      | 1.5      |
-          | 4321  | 1.00027,1,1.000135,1 | 15.013264  | 1.5        | 1.5      | 1.5      |
\ No newline at end of file
+          | 2345  | 1.00018,1,1.000314,1 | 14.914666  | 1.4        | 1.4      | 1.4      |
+          | 4321  | 1.00027,1,1.000135,1 | 15.02597   | 1.5        | 1.5      | 1.5      |
\ No newline at end of file
diff --git a/features/testbot/multi_level_routing.feature b/features/testbot/multi_level_routing.feature
index 467ddd26f..5ffabec5e 100644
--- a/features/testbot/multi_level_routing.feature
+++ b/features/testbot/multi_level_routing.feature
@@ -110,33 +110,34 @@ Feature: Multi level routing
 
         When I request a travel distance matrix I should get
             |   | a      | f      | l      | o      |
-            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
-            | f | 2383.7 | 0      | 1293.3 | 1617.3 |
-            | l | 1566.9 | 1293.3 | 0      | 800.5  |
-            | o | 1366.8 | 1617.3 | 800.5  | 0      |
+            | a | 0      | 2391.6 | 1570.8 | 1370.9 |
+            | f | 2391.6 | 0      | 1297.2 | 1620.9 |
+            | l | 1570.8 | 1297.2 | 0      | 800    |
+            | o | 1370.9 | 1620.9 | 800    | 0      |
+
 
         When I request a travel distance matrix I should get
             |   | a | f      | l      | o      |
-            | a | 0 | 2383.7 | 1566.9 | 1366.8 |
+            | a | 0 | 2391.6 | 1570.8 | 1370.9 |
 
         When I request a travel distance matrix I should get
             |   | a      |
             | a | 0      |
-            | f | 2383.7 |
-            | l | 1566.9 |
-            | o | 1366.8 |
+            | f | 2391.6 |
+            | l | 1570.8 |
+            | o | 1370.9 |
 
         When I request a travel distance matrix I should get
             |   | a      | f      | l      | o      |
-            | a | 0      | 2383.7 | 1566.9 | 1366.8 |
-            | f | 2383.7 | 0      | 1293.3 | 1617.3 |
+            | a | 0      | 2391.6 | 1570.8 | 1370.9 |
+            | f | 2391.6 | 0      | 1297.2 | 1620.9 |
 
         When I request a travel distance matrix I should get
             |   | a      | o      |
-            | a | 0      | 1366.8 |
-            | f | 2383.7 | 1617.3 |
-            | l | 1566.9 | 800.5  |
-            | o | 1366.8 | 0      |
+            | a | 0      | 1370.9 |
+            | f | 2391.6 | 1620.9 |
+            | l | 1570.8 | 800    |
+            | o | 1370.9 | 0      |
 
     Scenario: Testbot - Multi level routing: horizontal road
         Given the node map
diff --git a/features/testbot/nil.feature b/features/testbot/nil.feature
index af8a0b988..521720af7 100644
--- a/features/testbot/nil.feature
+++ b/features/testbot/nil.feature
@@ -1,18 +1,18 @@
 @routing @testbot @nil
-Feature: Testbot - Check assigning nil values
-    Scenario: Assign nil values to all way strings
+Feature: Testbot - Check assigning empty values
+    Scenario: Assign empty values to all way strings
         Given the profile file
         """
         functions = require('testbot')
 
         function way_function(profile, way, result)
-          result.name = nil
-          result.ref = nil
-          result.destinations = nil
-          result.exits = nil
-          result.pronunciation = nil
-          result.turn_lanes_forward = nil
-          result.turn_lanes_backward = nil
+          result.name = ""
+          result.ref = ""
+          result.destinations = ""
+          result.exits = ""
+          result.pronunciation = ""
+          result.turn_lanes_forward = ""
+          result.turn_lanes_backward = ""
 
           result.forward_speed = 10
           result.backward_speed = 10
diff --git a/features/testbot/origin.feature b/features/testbot/origin.feature
index c21febd07..fd14c86f7 100644
--- a/features/testbot/origin.feature
+++ b/features/testbot/origin.feature
@@ -53,7 +53,7 @@ Feature: Routing close to the [0,0] origin
 
         When I route I should get
             | from | to | route       | distance |
-            | b    | d  | abcde,abcde | 200m     |
+            | b    | d  | abcde,abcde | 198.8m   |
             | d    | b  |             |          |
 
     Scenario: North-south oneways crossing the origin
@@ -71,5 +71,5 @@ Feature: Routing close to the [0,0] origin
 
         When I route I should get
             | from | to | route       | distance |
-            | b    | d  | abcde,abcde | 200m     |
+            | b    | d  | abcde,abcde | 200.2m   |
             | d    | b  |             |          |
diff --git a/features/testbot/planetary.feature b/features/testbot/planetary.feature
index 1fff4bded..c70cedb3d 100644
--- a/features/testbot/planetary.feature
+++ b/features/testbot/planetary.feature
@@ -26,8 +26,8 @@ Feature: Distance calculation
             | cd    |
 
         When I route I should get
-            | from | to | route | distance       |
-            | c    | d  | cd,cd | 6028844m ~4.5% |
+            | from | to | route | distance         |
+            | c    | d  | cd,cd | 6310675.7m ~4.5% |
 
     Scenario: Approximated Longitudinal distances at latitude 80
         Given the node locations
@@ -54,8 +54,8 @@ Feature: Distance calculation
             | ab    |
 
         When I route I should get
-            | from | to | route | distance       |
-            | a    | b  | ab,ab | 8905559m ~0.1% |
+            | from | to | route | distance         |
+            | a    | b  | ab,ab | 8882574.6m ~0.1% |
 
     Scenario: Approximated Latitudinal distances at longitude 45
         Given the node locations
@@ -68,8 +68,8 @@ Feature: Distance calculation
             | ab    |
 
         When I route I should get
-            | from | to | route | distance       |
-            | a    | b  | ab,ab | 8905559m ~0.1% |
+            | from | to | route | distance         |
+            | a    | b  | ab,ab | 8882574.6m ~0.1% |
 
     Scenario: Approximated Latitudinal distances at longitude 80
         Given the node locations
@@ -83,4 +83,4 @@ Feature: Distance calculation
 
         When I route I should get
             | from | to | route | distance       |
-            | a    | b  | ab,ab | 8905559m ~0.1% |
+            | a    | b  | ab,ab | 8882574.6m ~0.1% |
diff --git a/features/testbot/projection.feature b/features/testbot/projection.feature
index 49a5d8df1..c5bd6be18 100644
--- a/features/testbot/projection.feature
+++ b/features/testbot/projection.feature
@@ -23,13 +23,13 @@ Feature: Projection to nearest point on road
 
     Scenario: Projection onto way at high latitudes, 1km distance
         When I route I should get
-            | from | to | route   | bearing       | distance   |
-            | b    | a  | abc,abc | 0->225,225->0 | 1000m      |
-            | b    | c  | abc,abc | 0->45,45->0   | 1000m +- 3 |
-            | a    | d  | abc,abc | 0->45,45->0   | 1000m      |
-            | d    | a  | abc,abc | 0->225,225->0 | 1000m      |
-            | c    | d  | abc,abc | 0->225,225->0 | 1000m +- 3 |
-            | d    | c  | abc,abc | 0->45,45->0   | 1000m +- 3 |
+            | from | to | route   | bearing       | distance     |
+            | b    | a  | abc,abc | 0->225,225->0 | 1002.9m      |
+            | b    | c  | abc,abc | 0->45,45->0   | 1005m +- 3   |
+            | a    | d  | abc,abc | 0->45,45->0   | 1002.9m      |
+            | d    | a  | abc,abc | 0->225,225->0 | 1002.9m      |
+            | c    | d  | abc,abc | 0->225,225->0 | 1005m +- 3   |
+            | d    | c  | abc,abc | 0->45,45->0   | 1005m +- 3   |
 
     Scenario: Projection onto way at high latitudes, no distance
         When I route I should get
diff --git a/features/testbot/traffic_speeds.feature b/features/testbot/traffic_speeds.feature
index f5f2198f3..db3b2372b 100644
--- a/features/testbot/traffic_speeds.feature
+++ b/features/testbot/traffic_speeds.feature
@@ -48,13 +48,13 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights              | a:datasources |
-          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0         |
-          | a    | c  | ad,dc,dc    | 31 km/h | 1275.7,956.8,0       | 1:0           |
-          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1             |
-          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1             |
-          | d    | c  | dc,dc       | 36 km/h | 956.8,0              | 0             |
-          | g    | b  | fb,fb       | 36 km/h | 164.7,0              | 0             |
-          | a    | g  | ad,df,fb,fb | 30 km/h | 1295.7,487.5,304.7,0 | 1:0:0         |
+          | a    | b  | ad,de,eb,eb | 30 km/h | 1273.9,400.8,378.5,0 | 1:0:0         |
+          | a    | c  | ad,dc,dc    | 31 km/h | 1273.9,955.4,0       | 1:0           |
+          | b    | c  | bc,bc       | 27 km/h | 737.2,0              | 1             |
+          | a    | d  | ad,ad       | 27 km/h | 1273.9,0             | 1             |
+          | d    | c  | dc,dc       | 36 km/h | 955.4,0              | 0             |
+          | g    | b  | fb,fb       | 36 km/h | 164.4,0              | 0             |
+          | a    | g  | ad,df,fb,fb | 30 km/h | 1293.9,486.8,304.3,0 | 1:0:0         |
 
 
     Scenario: Weighting based on speed file weights, ETA based on file durations
@@ -74,13 +74,13 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights              | a:datasources |
-          | a    | b  | ad,de,eb,eb | 30 km/h | 1275.7,400.4,378.2,0 | 1:0:0         |
-          | a    | c  | ad,dc,dc    | 31 km/h | 1275.7,956.8,0       | 1:0           |
-          | b    | c  | bc,bc       | 27 km/h | 741.5,0              | 1             |
-          | a    | d  | ad,ad       | 27 km/h | 1275.7,0             | 1             |
-          | d    | c  | dc,dc       | 36 km/h | 956.8,0              | 0             |
-          | g    | b  | ab,ab       | 1 km/h  | 10010.4,0            | 1             |
-          | a    | g  | ab,ab       | 1 km/h  | 10010.3,0            | 1             |
+          | a    | b  | ad,de,eb,eb | 30 km/h | 1273.9,400.8,378.5,0 | 1:0:0         |
+          | a    | c  | ad,dc,dc    | 31 km/h | 1273.9,955.4,0       | 1:0           |
+          | b    | c  | bc,bc       | 27 km/h | 737.2,0              | 1             |
+          | a    | d  | ad,ad       | 27 km/h | 1273.9,0             | 1             |
+          | d    | c  | dc,dc       | 36 km/h | 955.4,0              | 0             |
+          | g    | b  | ab,ab       | 1 km/h  | 9951.7,0             | 1             |
+          | a    | g  | ab,ab       | 1 km/h  | 9951.7,0             | 1             |
 
 
     Scenario: Weighting based on speed file weights, ETA based on file durations
@@ -106,14 +106,14 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route       | speed   | weights                  | a:datasources |
-          | a    | b  | ab,ab       | 1 km/h  | 20020.73,0               | 1             |
-          | a    | c  | ab,bc,bc    | 2 km/h  | 20020.73,741.51,0        | 1:1           |
-          | b    | c  | bc,bc       | 27 km/h | 741.51,0                 | 1             |
-          | a    | d  | ab,eb,de,de | 2 km/h  | 20020.73,378.17,400.41,0 | 1:0:0         |
-          | d    | c  | dc,dc       | 36 km/h | 956.8,0                  | 0             |
-          | g    | b  | ab,ab       | 1 km/h  | 10010.37,0               | 1             |
-          | a    | g  | ab,ab       | 1 km/h  | 10010.36,0               | 1             |
-          | g    | a  | ab,ab       | 1 km/h  | 10010.36,0               | 1             |
+          | a    | b  | ab,ab       | 1 km/h  | 19903.37,0               | 1             |
+          | a    | c  | ab,bc,bc    | 2 km/h  | 19903.37,737.16,0        | 1:1           |
+          | b    | c  | bc,bc       | 27 km/h | 737.16,0                 | 1             |
+          | a    | d  | ab,eb,de,de | 2 km/h  | 19903.37,378.49,400.75,0 | 1:0:0         |
+          | d    | c  | dc,dc       | 36 km/h | 955.45,0                 | 0             |
+          | g    | b  | ab,ab       | 1 km/h  | 9951.69,0                | 1             |
+          | a    | g  | ab,ab       | 1 km/h  | 9951.68,0                | 1             |
+          | g    | a  | ab,ab       | 1 km/h  | 9951.68,0                | 1             |
 
 
     Scenario: Speeds that isolate a single node (a)
@@ -136,13 +136,13 @@ Feature: Traffic - speeds
 
         When I route I should get
           | from | to | route    | speed   | weights       | a:datasources | a:speed | a:nodes|
-          | a    | b  | fb,fb    | 36 km/h | 329.4,0       | 0             | 10      | 6:2    |
-          | a    | c  | fb,bc,bc | 30 km/h | 329.4,741.5,0 | 0:1           | 10:7.5  | 6:2:3  |
-          | b    | c  | bc,bc    | 27 km/h | 741.5,0       | 1             | 7.5     | 2:3    |
-          | a    | d  | fb,df,df | 36 km/h | 140,487.5,0   | 0:0           | 10:10   | 2:6:4  |
-          | d    | c  | dc,dc    | 36 km/h | 956.8,0       | 0             | 10      | 4:3    |
-          | g    | b  | fb,fb    | 36 km/h | 164.7,0       | 0             | 10      | 6:2    |
-          | a    | g  | fb,fb    | 36 km/h | 164.7,0       | 0             | 10      | 6:2    |
+          | a    | b  | fb,fb    | 36 km/h | 328.9,0       | 0             | 10      | 6:2    |
+          | a    | c  | fb,bc,bc | 30 km/h | 328.9,737.2,0 | 0:1           | 10:7.5  | 6:2:3  |
+          | b    | c  | bc,bc    | 27 km/h | 737.2,0       | 1             | 7.5     | 2:3    |
+          | a    | d  | fb,df,df | 36 km/h | 139.8,486.8,0 | 0:0           | 10:10   | 2:6:4  |
+          | d    | c  | dc,dc    | 36 km/h | 955.4,0       | 0             | 10      | 4:3    |
+          | g    | b  | fb,fb    | 36 km/h | 164.4,0       | 0             | 10      | 6:2    |
+          | a    | g  | fb,fb    | 36 km/h | 164.5,0       | 0             | 10      | 6:2    |
 
 
     Scenario: Verify that negative values cause an error, they're not valid at all
diff --git a/features/testbot/traffic_turn_penalties.feature b/features/testbot/traffic_turn_penalties.feature
index 9d3c45412..4ab9aa8b2 100644
--- a/features/testbot/traffic_turn_penalties.feature
+++ b/features/testbot/traffic_turn_penalties.feature
@@ -62,8 +62,8 @@ Feature: Traffic - turn penalties applied to turn onto which a phantom node snap
         When I route I should get
             | from | to | route    | speed    | time    | weights    |
             | a    | e  | ab,be,be | 36 km/h  | 40s +-1 | 16.7,20,0  |
-            | 1    | e  | ab,be,be | 36 km/h  | 30s +-1 | 6.7,20,0   |
+            | 1    | e  | ab,be,be | 36 km/h  | 30s +-1 | 6.8,20,0   |
             | b    | f  | bc,cf,cf | 36 km/h  | 40s +-1 | 20,20,0    |
-            | 2    | f  | bc,cf,cf | 36 km/h  | 30s +-1 | 10,20,0    |
+            | 2    | f  | bc,cf,cf | 36 km/h  | 30s +-1 | 10.1,20,0  |
             | c    | g  | cd,dg,dg | 144 km/h | 10s +-1 | 120.8,20,0 |
-            | 3    | g  | cd,dg,dg | 54 km/h  | 20s +-1 | 110.8,20,0 |
+            | 3    | g  | cd,dg,dg | 54 km/h  | 20s +-1 | 110.9,20,0 |
diff --git a/features/testbot/trip.feature b/features/testbot/trip.feature
index c254f8d75..9fe3c23ae 100644
--- a/features/testbot/trip.feature
+++ b/features/testbot/trip.feature
@@ -221,7 +221,7 @@ Feature: Basic trip planning
 
         When I plan a trip I should get
             |  waypoints  | source | destination |roundtrip | trips  | durations         | distance               |
-            |  a,b,d,e,c  | first  | last        | false    | abedc  | 8.200000000000001 | 81.6                   |
+            |  a,b,d,e,c  | first  | last        | false    | abedc  | 8.200000000000001 | 81.4                   |
 
 
     Scenario: Testbot - Trip: FSE with waypoints (more than 10)
diff --git a/features/testbot/weight.feature b/features/testbot/weight.feature
index eae35c0ff..5d8aadee3 100644
--- a/features/testbot/weight.feature
+++ b/features/testbot/weight.feature
@@ -28,12 +28,12 @@ Feature: Weight tests
             | cde   |
 
         When I route I should get
-            | waypoints | route   | a:weight  |
-            | s,t       | abc,cde | 1.1:2:2:1 |
+            | waypoints | route   | a:weight    |
+            | s,t       | abc,cde | 1.1:2:2:0.9 |
 
         When I route I should get
             | waypoints | route   | times   | weight_name | weights |
-            | s,t       | abc,cde | 6.1s,0s | duration    | 6.1,0   |
+            | s,t       | abc,cde | 6s,0s   | duration    | 6,0     |
 
     # FIXME include/engine/guidance/assemble_geometry.hpp:95
     Scenario: Start and target on the same and adjacent edge
@@ -53,10 +53,10 @@ Feature: Weight tests
 
         When I route I should get
             | waypoints | route   | distances | weights | times   | a:distance          | a:duration | a:weight | a:speed |
-            | s,t       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 2.1        | 2.1      | 9.5     |
-            | t,s       | abc,abc | 20m,0m    | 2.1,0   | 2.1s,0s | 20.017685           | 2.1        | 2.1      | 9.5     |
-            | s,e       | abc,abc | 40m,0m    | 4.1,0   | 4.1s,0s | 30.026527:10.008842 | 3.1:1      | 3.1:1    | 9.7:10  |
-            | e,s       | abc,abc | 40m,0m    | 4.1,0   | 4.1s,0s | 10.008842:30.026527 | 1:3.1      | 1:3.1    | 10:9.7  |
+            | s,t       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.034627           | 2          | 2        | 10      |
+            | t,s       | abc,abc | 20m,0m    | 2,0     | 2s,0s   | 20.034627           | 2          | 2        | 10      |
+            | s,e       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 29.940636:10.017313 | 3:0.9      | 3:0.9    | 10:11.1  |
+            | e,s       | abc,abc | 40m,0m    | 3.9,0   | 3.9s,0s | 10.017313:29.940636 | 0.9:3      | 0.9:3    | 11.1:10  |
 
 
     Scenario: Step weights -- way_function: fail if no weight or weight_per_meter property
@@ -173,13 +173,13 @@ Feature: Weight tests
             | fgh      |
 
         When I route I should get
-            | waypoints | route | distance | weights | times  |
-            | a,f       | ,     | 100m     | 99.9,0  | 30s,0s |
-            | f,a       | ,     | 100m     | 199.8,0 | 30s,0s |
-            | a,h       | ,     | 140m     | 139.9,0 | 42s,0s |
-            | h,a       | ,     | 140m     | 279.8,0 | 42s,0s |
-            | f,h       | ,     | 40m      | 40,0    | 12s,0s |
-            | h,f       | ,     | 40m      | 80,0    | 12s,0s |
+            | waypoints | route | distance   | weights   | times  |
+            | a,f       | ,     | 100m       | 99.8,0    | 30s,0s |
+            | f,a       | ,     | 100m       | 199.9,0   | 30s,0s |
+            | a,h       | ,     | 140m       | 139.8,0   | 42s,0s |
+            | h,a       | ,     | 140m       | 280.1,0   | 42s,0s |
+            | f,h       | ,     | 40.1m      | 40,0      | 12s,0s |
+            | h,f       | ,     | 40.1m      | 80.2,0    | 12s,0s |
 
     Scenario: Step weights -- segment_function
         Given the profile file
@@ -281,11 +281,11 @@ Feature: Weight tests
 
         When I route I should get
             | waypoints | route | distance | weights      | times          |
-            | a,c       | ,     | 40m +-.1 | 5.119,0      | 289.9s,0s      |
-            | a,e       | ,,    | 60m +-.1 | 5.119,1.11,0 | 289.9s,100s,0s |
-            | e,a       | ,,    | 60m +-.1 | 2.21,2.22,0  | 10.1s,200s,0s  |
-            | e,d       | ,,    | 40m +-.1 | 4.009,1.11,0 | 189.9s,100s,0s |
-            | d,e       | ,,    | 40m +-.1 | 2.21,1.11,0  | 10.1s,100s,0s  |
+            | a,c       | ,     | 40m +-.1 | 5.12,0       | 290s,0s        |
+            | a,e       | ,,    | 60m +-.1 | 5.12,1.11,0  | 290s,100s,0s   |
+            | e,a       | ,,    | 60m +-.1 | 2.21,2.22,0  | 10s,200s,0s    |
+            | e,d       | ,,    | 40m +-.1 | 4.01,1.11,0  | 190s,100s,0s   |
+            | d,e       | ,,    | 40m +-.1 | 2.21,1.11,0  | 10s,100s,0s    |
 
     @traffic @speed
     Scenario: Step weights -- segment_function with speed and turn updates
@@ -341,9 +341,9 @@ Feature: Weight tests
 
         When I route I should get
             | waypoints | route | distance | weights   | times        |
-            | a,d       | ,     | 59.9m    | 20.5,0    | 24s,0s       |
-            | a,e       | ,,    | 60.1m    | 27.2,10,0 | 38.5s,11s,0s |
-            | d,e       | ,,    | 39.9m    | 10,10,0   | 11s,11s,0s   |
+            | a,d       | ,     | 60m      | 20.5,0    | 24s,0s       |
+            | a,e       | ,,    | 60m      | 27.2,10,0 | 38.5s,11s,0s |
+            | d,e       | ,,    | 40m      | 10,10,0   | 11s,11s,0s   |
 
     @traffic @speed
     Scenario: Step weights -- segment_function with speed and turn updates with fallback to durations
@@ -375,10 +375,10 @@ Feature: Weight tests
         And the customize extra arguments "--segment-speed-file {speeds_file} --turn-penalty-file {penalties_file}"
 
         When I route I should get
-            | waypoints | route      | distance | weights       | times    |
-            | a,d       | abcd,abcd  | 59.9m    | 6.996,0       | 7s,0s    |
-            | a,e       | abcd,ce,ce | 60.1m    | 6.005,2.002,0 | 6s,2s,0s |
-            | d,e       | abcd,ce,ce | 39.9m    | 1.991,2.002,0 | 2s,2s,0s |
+            | waypoints | route      | distance | weights        | times    |
+            | a,d       | abcd,abcd  | 60m      | 7,0            | 7s,0s    |
+            | a,e       | abcd,ce,ce | 60m      | 5.997,2.001,0  | 6s,2s,0s |
+            | d,e       | abcd,ce,ce | 40m      | 2.003,2.001,0  | 2s,2s,0s |
 
     @traffic @speed
     Scenario: Updating speeds without affecting weights.
@@ -410,5 +410,5 @@ Feature: Weight tests
         And the customize extra arguments "--segment-speed-file {speeds_file}"
 
         When I route I should get
-            | waypoints | route      | distance | weights       | times    |
-            | a,b       | acdb,acdb  | 78.3m    | 11.744,0      | 56.4s,0s  |
+            | waypoints | route     | distance | weights  | times    |
+            | a,b       | acdb,acdb | 78.3m    | 11.742,0 | 56.4s,0s |
diff --git a/fuzz/CMakeLists.txt b/fuzz/CMakeLists.txt
index 17b26b6e0..67792e07a 100644
--- a/fuzz/CMakeLists.txt
+++ b/fuzz/CMakeLists.txt
@@ -38,8 +38,7 @@ if (ENABLE_FUZZING)
 	  "table_parameters"
 	  "tile_parameters"
 	  "trip_parameters"
-	  "url_parser"
-	  "request_parser")
+	  "url_parser")
 
   foreach (target ${ServerTargets})
 	  add_fuzz_target(${target})
diff --git a/fuzz/request_parser.cc b/fuzz/request_parser.cc
deleted file mode 100644
index e292ab27e..000000000
--- a/fuzz/request_parser.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "server/request_parser.hpp"
-#include "server/http/request.hpp"
-
-#include "util.hpp"
-
-#include <iterator>
-#include <string>
-
-using osrm::server::RequestParser;
-using osrm::server::http::request;
-
-extern "C" int LLVMFuzzerTestOneInput(const unsigned char *data, unsigned long size)
-{
-    std::string in(reinterpret_cast<const char *>(data), size);
-
-    auto first = begin(in);
-    auto last = end(in);
-
-    RequestParser parser;
-    request req;
-
-    // &(*it) is needed to go from iterator to underlying item to pointer to underlying item
-    parser.parse(req, &(*first), &(*last));
-
-    escape(&req);
-
-    return 0;
-}
diff --git a/include/contractor/contract_excludable_graph.hpp b/include/contractor/contract_excludable_graph.hpp
index 6ae29282a..9d0cc6979 100644
--- a/include/contractor/contract_excludable_graph.hpp
+++ b/include/contractor/contract_excludable_graph.hpp
@@ -18,7 +18,7 @@ inline auto contractFullGraph(ContractorGraph contractor_graph,
                               std::vector<EdgeWeight> node_weights)
 {
     auto num_nodes = contractor_graph.GetNumberOfNodes();
-    contractGraph(contractor_graph, node_weights);
+    contractGraph(contractor_graph, std::move(node_weights));
 
     auto edges = toEdges<QueryEdge>(std::move(contractor_graph));
     std::vector<bool> edge_filter(edges.size(), true);
@@ -94,7 +94,7 @@ inline auto contractExcludableGraph(ContractorGraph contractor_graph_,
     return GraphAndFilter{QueryGraph{num_nodes, std::move(edge_container.edges)},
                           edge_container.MakeEdgeFilters()};
 }
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif
diff --git a/include/contractor/contracted_edge_container.hpp b/include/contractor/contracted_edge_container.hpp
index 8b37f5d4a..db3ae5cc9 100644
--- a/include/contractor/contracted_edge_container.hpp
+++ b/include/contractor/contracted_edge_container.hpp
@@ -164,7 +164,7 @@ struct ContractedEdgeContainer
     std::vector<MergedFlags> flags;
     std::vector<QueryEdge> edges;
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif
diff --git a/include/contractor/contracted_metric.hpp b/include/contractor/contracted_metric.hpp
index f44f49e83..c795a139a 100644
--- a/include/contractor/contracted_metric.hpp
+++ b/include/contractor/contracted_metric.hpp
@@ -15,11 +15,11 @@ template <storage::Ownership Ownership> struct ContractedMetric
     detail::QueryGraph<Ownership> graph;
     std::vector<util::ViewOrVector<bool, Ownership>> edge_filter;
 };
-}
+} // namespace detail
 
 using ContractedMetric = detail::ContractedMetric<storage::Ownership::Container>;
 using ContractedMetricView = detail::ContractedMetric<storage::Ownership::View>;
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif
diff --git a/include/contractor/contractor.hpp b/include/contractor/contractor.hpp
index ee1d2dd42..a0335d8ea 100644
--- a/include/contractor/contractor.hpp
+++ b/include/contractor/contractor.hpp
@@ -49,7 +49,7 @@ class Contractor
   private:
     ContractorConfig config;
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // PROCESSING_CHAIN_HPP
diff --git a/include/contractor/contractor_config.hpp b/include/contractor/contractor_config.hpp
index 8f1455cce..18e8ae222 100644
--- a/include/contractor/contractor_config.hpp
+++ b/include/contractor/contractor_config.hpp
@@ -43,10 +43,8 @@ namespace contractor
 struct ContractorConfig final : storage::IOConfig
 {
     ContractorConfig()
-        : IOConfig({".osrm.ebg", ".osrm.ebg_nodes", ".osrm.properties"},
-                   {},
-                   {".osrm.hsgr", ".osrm.enw"}),
-          requested_num_threads(0)
+        : IOConfig(
+              {".osrm.ebg", ".osrm.ebg_nodes", ".osrm.properties"}, {}, {".osrm.hsgr", ".osrm.enw"})
     {
     }
 
@@ -62,18 +60,18 @@ struct ContractorConfig final : storage::IOConfig
     updater::UpdaterConfig updater_config;
 
     // DEPRECATED to be removed in v6.0
-    bool use_cached_priority;
+    bool use_cached_priority = false;
 
-    unsigned requested_num_threads;
+    unsigned requested_num_threads = 0;
 
     // DEPRECATED to be removed in v6.0
     // A percentage of vertices that will be contracted for the hierarchy.
     // Offers a trade-off between preprocessing and query time.
     // The remaining vertices form the core of the hierarchy
     //(e.g. 0.8 contracts 80 percent of the hierarchy, leaving a core of 20%)
-    double core_factor;
+    double core_factor = 1.0;
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // EXTRACTOR_OPTIONS_HPP
diff --git a/include/contractor/crc32_processor.hpp b/include/contractor/crc32_processor.hpp
index 4130ed583..a441ae576 100644
--- a/include/contractor/crc32_processor.hpp
+++ b/include/contractor/crc32_processor.hpp
@@ -125,7 +125,7 @@ struct RangebasedCRC32
   private:
     IteratorbasedCRC32 crc32;
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif /* ITERATOR_BASED_CRC32_H */
diff --git a/include/contractor/files.hpp b/include/contractor/files.hpp
index 8dcade795..39ffa5b54 100644
--- a/include/contractor/files.hpp
+++ b/include/contractor/files.hpp
@@ -52,8 +52,8 @@ inline void writeGraph(const boost::filesystem::path &path,
         serialization::write(writer, "/ch/metrics/" + pair.first, pair.second);
     }
 }
-}
-}
-}
+} // namespace files
+} // namespace contractor
+} // namespace osrm
 
 #endif
diff --git a/include/contractor/query_edge.hpp b/include/contractor/query_edge.hpp
index 74d38e79e..351ecee24 100644
--- a/include/contractor/query_edge.hpp
+++ b/include/contractor/query_edge.hpp
@@ -77,7 +77,7 @@ struct QueryEdge
                 data.distance == right.data.distance);
     }
 };
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // QUERYEDGE_HPP
diff --git a/include/contractor/query_graph.hpp b/include/contractor/query_graph.hpp
index e5758dcfe..c0c4b6cf5 100644
--- a/include/contractor/query_graph.hpp
+++ b/include/contractor/query_graph.hpp
@@ -15,11 +15,11 @@ namespace detail
 {
 template <storage::Ownership Ownership>
 using QueryGraph = util::StaticGraph<typename QueryEdge::EdgeData, Ownership>;
-}
+} // namespace detail
 
 using QueryGraph = detail::QueryGraph<storage::Ownership::Container>;
 using QueryGraphView = detail::QueryGraph<storage::Ownership::View>;
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 #endif // QUERYEDGE_HPP
diff --git a/include/contractor/serialization.hpp b/include/contractor/serialization.hpp
index aa8659274..693216d6a 100644
--- a/include/contractor/serialization.hpp
+++ b/include/contractor/serialization.hpp
@@ -46,8 +46,8 @@ void read(storage::tar::FileReader &reader,
                                      metric.edge_filter[index]);
     }
 }
-}
-}
-}
+} // namespace serialization
+} // namespace contractor
+} // namespace osrm
 
 #endif
diff --git a/include/customizer/cell_customizer.hpp b/include/customizer/cell_customizer.hpp
index df5499579..9e27236d0 100644
--- a/include/customizer/cell_customizer.hpp
+++ b/include/customizer/cell_customizer.hpp
@@ -212,9 +212,8 @@ class CellCustomizer
             }
 
             const auto &data = graph.GetEdgeData(edge);
-            if (data.forward &&
-                (first_level ||
-                 partition.GetCell(level - 1, node) != partition.GetCell(level - 1, to)))
+            if (data.forward && (first_level || partition.GetCell(level - 1, node) !=
+                                                    partition.GetCell(level - 1, to)))
             {
                 const EdgeWeight to_weight = weight + data.weight;
                 const EdgeDuration to_duration = duration + data.duration;
@@ -237,7 +236,7 @@ class CellCustomizer
 
     const partitioner::MultiLevelPartition &partition;
 };
-}
-}
+} // namespace customizer
+} // namespace osrm
 
 #endif // OSRM_CELLS_CUSTOMIZER_HPP
diff --git a/include/customizer/cell_metric.hpp b/include/customizer/cell_metric.hpp
index 7674174fe..a522facc3 100644
--- a/include/customizer/cell_metric.hpp
+++ b/include/customizer/cell_metric.hpp
@@ -22,11 +22,11 @@ template <storage::Ownership Ownership> struct CellMetricImpl
     Vector<EdgeDuration> durations;
     Vector<EdgeDistance> distances;
 };
-}
+} // namespace detail
 
 using CellMetric = detail::CellMetricImpl<storage::Ownership::Container>;
 using CellMetricView = detail::CellMetricImpl<storage::Ownership::View>;
-}
-}
+} // namespace customizer
+} // namespace osrm
 
 #endif
diff --git a/include/customizer/customizer_config.hpp b/include/customizer/customizer_config.hpp
index 35ab1a356..4df629de5 100644
--- a/include/customizer/customizer_config.hpp
+++ b/include/customizer/customizer_config.hpp
@@ -39,7 +39,7 @@ struct CustomizationConfig final : storage::IOConfig
 
     updater::UpdaterConfig updater_config;
 };
-}
-}
+} // namespace customizer
+} // namespace osrm
 
 #endif // OSRM_CUSTOMIZE_CUSTOMIZER_CONFIG_HPP
diff --git a/include/customizer/edge_based_graph.hpp b/include/customizer/edge_based_graph.hpp
index 840a84299..5ef3277f9 100644
--- a/include/customizer/edge_based_graph.hpp
+++ b/include/customizer/edge_based_graph.hpp
@@ -34,7 +34,7 @@ template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const MultiLevelGraph<EdgeDataT, Ownership> &graph);
-}
+} // namespace serialization
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 class MultiLevelGraph : public partitioner::MultiLevelGraph<EdgeDataT, Ownership>
@@ -126,7 +126,7 @@ using MultiLevelEdgeBasedGraph =
     MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
 using MultiLevelEdgeBasedGraphView =
     MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::View>;
-}
-}
+} // namespace customizer
+} // namespace osrm
 
 #endif
diff --git a/include/customizer/files.hpp b/include/customizer/files.hpp
index 364a2572d..335b77a30 100644
--- a/include/customizer/files.hpp
+++ b/include/customizer/files.hpp
@@ -106,8 +106,8 @@ inline void writeGraph(const boost::filesystem::path &path,
     writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
     serialization::write(writer, "/mld/multilevelgraph", graph);
 }
-}
-}
-}
+} // namespace files
+} // namespace customizer
+} // namespace osrm
 
 #endif
diff --git a/include/customizer/serialization.hpp b/include/customizer/serialization.hpp
index afe23cf9b..c242f8ba3 100644
--- a/include/customizer/serialization.hpp
+++ b/include/customizer/serialization.hpp
@@ -65,8 +65,8 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(writer, name + "/is_backward_edge", graph.is_backward_edge);
     storage::serialization::write(writer, name + "/node_to_edge_offset", graph.node_to_edge_offset);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace customizer
+} // namespace osrm
 
 #endif
diff --git a/include/engine/algorithm.hpp b/include/engine/algorithm.hpp
index 760f78e80..1d65cac04 100644
--- a/include/engine/algorithm.hpp
+++ b/include/engine/algorithm.hpp
@@ -16,14 +16,14 @@ namespace ch
 struct Algorithm final
 {
 };
-}
+} // namespace ch
 // Multi-Level Dijkstra
 namespace mld
 {
 struct Algorithm final
 {
 };
-}
+} // namespace mld
 
 // Algorithm names
 template <typename AlgorithmT> const char *name();
@@ -111,8 +111,8 @@ template <> struct HasGetTileTurns<mld::Algorithm> final : std::true_type
 template <> struct HasExcludeFlags<mld::Algorithm> final : std::true_type
 {
 };
-}
-}
-}
+} // namespace routing_algorithms
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/base_api.hpp b/include/engine/api/base_api.hpp
index 702a7f15f..3f27dcf51 100644
--- a/include/engine/api/base_api.hpp
+++ b/include/engine/api/base_api.hpp
@@ -56,8 +56,8 @@ class BaseAPI
             // TODO: check forward/reverse
             return json::makeWaypoint(
                 phantom.location,
-                util::coordinate_calculation::fccApproximateDistance(phantom.location,
-                                                                     phantom.input_location),
+                util::coordinate_calculation::greatCircleDistance(phantom.location,
+                                                                  phantom.input_location),
                 facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id)).to_string(),
                 Hint{phantom, facade.GetCheckSum()});
         }
@@ -66,8 +66,8 @@ class BaseAPI
             // TODO: check forward/reverse
             return json::makeWaypoint(
                 phantom.location,
-                util::coordinate_calculation::fccApproximateDistance(phantom.location,
-                                                                     phantom.input_location),
+                util::coordinate_calculation::greatCircleDistance(phantom.location,
+                                                                  phantom.input_location),
                 facade.GetNameForID(facade.GetNameIndex(phantom.forward_segment_id.id))
                     .to_string());
         }
@@ -114,7 +114,7 @@ class BaseAPI
 
         auto waypoint = std::make_unique<fbresult::WaypointBuilder>(*builder);
         waypoint->add_location(&location);
-        waypoint->add_distance(util::coordinate_calculation::fccApproximateDistance(
+        waypoint->add_distance(util::coordinate_calculation::greatCircleDistance(
             phantom.location, phantom.input_location));
         waypoint->add_name(name_string);
         if (parameters.generate_hints)
@@ -128,8 +128,8 @@ class BaseAPI
     const BaseParameters &parameters;
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/base_parameters.hpp b/include/engine/api/base_parameters.hpp
index e7a49378d..e49f71157 100644
--- a/include/engine/api/base_parameters.hpp
+++ b/include/engine/api/base_parameters.hpp
@@ -92,21 +92,21 @@ struct BaseParameters
 
     SnappingType snapping = SnappingType::Default;
 
-    BaseParameters(const std::vector<util::Coordinate> coordinates_ = {},
-                   const std::vector<boost::optional<Hint>> hints_ = {},
+    BaseParameters(std::vector<util::Coordinate> coordinates_ = {},
+                   std::vector<boost::optional<Hint>> hints_ = {},
                    std::vector<boost::optional<double>> radiuses_ = {},
                    std::vector<boost::optional<Bearing>> bearings_ = {},
                    std::vector<boost::optional<Approach>> approaches_ = {},
                    bool generate_hints_ = true,
                    std::vector<std::string> exclude = {},
                    const SnappingType snapping_ = SnappingType::Default)
-        : coordinates(coordinates_), hints(hints_), radiuses(radiuses_), bearings(bearings_),
-          approaches(approaches_), exclude(std::move(exclude)), generate_hints(generate_hints_),
-          snapping(snapping_)
+        : coordinates(std::move(coordinates_)), hints(std::move(hints_)),
+          radiuses(std::move(radiuses_)), bearings(std::move(bearings_)),
+          approaches(std::move(approaches_)), exclude(std::move(exclude)),
+          generate_hints(generate_hints_), snapping(snapping_)
     {
     }
 
-    // FIXME add validation for invalid bearing values
     bool IsValid() const
     {
         return (hints.empty() || hints.size() == coordinates.size()) &&
@@ -115,7 +115,7 @@ struct BaseParameters
                (approaches.empty() || approaches.size() == coordinates.size()) &&
                std::all_of(bearings.begin(),
                            bearings.end(),
-                           [](const boost::optional<Bearing> bearing_and_range) {
+                           [](const boost::optional<Bearing> &bearing_and_range) {
                                if (bearing_and_range)
                                {
                                    return bearing_and_range->IsValid();
@@ -124,8 +124,8 @@ struct BaseParameters
                            });
     }
 };
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif // ROUTE_PARAMETERS_HPP
diff --git a/include/engine/api/base_result.hpp b/include/engine/api/base_result.hpp
index 65dd6aeeb..5dd63e7a9 100644
--- a/include/engine/api/base_result.hpp
+++ b/include/engine/api/base_result.hpp
@@ -16,8 +16,8 @@ namespace api
 {
 using ResultT =
     mapbox::util::variant<util::json::Object, std::string, flatbuffers::FlatBufferBuilder>;
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/json_factory.hpp b/include/engine/api/json_factory.hpp
index 0ec505703..f92dba16a 100644
--- a/include/engine/api/json_factory.hpp
+++ b/include/engine/api/json_factory.hpp
@@ -112,8 +112,8 @@ util::json::Object makeRouteLeg(guidance::RouteLeg leg, util::json::Array steps)
 util::json::Array makeRouteLegs(std::vector<guidance::RouteLeg> legs,
                                 std::vector<util::json::Value> step_geometries,
                                 std::vector<util::json::Object> annotations);
-}
-}
+} // namespace json
+} // namespace api
 } // namespace engine
 } // namespace osrm
 
diff --git a/include/engine/api/match_api.hpp b/include/engine/api/match_api.hpp
index e1639794e..a93e49710 100644
--- a/include/engine/api/match_api.hpp
+++ b/include/engine/api/match_api.hpp
@@ -248,8 +248,8 @@ class MatchAPI final : public RouteAPI
     const tidy::Result &tidy_result;
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/match_parameters.hpp b/include/engine/api/match_parameters.hpp
index b54076582..774a2c09d 100644
--- a/include/engine/api/match_parameters.hpp
+++ b/include/engine/api/match_parameters.hpp
@@ -68,8 +68,11 @@ struct MatchParameters : public RouteParameters
     }
 
     template <typename... Args>
-    MatchParameters(std::vector<unsigned> timestamps_, GapsType gaps_, bool tidy_, Args... args_)
-        : MatchParameters(std::move(timestamps_), gaps_, tidy_, {}, std::forward<Args>(args_)...)
+    MatchParameters(const std::vector<unsigned> &timestamps_,
+                    GapsType gaps_,
+                    bool tidy_,
+                    Args &&... args_)
+        : MatchParameters(timestamps_, gaps_, tidy_, {}, std::forward<Args>(args_)...)
     {
     }
 
@@ -77,10 +80,11 @@ struct MatchParameters : public RouteParameters
     MatchParameters(std::vector<unsigned> timestamps_,
                     GapsType gaps_,
                     bool tidy_,
-                    std::vector<std::size_t> waypoints_,
-                    Args... args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_},
-          timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)
+                    const std::vector<std::size_t> &waypoints_,
+                    Args &&... args_)
+        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
+                                                                         timestamps_)},
+          gaps(gaps_), tidy(tidy_)
     {
     }
 
@@ -94,8 +98,8 @@ struct MatchParameters : public RouteParameters
                (timestamps.empty() || timestamps.size() == coordinates.size());
     }
 };
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/match_parameters_tidy.hpp b/include/engine/api/match_parameters_tidy.hpp
index ab4610c4f..694dd6885 100644
--- a/include/engine/api/match_parameters_tidy.hpp
+++ b/include/engine/api/match_parameters_tidy.hpp
@@ -122,7 +122,7 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
     // Walk over adjacent (coord, ts)-pairs, with rhs being the candidate to discard or keep
     for (std::size_t current = 0, next = 1; next < params.coordinates.size() - 1; ++current, ++next)
     {
-        auto distance_delta = util::coordinate_calculation::haversineDistance(
+        auto distance_delta = util::coordinate_calculation::greatCircleDistance(
             params.coordinates[current], params.coordinates[next]);
         running.distance_in_meters += distance_delta;
         const auto over_distance = running.distance_in_meters >= cfg.distance_in_meters;
@@ -200,9 +200,9 @@ inline Result tidy(const MatchParameters &params, Thresholds cfg = {15., 5})
     return result;
 }
 
-} // ns tidy
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace tidy
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/nearest_api.hpp b/include/engine/api/nearest_api.hpp
index 4cc01e41f..aff3c57dc 100644
--- a/include/engine/api/nearest_api.hpp
+++ b/include/engine/api/nearest_api.hpp
@@ -159,8 +159,8 @@ class NearestAPI final : public BaseAPI
     }
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/nearest_parameters.hpp b/include/engine/api/nearest_parameters.hpp
index f24251b8c..576e75352 100644
--- a/include/engine/api/nearest_parameters.hpp
+++ b/include/engine/api/nearest_parameters.hpp
@@ -52,8 +52,8 @@ struct NearestParameters : public BaseParameters
 
     bool IsValid() const { return BaseParameters::IsValid() && number_of_results >= 1; }
 };
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif // ENGINE_API_NEAREST_PARAMETERS_HPP
diff --git a/include/engine/api/route_api.hpp b/include/engine/api/route_api.hpp
index 1c8283fae..72244c453 100644
--- a/include/engine/api/route_api.hpp
+++ b/include/engine/api/route_api.hpp
@@ -688,7 +688,7 @@ class RouteAPI : public BaseAPI
                     intersection.classes.begin(),
                     intersection.classes.end(),
                     classes.begin(),
-                    [&fb_result](const std::string cls) { return fb_result.CreateString(cls); });
+                    [&fb_result](const std::string &cls) { return fb_result.CreateString(cls); });
                 auto classes_vector = fb_result.CreateVector(classes);
                 auto entry_vector = fb_result.CreateVector(intersection.entry);
 
@@ -988,8 +988,8 @@ class RouteAPI : public BaseAPI
     }
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/route_parameters.hpp b/include/engine/api/route_parameters.hpp
index ba200050d..8d5dd9ae4 100644
--- a/include/engine/api/route_parameters.hpp
+++ b/include/engine/api/route_parameters.hpp
@@ -87,19 +87,13 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args... args_)
+                    Args &&... args_)
         // Once we perfectly-forward `args` (see #2990) this constructor can delegate to the one
         // below.
-        : BaseParameters{std::forward<Args>(args_)...},
-          steps{steps_},
-          alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
-          annotations{false},
-          annotations_type{AnnotationsType::None},
-          geometries{geometries_},
-          overview{overview_},
-          continue_straight{continue_straight_},
-          waypoints()
+        : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
+          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{false},
+          annotations_type{AnnotationsType::None}, geometries{geometries_}, overview{overview_},
+          continue_straight{continue_straight_}, waypoints()
     {
     }
 
@@ -111,7 +105,7 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
@@ -129,12 +123,12 @@ struct RouteParameters : public BaseParameters
                     const GeometriesType geometries_,
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u},
-          annotations{annotations_ == AnnotationsType::None ? false : true},
-          annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints()
+          annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
+          waypoints()
     {
     }
 
@@ -147,12 +141,12 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    const Args... args_)
+                    const Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
-          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
-          waypoints{waypoints_}
+          geometries{geometries_}, overview{overview_},
+          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
     {
     }
 
@@ -165,12 +159,12 @@ struct RouteParameters : public BaseParameters
                     const OverviewType overview_,
                     const boost::optional<bool> continue_straight_,
                     std::vector<std::size_t> waypoints_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u},
-          annotations{annotations_ == AnnotationsType::None ? false : true},
+          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=
+                                                                       AnnotationsType::None},
           annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{waypoints_}
+          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
     {
     }
 
@@ -217,8 +211,8 @@ inline RouteParameters::AnnotationsType operator|=(RouteParameters::AnnotationsT
 {
     return lhs = lhs | rhs;
 }
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/table_api.hpp b/include/engine/api/table_api.hpp
index d3efe15d9..72cdea4e6 100644
--- a/include/engine/api/table_api.hpp
+++ b/include/engine/api/table_api.hpp
@@ -407,8 +407,8 @@ class TableAPI final : public BaseAPI
     const TableParameters &parameters;
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/table_parameters.hpp b/include/engine/api/table_parameters.hpp
index fbbf6831e..30e17900b 100644
--- a/include/engine/api/table_parameters.hpp
+++ b/include/engine/api/table_parameters.hpp
@@ -85,7 +85,7 @@ struct TableParameters : public BaseParameters
     template <typename... Args>
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}
     {
@@ -95,7 +95,7 @@ struct TableParameters : public BaseParameters
     TableParameters(std::vector<std::size_t> sources_,
                     std::vector<std::size_t> destinations_,
                     const AnnotationsType annotations_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}, annotations{annotations_}
     {
@@ -108,7 +108,7 @@ struct TableParameters : public BaseParameters
                     double fallback_speed_,
                     FallbackCoordinateType fallback_coordinate_type_,
                     double scale_factor_,
-                    Args... args_)
+                    Args &&... args_)
         : BaseParameters{std::forward<Args>(args_)...}, sources{std::move(sources_)},
           destinations{std::move(destinations_)}, fallback_speed{fallback_speed_},
           fallback_coordinate_type{fallback_coordinate_type_}, annotations{annotations_},
@@ -122,7 +122,7 @@ struct TableParameters : public BaseParameters
         if (!BaseParameters::IsValid())
             return false;
 
-        // Distance Table makes only sense with 2+ coodinates
+        // Distance Table makes only sense with 2+ coordinates
         if (coordinates.size() < 2)
             return false;
 
@@ -166,8 +166,8 @@ inline TableParameters::AnnotationsType &operator|=(TableParameters::Annotations
 {
     return lhs = lhs | rhs;
 }
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif // ENGINE_API_TABLE_PARAMETERS_HPP
diff --git a/include/engine/api/tile_parameters.hpp b/include/engine/api/tile_parameters.hpp
index 137c4dac3..e5328e7c7 100644
--- a/include/engine/api/tile_parameters.hpp
+++ b/include/engine/api/tile_parameters.hpp
@@ -70,8 +70,8 @@ struct TileParameters final
         return valid_x && valid_y && valid_z;
     }
 };
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/trip_api.hpp b/include/engine/api/trip_api.hpp
index 65f9381fc..90e5e1391 100644
--- a/include/engine/api/trip_api.hpp
+++ b/include/engine/api/trip_api.hpp
@@ -175,8 +175,8 @@ class TripAPI final : public RouteAPI
     const TripParameters &parameters;
 };
 
-} // ns api
-} // ns engine
-} // ns osrm
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/api/trip_parameters.hpp b/include/engine/api/trip_parameters.hpp
index 0df38d6c9..84d6b861a 100644
--- a/include/engine/api/trip_parameters.hpp
+++ b/include/engine/api/trip_parameters.hpp
@@ -65,8 +65,8 @@ struct TripParameters : public RouteParameters
                    DestinationType destination_,
                    bool roundtrip_,
                    Args &&... args_)
-        : RouteParameters{std::forward<Args>(args_)...}, source{source_}, destination{destination_},
-          roundtrip{roundtrip_}
+        : RouteParameters{std::forward<Args>(args_)...}, source{source_},
+          destination{destination_}, roundtrip{roundtrip_}
     {
     }
 
@@ -76,8 +76,8 @@ struct TripParameters : public RouteParameters
 
     bool IsValid() const { return RouteParameters::IsValid(); }
 };
-}
-}
-}
+} // namespace api
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/approach.hpp b/include/engine/approach.hpp
index 5c6787f27..f7d671a9c 100644
--- a/include/engine/approach.hpp
+++ b/include/engine/approach.hpp
@@ -42,5 +42,5 @@ enum class Approach : std::uint8_t
 
 };
 }
-}
+} // namespace osrm
 #endif
diff --git a/include/engine/base64.hpp b/include/engine/base64.hpp
index 024d04b29..d1fa8753c 100644
--- a/include/engine/base64.hpp
+++ b/include/engine/base64.hpp
@@ -38,7 +38,7 @@ using BinaryFromBase64 = boost::archive::iterators::transform_width<
     8, // get a view of 8 bit
     6  // from a sequence of 6 bit
     >;
-} // ns detail
+} // namespace detail
 namespace engine
 {
 
@@ -135,7 +135,7 @@ template <typename T> T decodeBase64Bytewise(const std::string &encoded)
     return x;
 }
 
-} // ns engine
-} // ns osrm
+} // namespace engine
+} // namespace osrm
 
 #endif /* OSRM_BASE64_HPP */
diff --git a/include/engine/bearing.hpp b/include/engine/bearing.hpp
index eaabae781..54e24f57f 100644
--- a/include/engine/bearing.hpp
+++ b/include/engine/bearing.hpp
@@ -46,7 +46,7 @@ inline bool operator==(const Bearing lhs, const Bearing rhs)
     return lhs.bearing == rhs.bearing && lhs.range == rhs.range;
 }
 inline bool operator!=(const Bearing lhs, const Bearing rhs) { return !(lhs == rhs); }
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/data_watchdog.hpp b/include/engine/data_watchdog.hpp
index 416f1df76..29fb93443 100644
--- a/include/engine/data_watchdog.hpp
+++ b/include/engine/data_watchdog.hpp
@@ -142,14 +142,14 @@ class DataWatchdogImpl<AlgorithmT, datafacade::ContiguousInternalMemoryDataFacad
     storage::SharedRegion *updatable_shared_region;
     DataFacadeFactory<datafacade::ContiguousInternalMemoryDataFacade, AlgorithmT> facade_factory;
 };
-}
+} // namespace detail
 
 // This class monitors the shared memory region that contains the pointers to
 // the data and layout regions that should be used. This region is updated
 // once a new dataset arrives.
 template <typename AlgorithmT, template <typename A> class FacadeT>
 using DataWatchdog = detail::DataWatchdogImpl<AlgorithmT, FacadeT<AlgorithmT>>;
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/datafacade.hpp b/include/engine/datafacade.hpp
index 76068a472..f0f8e9e5b 100644
--- a/include/engine/datafacade.hpp
+++ b/include/engine/datafacade.hpp
@@ -11,7 +11,7 @@ namespace engine
 using DataFacadeBase = datafacade::ContiguousInternalMemoryDataFacadeBase;
 template <typename AlgorithmT>
 using DataFacade = datafacade::ContiguousInternalMemoryDataFacade<AlgorithmT>;
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/datafacade/algorithm_datafacade.hpp b/include/engine/datafacade/algorithm_datafacade.hpp
index a83a5340c..38030511c 100644
--- a/include/engine/datafacade/algorithm_datafacade.hpp
+++ b/include/engine/datafacade/algorithm_datafacade.hpp
@@ -99,8 +99,8 @@ template <> class AlgorithmDataFacade<MLD>
     // searches for a specific edge
     virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;
 };
-}
-}
-}
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index 63d4dbc3a..e448a8f57 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -609,7 +609,7 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         auto found_range = std::equal_range(
             m_maneuver_overrides.begin(), m_maneuver_overrides.end(), edge_based_node_id, Comp{});
 
-        std::for_each(found_range.first, found_range.second, [&](const auto & override) {
+        std::for_each(found_range.first, found_range.second, [&](const auto &override) {
             std::vector<NodeID> sequence(
                 m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_begin,
                 m_maneuver_override_node_sequences.begin() + override.node_sequence_offset_end);
@@ -630,7 +630,7 @@ class ContiguousInternalMemoryDataFacade<CH>
       public ContiguousInternalMemoryAlgorithmDataFacade<CH>
 {
   public:
-    ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+    ContiguousInternalMemoryDataFacade(const std::shared_ptr<ContiguousBlockAllocator> &allocator,
                                        const std::string &metric_name,
                                        const std::size_t exclude_index)
         : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
@@ -752,7 +752,7 @@ class ContiguousInternalMemoryDataFacade<MLD> final
 {
   private:
   public:
-    ContiguousInternalMemoryDataFacade(std::shared_ptr<ContiguousBlockAllocator> allocator,
+    ContiguousInternalMemoryDataFacade(const std::shared_ptr<ContiguousBlockAllocator> &allocator,
                                        const std::string &metric_name,
                                        const std::size_t exclude_index)
         : ContiguousInternalMemoryDataFacadeBase(allocator, metric_name, exclude_index),
@@ -760,8 +760,8 @@ class ContiguousInternalMemoryDataFacade<MLD> final
     {
     }
 };
-}
-}
-}
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm
 
 #endif // CONTIGUOUS_INTERNALMEM_DATAFACADE_HPP
diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp
index 77dab643f..b80c93b18 100644
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@@ -223,8 +223,8 @@ class BaseDataFacade
     virtual std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID edge_based_node_id) const = 0;
 };
-}
-}
-}
+} // namespace datafacade
+} // namespace engine
+} // namespace osrm
 
 #endif // DATAFACADE_BASE_HPP
diff --git a/include/engine/datafacade/mmap_memory_allocator.hpp b/include/engine/datafacade/mmap_memory_allocator.hpp
index fc4b4e24a..817fcf9db 100644
--- a/include/engine/datafacade/mmap_memory_allocator.hpp
+++ b/include/engine/datafacade/mmap_memory_allocator.hpp
@@ -22,7 +22,7 @@ namespace datafacade
 /**
  * This allocator uses file backed mmap memory block as the data location.
  */
-class MMapMemoryAllocator : public ContiguousBlockAllocator
+class MMapMemoryAllocator final : public ContiguousBlockAllocator
 {
   public:
     explicit MMapMemoryAllocator(const storage::StorageConfig &config);
diff --git a/include/engine/datafacade/process_memory_allocator.hpp b/include/engine/datafacade/process_memory_allocator.hpp
index 0dd555e26..742f20e36 100644
--- a/include/engine/datafacade/process_memory_allocator.hpp
+++ b/include/engine/datafacade/process_memory_allocator.hpp
@@ -20,7 +20,7 @@ namespace datafacade
  * This class holds a unique_ptr to the memory block, so it
  * is auto-freed upon destruction.
  */
-class ProcessMemoryAllocator : public ContiguousBlockAllocator
+class ProcessMemoryAllocator final : public ContiguousBlockAllocator
 {
   public:
     explicit ProcessMemoryAllocator(const storage::StorageConfig &config);
diff --git a/include/engine/datafacade/shared_memory_allocator.hpp b/include/engine/datafacade/shared_memory_allocator.hpp
index 00b37ac7f..5b0a0989a 100644
--- a/include/engine/datafacade/shared_memory_allocator.hpp
+++ b/include/engine/datafacade/shared_memory_allocator.hpp
@@ -20,7 +20,7 @@ namespace datafacade
  * Many SharedMemoryDataFacade objects can be created that point to the same shared
  * memory block.
  */
-class SharedMemoryAllocator : public ContiguousBlockAllocator
+class SharedMemoryAllocator final : public ContiguousBlockAllocator
 {
   public:
     explicit SharedMemoryAllocator(
diff --git a/include/engine/datafacade_factory.hpp b/include/engine/datafacade_factory.hpp
index a4ff57f38..e01c70f72 100644
--- a/include/engine/datafacade_factory.hpp
+++ b/include/engine/datafacade_factory.hpp
@@ -65,12 +65,12 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
 
         for (const auto &exclude_prefix : exclude_prefixes)
         {
-            auto index_begin = exclude_prefix.find_last_of("/");
+            auto index_begin = exclude_prefix.find_last_of('/');
             BOOST_ASSERT_MSG(index_begin != std::string::npos,
                              "The exclude prefix needs to be a valid data path.");
             std::size_t index =
                 std::stoi(exclude_prefix.substr(index_begin + 1, exclude_prefix.size()));
-            BOOST_ASSERT(index >= 0 && index < facades.size());
+            BOOST_ASSERT(index < facades.size());
             facades[index] = std::make_shared<const Facade>(allocator, metric_name, index);
         }
 
@@ -152,7 +152,7 @@ template <template <typename A> class FacadeT, typename AlgorithmT> class DataFa
     std::unordered_map<std::string, extractor::ClassData> name_to_class;
     const extractor::ProfileProperties *properties = nullptr;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/datafacade_provider.hpp b/include/engine/datafacade_provider.hpp
index 0f1441f6a..0ad6370f0 100644
--- a/include/engine/datafacade_provider.hpp
+++ b/include/engine/datafacade_provider.hpp
@@ -93,7 +93,7 @@ class WatchingProvider : public DataFacadeProvider<AlgorithmT, FacadeT>
         return watchdog.Get(params);
     }
 };
-}
+} // namespace detail
 
 template <typename AlgorithmT>
 using DataFacadeProvider = detail::DataFacadeProvider<AlgorithmT, DataFacade>;
@@ -103,7 +103,7 @@ template <typename AlgorithmT>
 using ImmutableProvider = detail::ImmutableProvider<AlgorithmT, DataFacade>;
 template <typename AlgorithmT>
 using ExternalProvider = detail::ExternalProvider<AlgorithmT, DataFacade>;
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/douglas_peucker.hpp b/include/engine/douglas_peucker.hpp
index 0f48378f7..1dced2617 100644
--- a/include/engine/douglas_peucker.hpp
+++ b/include/engine/douglas_peucker.hpp
@@ -57,7 +57,7 @@ const constexpr std::uint64_t DOUGLAS_PEUCKER_THRESHOLDS[19] = {
 
 const constexpr auto DOUGLAS_PEUCKER_THRESHOLDS_SIZE =
     sizeof(DOUGLAS_PEUCKER_THRESHOLDS) / sizeof(*DOUGLAS_PEUCKER_THRESHOLDS);
-} // ns detail
+} // namespace detail
 
 // These functions compute the bitvector of indicating generalized input
 // points according to the (Ramer-)Douglas-Peucker algorithm.
@@ -75,7 +75,7 @@ inline std::vector<util::Coordinate> douglasPeucker(const std::vector<util::Coor
 {
     return douglasPeucker(begin(geometry), end(geometry), zoom_level);
 }
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif /* DOUGLAS_PEUCKER_HPP_ */
diff --git a/include/engine/engine.hpp b/include/engine/engine.hpp
index d7b533970..4fe63ec05 100644
--- a/include/engine/engine.hpp
+++ b/include/engine/engine.hpp
@@ -130,7 +130,7 @@ template <typename Algorithm> class Engine final : public EngineInterface
     const plugins::MatchPlugin match_plugin;
     const plugins::TilePlugin tile_plugin;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // OSRM_IMPL_HPP
diff --git a/include/engine/engine_config.hpp b/include/engine/engine_config.hpp
index cc0cc4a93..ece74b3a5 100644
--- a/include/engine/engine_config.hpp
+++ b/include/engine/engine_config.hpp
@@ -94,7 +94,7 @@ struct EngineConfig final
     std::string verbosity;
     std::string dataset_name;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // SERVER_CONFIG_HPP
diff --git a/include/engine/geospatial_query.hpp b/include/engine/geospatial_query.hpp
index b4a05b18d..2b01b20dd 100644
--- a/include/engine/geospatial_query.hpp
+++ b/include/engine/geospatial_query.hpp
@@ -467,11 +467,13 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         const auto forward_geometry = datafacade.GetUncompressedForwardGeometry(geometry_id);
 
         const auto forward_weight_offset =
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             std::accumulate(forward_weights.begin(),
                             forward_weights.begin() + data.fwd_segment_position,
                             EdgeWeight{0});
 
         const auto forward_duration_offset =
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             std::accumulate(forward_durations.begin(),
                             forward_durations.begin() + data.fwd_segment_position,
                             EdgeDuration{0});
@@ -482,7 +484,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
              current < forward_geometry.begin() + data.fwd_segment_position;
              ++current)
         {
-            forward_distance_offset += util::coordinate_calculation::fccApproximateDistance(
+            forward_distance_offset += util::coordinate_calculation::greatCircleDistance(
                 datafacade.GetCoordinateOfNode(*current),
                 datafacade.GetCoordinateOfNode(*std::next(current)));
         }
@@ -492,7 +494,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
 
         EdgeWeight forward_weight = forward_weights[data.fwd_segment_position];
         EdgeDuration forward_duration = forward_durations[data.fwd_segment_position];
-        EdgeDistance forward_distance = util::coordinate_calculation::fccApproximateDistance(
+        EdgeDistance forward_distance = util::coordinate_calculation::greatCircleDistance(
             datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position)),
             point_on_segment);
 
@@ -512,7 +514,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
              current != std::prev(forward_geometry.end());
              ++current)
         {
-            reverse_distance_offset += util::coordinate_calculation::fccApproximateDistance(
+            reverse_distance_offset += util::coordinate_calculation::greatCircleDistance(
                 datafacade.GetCoordinateOfNode(*current),
                 datafacade.GetCoordinateOfNode(*std::next(current)));
         }
@@ -521,7 +523,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
             reverse_weights[reverse_weights.size() - data.fwd_segment_position - 1];
         EdgeDuration reverse_duration =
             reverse_durations[reverse_durations.size() - data.fwd_segment_position - 1];
-        EdgeDistance reverse_distance = util::coordinate_calculation::fccApproximateDistance(
+        EdgeDistance reverse_distance = util::coordinate_calculation::greatCircleDistance(
             point_on_segment,
             datafacade.GetCoordinateOfNode(forward_geometry(data.fwd_segment_position + 1)));
 
@@ -590,8 +592,8 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
         Coordinate wsg84_coordinate =
             util::web_mercator::toWGS84(segment.fixed_projected_coordinate);
 
-        return util::coordinate_calculation::haversineDistance(input_coordinate, wsg84_coordinate) >
-               max_distance;
+        return util::coordinate_calculation::greatCircleDistance(input_coordinate,
+                                                                 wsg84_coordinate) > max_distance;
     }
 
     std::pair<bool, bool> CheckSegmentExclude(const CandidateSegment &segment) const
@@ -715,7 +717,7 @@ template <typename RTreeT, typename DataFacadeT> class GeospatialQuery
     const CoordinateList &coordinates;
     DataFacadeT &datafacade;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/guidance/assemble_geometry.hpp b/include/engine/guidance/assemble_geometry.hpp
index eb4f9cf95..736c868fd 100644
--- a/include/engine/guidance/assemble_geometry.hpp
+++ b/include/engine/guidance/assemble_geometry.hpp
@@ -67,7 +67,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
     {
         auto coordinate = facade.GetCoordinateOfNode(path_point.turn_via_node);
         current_distance =
-            util::coordinate_calculation::haversineDistance(prev_coordinate, coordinate);
+            util::coordinate_calculation::greatCircleDistance(prev_coordinate, coordinate);
         cumulative_distance += current_distance;
 
         // all changes to this check have to be matched with assemble_steps
@@ -103,7 +103,7 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
         }
     }
     current_distance =
-        util::coordinate_calculation::haversineDistance(prev_coordinate, target_node.location);
+        util::coordinate_calculation::greatCircleDistance(prev_coordinate, target_node.location);
     cumulative_distance += current_distance;
     // segment leading to the target node
     geometry.segment_distances.push_back(cumulative_distance);
@@ -167,8 +167,8 @@ inline LegGeometry assembleGeometry(const datafacade::BaseDataFacade &facade,
 
     return geometry;
 }
-}
-}
-}
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/guidance/assemble_leg.hpp b/include/engine/guidance/assemble_leg.hpp
index 5bd2cca0e..0a49ae81e 100644
--- a/include/engine/guidance/assemble_leg.hpp
+++ b/include/engine/guidance/assemble_leg.hpp
@@ -122,7 +122,7 @@ std::array<std::uint32_t, SegmentNumber> summarizeRoute(const datafacade::BaseDa
                    [](const NamedSegment &segment) { return segment.name_id; });
     return summary;
 }
-}
+} // namespace detail
 
 inline RouteLeg assembleLeg(const datafacade::BaseDataFacade &facade,
                             const std::vector<PathData> &route_data,
diff --git a/include/engine/guidance/assemble_steps.hpp b/include/engine/guidance/assemble_steps.hpp
index 75344c063..ac65a539f 100644
--- a/include/engine/guidance/assemble_steps.hpp
+++ b/include/engine/guidance/assemble_steps.hpp
@@ -35,7 +35,7 @@ std::pair<short, short> getDepartBearings(const LegGeometry &leg_geometry,
 std::pair<short, short> getArriveBearings(const LegGeometry &leg_geometry,
                                           const PhantomNode &target_node,
                                           const bool traversed_in_reverse);
-} // ns detail
+} // namespace detail
 
 inline std::vector<RouteStep> assembleSteps(const datafacade::BaseDataFacade &facade,
                                             const std::vector<PathData> &leg_data,
diff --git a/include/engine/guidance/collapse_turns.hpp b/include/engine/guidance/collapse_turns.hpp
index b8b5d3198..d2db4a420 100644
--- a/include/engine/guidance/collapse_turns.hpp
+++ b/include/engine/guidance/collapse_turns.hpp
@@ -163,7 +163,7 @@ void combineRouteSteps(RouteStep &step_at_turn_location,
 void suppressStep(RouteStep &step_at_turn_location, RouteStep &step_after_turn_location);
 
 } /* namespace guidance */
-} /* namespace osrm */
+} // namespace engine
 } /* namespace osrm */
 
 #endif /* OSRM_ENGINE_GUIDANCE_COLLAPSE_HPP_ */
diff --git a/include/engine/guidance/leg_geometry.hpp b/include/engine/guidance/leg_geometry.hpp
index a1ba56c81..8374bb992 100644
--- a/include/engine/guidance/leg_geometry.hpp
+++ b/include/engine/guidance/leg_geometry.hpp
@@ -64,8 +64,8 @@ struct LegGeometry
         return segment_offsets.size() - 1;
     }
 };
-}
-}
-}
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/guidance/route.hpp b/include/engine/guidance/route.hpp
index 461da4cc7..fa750d4da 100644
--- a/include/engine/guidance/route.hpp
+++ b/include/engine/guidance/route.hpp
@@ -14,8 +14,8 @@ struct Route
     double duration;
     double weight;
 };
-}
-}
-}
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/guidance/route_leg.hpp b/include/engine/guidance/route_leg.hpp
index c9f4e2ab5..443c2ae23 100644
--- a/include/engine/guidance/route_leg.hpp
+++ b/include/engine/guidance/route_leg.hpp
@@ -23,8 +23,8 @@ struct RouteLeg
     std::string summary;
     std::vector<RouteStep> steps;
 };
-}
-}
-}
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/guidance/step_maneuver.hpp b/include/engine/guidance/step_maneuver.hpp
index 6d5dcede7..efe0726ca 100644
--- a/include/engine/guidance/step_maneuver.hpp
+++ b/include/engine/guidance/step_maneuver.hpp
@@ -46,5 +46,5 @@ inline StepManeuver getInvalidStepManeuver()
 
 } // namespace guidance
 } // namespace engine
-} // namespace osrmn
+} // namespace osrm
 #endif
diff --git a/include/engine/hint.hpp b/include/engine/hint.hpp
index 3ab69b928..50e7cdb16 100644
--- a/include/engine/hint.hpp
+++ b/include/engine/hint.hpp
@@ -67,7 +67,7 @@ static_assert(sizeof(Hint) == 80 + 4, "Hint is bigger than expected");
 constexpr std::size_t ENCODED_HINT_SIZE = 112;
 static_assert(ENCODED_HINT_SIZE / 4 * 3 >= sizeof(Hint),
               "ENCODED_HINT_SIZE does not match size of Hint");
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/internal_route_result.hpp b/include/engine/internal_route_result.hpp
index bd4798f5b..9f5443ffa 100644
--- a/include/engine/internal_route_result.hpp
+++ b/include/engine/internal_route_result.hpp
@@ -173,7 +173,7 @@ inline InternalRouteResult CollapseInternalRouteResult(const InternalRouteResult
                  collapsed.unpacked_path_segments.size());
     return collapsed;
 }
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // RAW_ROUTE_DATA_H
diff --git a/include/engine/map_matching/bayes_classifier.hpp b/include/engine/map_matching/bayes_classifier.hpp
index 70e2cfd30..c93277f64 100644
--- a/include/engine/map_matching/bayes_classifier.hpp
+++ b/include/engine/map_matching/bayes_classifier.hpp
@@ -98,8 +98,8 @@ class BayesClassifier
     double positive_apriori_probability;
     double negative_apriori_probability;
 };
-}
-}
-}
+} // namespace map_matching
+} // namespace engine
+} // namespace osrm
 
 #endif // BAYES_CLASSIFIER_HPP
diff --git a/include/engine/map_matching/hidden_markov_model.hpp b/include/engine/map_matching/hidden_markov_model.hpp
index 8f1e4d1ff..30bb8254b 100644
--- a/include/engine/map_matching/hidden_markov_model.hpp
+++ b/include/engine/map_matching/hidden_markov_model.hpp
@@ -137,8 +137,8 @@ template <class CandidateLists> struct HiddenMarkovModel
         return initial_timestamp;
     }
 };
-}
-}
-}
+} // namespace map_matching
+} // namespace engine
+} // namespace osrm
 
 #endif // HIDDEN_MARKOV_MODEL
diff --git a/include/engine/map_matching/matching_confidence.hpp b/include/engine/map_matching/matching_confidence.hpp
index 03613b048..2ae8728d6 100644
--- a/include/engine/map_matching/matching_confidence.hpp
+++ b/include/engine/map_matching/matching_confidence.hpp
@@ -51,8 +51,8 @@ struct MatchingConfidence
   private:
     ClassifierT classifier;
 };
-}
-}
-}
+} // namespace map_matching
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/map_matching/sub_matching.hpp b/include/engine/map_matching/sub_matching.hpp
index e272423e7..544978d61 100644
--- a/include/engine/map_matching/sub_matching.hpp
+++ b/include/engine/map_matching/sub_matching.hpp
@@ -19,8 +19,8 @@ struct SubMatching
     std::vector<unsigned> alternatives_count;
     double confidence;
 };
-}
-}
-}
+} // namespace map_matching
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/phantom_node.hpp b/include/engine/phantom_node.hpp
index 3cb0b9593..d535283d3 100644
--- a/include/engine/phantom_node.hpp
+++ b/include/engine/phantom_node.hpp
@@ -44,14 +44,15 @@ namespace engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
-          reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset(0), reverse_weight_offset(0),
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
+                                                                           false},
+          forward_weight(INVALID_EDGE_WEIGHT), reverse_weight(INVALID_EDGE_WEIGHT),
+          forward_weight_offset(0), reverse_weight_offset(0),
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset(0), reverse_distance_offset(0),
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
-          forward_duration_offset(0), reverse_duration_offset(0), fwd_segment_position(0),
-          is_valid_forward_source{false}, is_valid_forward_target{false},
+          forward_duration_offset(0), reverse_duration_offset(0),
+          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
 
     {
@@ -109,8 +110,9 @@ struct PhantomNode
 
     bool IsValid(const unsigned number_of_nodes) const
     {
-        return location.IsValid() && ((forward_segment_id.id < number_of_nodes) ||
-                                      (reverse_segment_id.id < number_of_nodes)) &&
+        return location.IsValid() &&
+               ((forward_segment_id.id < number_of_nodes) ||
+                (reverse_segment_id.id < number_of_nodes)) &&
                ((forward_weight != INVALID_EDGE_WEIGHT) ||
                 (reverse_weight != INVALID_EDGE_WEIGHT)) &&
                ((forward_duration != MAXIMAL_EDGE_DURATION) ||
@@ -234,7 +236,7 @@ struct PhantomNodes
     PhantomNode source_phantom;
     PhantomNode target_phantom;
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // PHANTOM_NODES_H
diff --git a/include/engine/plugins/match.hpp b/include/engine/plugins/match.hpp
index 3717aa718..5b2bdca30 100644
--- a/include/engine/plugins/match.hpp
+++ b/include/engine/plugins/match.hpp
@@ -38,8 +38,8 @@ class MatchPlugin : public BasePlugin
     const int max_locations_map_matching;
     const double max_radius_map_matching;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif // MATCH_HPP
diff --git a/include/engine/plugins/nearest.hpp b/include/engine/plugins/nearest.hpp
index d696c46b0..4582de348 100644
--- a/include/engine/plugins/nearest.hpp
+++ b/include/engine/plugins/nearest.hpp
@@ -26,8 +26,8 @@ class NearestPlugin final : public BasePlugin
   private:
     const int max_results;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif /* NEAREST_HPP */
diff --git a/include/engine/plugins/plugin_base.hpp b/include/engine/plugins/plugin_base.hpp
index 6fc23adcd..b437b1a6c 100644
--- a/include/engine/plugins/plugin_base.hpp
+++ b/include/engine/plugins/plugin_base.hpp
@@ -131,8 +131,10 @@ class BasePlugin
                 return phantom_pair.first;
             };
 
-        const auto use_closed_phantom = [](
-            const std::pair<PhantomNode, PhantomNode> &phantom_pair) { return phantom_pair.first; };
+        const auto use_closed_phantom =
+            [](const std::pair<PhantomNode, PhantomNode> &phantom_pair) {
+                return phantom_pair.first;
+            };
 
         const bool every_phantom_is_in_tiny_cc = std::all_of(std::begin(phantom_node_pair_list),
                                                              std::end(phantom_node_pair_list),
@@ -166,7 +168,7 @@ class BasePlugin
     std::vector<std::vector<PhantomNodeWithDistance>>
     GetPhantomNodesInRange(const datafacade::BaseDataFacade &facade,
                            const api::BaseParameters &parameters,
-                           const std::vector<double> radiuses,
+                           const std::vector<double> &radiuses,
                            bool use_all_edges = false) const
     {
         std::vector<std::vector<PhantomNodeWithDistance>> phantom_nodes(
@@ -188,7 +190,7 @@ class BasePlugin
             {
                 phantom_nodes[i].push_back(PhantomNodeWithDistance{
                     parameters.hints[i]->phantom,
-                    util::coordinate_calculation::haversineDistance(
+                    util::coordinate_calculation::greatCircleDistance(
                         parameters.coordinates[i], parameters.hints[i]->phantom.location),
                 });
                 continue;
@@ -238,7 +240,7 @@ class BasePlugin
             {
                 phantom_nodes[i].push_back(PhantomNodeWithDistance{
                     parameters.hints[i]->phantom,
-                    util::coordinate_calculation::haversineDistance(
+                    util::coordinate_calculation::greatCircleDistance(
                         parameters.coordinates[i], parameters.hints[i]->phantom.location),
                 });
                 continue;
@@ -388,8 +390,8 @@ class BasePlugin
                std::to_string(missing_index);
     }
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif /* BASE_PLUGIN_HPP */
diff --git a/include/engine/plugins/table.hpp b/include/engine/plugins/table.hpp
index 1cd7da6e9..d8e5a32e9 100644
--- a/include/engine/plugins/table.hpp
+++ b/include/engine/plugins/table.hpp
@@ -27,8 +27,8 @@ class TablePlugin final : public BasePlugin
   private:
     const int max_locations_distance_table;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif // TABLE_HPP
diff --git a/include/engine/plugins/tile.hpp b/include/engine/plugins/tile.hpp
index 90d598d78..5d4bdb5b0 100644
--- a/include/engine/plugins/tile.hpp
+++ b/include/engine/plugins/tile.hpp
@@ -30,8 +30,8 @@ class TilePlugin final : public BasePlugin
                          const api::TileParameters &parameters,
                          osrm::engine::api::ResultT &pbf_buffer) const;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif /* TILEPLUGIN_HPP */
diff --git a/include/engine/plugins/trip.hpp b/include/engine/plugins/trip.hpp
index ee45729f8..2cf9da4de 100644
--- a/include/engine/plugins/trip.hpp
+++ b/include/engine/plugins/trip.hpp
@@ -42,8 +42,8 @@ class TripPlugin final : public BasePlugin
                          const api::TripParameters &parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif // TRIP_HPP
diff --git a/include/engine/plugins/viaroute.hpp b/include/engine/plugins/viaroute.hpp
index 70642d6d1..719749472 100644
--- a/include/engine/plugins/viaroute.hpp
+++ b/include/engine/plugins/viaroute.hpp
@@ -35,8 +35,8 @@ class ViaRoutePlugin final : public BasePlugin
                          const api::RouteParameters &route_parameters,
                          osrm::engine::api::ResultT &json_result) const;
 };
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
 
 #endif // VIA_ROUTE_HPP
diff --git a/include/engine/polyline_compressor.hpp b/include/engine/polyline_compressor.hpp
index fb64b9de9..224f1ed3b 100644
--- a/include/engine/polyline_compressor.hpp
+++ b/include/engine/polyline_compressor.hpp
@@ -17,7 +17,7 @@ namespace detail
 std::string encode(std::vector<int> &numbers);
 std::int32_t decode_polyline_integer(std::string::const_iterator &first,
                                      std::string::const_iterator last);
-}
+} // namespace detail
 using CoordVectorForwardIter = std::vector<util::Coordinate>::const_iterator;
 // Encodes geometry into polyline format.
 // See: https://developers.google.com/maps/documentation/utilities/polylinealgorithm
@@ -80,7 +80,7 @@ std::vector<util::Coordinate> decodePolyline(const std::string &polyline)
     }
     return coordinates;
 }
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif /* POLYLINECOMPRESSOR_H_ */
diff --git a/include/engine/routing_algorithms.hpp b/include/engine/routing_algorithms.hpp
index 5d4a8a956..8bedcb8d8 100644
--- a/include/engine/routing_algorithms.hpp
+++ b/include/engine/routing_algorithms.hpp
@@ -230,7 +230,7 @@ inline std::vector<routing_algorithms::TurnData> RoutingAlgorithms<Algorithm>::G
     return routing_algorithms::getTileTurns(*facade, edges, sorted_edge_indexes);
 }
 
-} // ns engine
-} // ns osrm
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/routing_algorithms/routing_base.hpp b/include/engine/routing_algorithms/routing_base.hpp
index ee564afe2..c7df59e80 100644
--- a/include/engine/routing_algorithms/routing_base.hpp
+++ b/include/engine/routing_algorithms/routing_base.hpp
@@ -336,7 +336,7 @@ void annotatePath(const FacadeT &facade,
 
 template <typename Algorithm>
 double getPathDistance(const DataFacade<Algorithm> &facade,
-                       const std::vector<PathData> unpacked_path,
+                       const std::vector<PathData> &unpacked_path,
                        const PhantomNode &source_phantom,
                        const PhantomNode &target_phantom)
 {
@@ -428,7 +428,7 @@ template <typename FacadeT> EdgeDistance computeEdgeDistance(const FacadeT &faca
     auto geometry_range = facade.GetUncompressedForwardGeometry(geometry_index.id);
     for (auto current = geometry_range.begin(); current < geometry_range.end() - 1; ++current)
     {
-        total_distance += util::coordinate_calculation::fccApproximateDistance(
+        total_distance += util::coordinate_calculation::greatCircleDistance(
             facade.GetCoordinateOfNode(*current), facade.GetCoordinateOfNode(*std::next(current)));
     }
 
diff --git a/include/engine/routing_algorithms/routing_base_ch.hpp b/include/engine/routing_algorithms/routing_base_ch.hpp
index 79044c8d6..863d29cf3 100644
--- a/include/engine/routing_algorithms/routing_base_ch.hpp
+++ b/include/engine/routing_algorithms/routing_base_ch.hpp
@@ -24,11 +24,10 @@ namespace ch
 // Stalling
 template <bool DIRECTION, typename HeapT>
 bool stallAtNode(const DataFacade<Algorithm> &facade,
-                 const NodeID node,
-                 const EdgeWeight weight,
+                 const typename HeapT::HeapNode &heapNode,
                  const HeapT &query_heap)
 {
-    for (auto edge : facade.GetAdjacentEdgeRange(node))
+    for (auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == REVERSE_DIRECTION ? data.forward : data.backward)
@@ -36,9 +35,10 @@ bool stallAtNode(const DataFacade<Algorithm> &facade,
             const NodeID to = facade.GetTarget(edge);
             const EdgeWeight edge_weight = data.weight;
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            if (query_heap.WasInserted(to))
+            const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
+            if (toHeapNode)
             {
-                if (query_heap.GetKey(to) + edge_weight < weight)
+                if (toHeapNode->weight + edge_weight < heapNode.weight)
                 {
                     return true;
                 }
@@ -50,11 +50,10 @@ bool stallAtNode(const DataFacade<Algorithm> &facade,
 
 template <bool DIRECTION>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        const NodeID node,
-                        const EdgeWeight weight,
+                        const SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
                         SearchEngineData<Algorithm>::QueryHeap &heap)
 {
-    for (const auto edge : facade.GetAdjacentEdgeRange(node))
+    for (const auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
@@ -63,19 +62,21 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const EdgeWeight edge_weight = data.weight;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            const EdgeWeight to_weight = weight + edge_weight;
+            const EdgeWeight to_weight = heapNode.weight + edge_weight;
 
+            const auto toHeapNode = heap.GetHeapNodeIfWasInserted(to);
             // New Node discovered -> Add to Heap + Node Info Storage
-            if (!heap.WasInserted(to))
+            if (!toHeapNode)
             {
-                heap.Insert(to, to_weight, node);
+                heap.Insert(to, to_weight, heapNode.node);
             }
             // Found a shorter Path -> Update weight
-            else if (to_weight < heap.GetKey(to))
+            else if (to_weight < toHeapNode->weight)
             {
                 // new parent
-                heap.GetData(to).parent = node;
-                heap.DecreaseKey(to, to_weight);
+                toHeapNode->data.parent = heapNode.node;
+                toHeapNode->weight = to_weight;
+                heap.DecreaseKey(*toHeapNode);
             }
         }
     }
@@ -122,35 +123,35 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  const bool force_loop_forward,
                  const bool force_loop_reverse)
 {
-    const NodeID node = forward_heap.DeleteMin();
-    const EdgeWeight weight = forward_heap.GetKey(node);
+    auto heapNode = forward_heap.DeleteMinGetHeapNode();
+    const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
 
-    if (reverse_heap.WasInserted(node))
+    if (reverseHeapNode)
     {
-        const EdgeWeight new_weight = reverse_heap.GetKey(node) + weight;
+        const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
         if (new_weight < upper_bound)
         {
             // if loops are forced, they are so at the source
-            if ((force_loop_forward && forward_heap.GetData(node).parent == node) ||
-                (force_loop_reverse && reverse_heap.GetData(node).parent == node) ||
+            if ((force_loop_forward && heapNode.data.parent == heapNode.node) ||
+                (force_loop_reverse && reverseHeapNode->data.parent == heapNode.node) ||
                 // in this case we are looking at a bi-directional way where the source
                 // and target phantom are on the same edge based node
                 new_weight < 0)
             {
                 // check whether there is a loop present at the node
-                for (const auto edge : facade.GetAdjacentEdgeRange(node))
+                for (const auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
                 {
                     const auto &data = facade.GetEdgeData(edge);
                     if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
                     {
                         const NodeID to = facade.GetTarget(edge);
-                        if (to == node)
+                        if (to == heapNode.node)
                         {
                             const EdgeWeight edge_weight = data.weight;
                             const EdgeWeight loop_weight = new_weight + edge_weight;
                             if (loop_weight >= 0 && loop_weight < upper_bound)
                             {
-                                middle_node_id = node;
+                                middle_node_id = heapNode.node;
                                 upper_bound = loop_weight;
                             }
                         }
@@ -161,7 +162,7 @@ void routingStep(const DataFacade<Algorithm> &facade,
             {
                 BOOST_ASSERT(new_weight >= 0);
 
-                middle_node_id = node;
+                middle_node_id = heapNode.node;
                 upper_bound = new_weight;
             }
         }
@@ -170,19 +171,19 @@ void routingStep(const DataFacade<Algorithm> &facade,
     // make sure we don't terminate too early if we initialize the weight
     // for the nodes in the forward heap with the forward/reverse offset
     BOOST_ASSERT(min_edge_offset <= 0);
-    if (weight + min_edge_offset > upper_bound)
+    if (heapNode.weight + min_edge_offset > upper_bound)
     {
         forward_heap.DeleteAll();
         return;
     }
 
     // Stalling
-    if (STALLING && stallAtNode<DIRECTION>(facade, node, weight, forward_heap))
+    if (STALLING && stallAtNode<DIRECTION>(facade, heapNode, forward_heap))
     {
         return;
     }
 
-    relaxOutgoingEdges<DIRECTION>(facade, node, weight, forward_heap);
+    relaxOutgoingEdges<DIRECTION>(facade, heapNode, forward_heap);
 }
 
 template <bool UseDuration>
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
index c3462039c..55f366574 100644
--- a/include/engine/routing_algorithms/routing_base_mld.hpp
+++ b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -97,7 +97,6 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
                                  const std::vector<std::size_t> &phantom_indices)
 {
     auto min_level = [&partition, node](const PhantomNode &phantom_node) {
-
         const auto &forward_segment = phantom_node.forward_segment_id;
         const auto forward_level =
             forward_segment.enabled ? partition.GetHighestDifferentLevel(node, forward_segment.id)
@@ -120,7 +119,7 @@ inline LevelID getNodeQueryLevel(const MultiLevelPartition &partition,
     }
     return result;
 }
-}
+} // namespace
 
 // Heaps only record for each node its predecessor ("parent") on the shortest path.
 // For re-constructing the actual path we need to trace back all parent "pointers".
@@ -229,40 +228,42 @@ retrievePackedPathFromHeap(const SearchEngineData<Algorithm>::QueryHeap &forward
 template <bool DIRECTION, typename Algorithm, typename... Args>
 void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                         typename SearchEngineData<Algorithm>::QueryHeap &forward_heap,
-                        const NodeID node,
-                        const EdgeWeight weight,
+                        const typename SearchEngineData<Algorithm>::QueryHeap::HeapNode &heapNode,
                         Args... args)
 {
     const auto &partition = facade.GetMultiLevelPartition();
     const auto &cells = facade.GetCellStorage();
     const auto &metric = facade.GetCellMetric();
 
-    const auto level = getNodeQueryLevel(partition, node, args...);
+    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
 
-    if (level >= 1 && !forward_heap.GetData(node).from_clique_arc)
+    if (level >= 1 && !heapNode.data.from_clique_arc)
     {
         if (DIRECTION == FORWARD_DIRECTION)
         {
             // Shortcuts in forward direction
-            const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, node));
+            const auto &cell =
+                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto destination = cell.GetDestinationNodes().begin();
-            for (auto shortcut_weight : cell.GetOutWeight(node))
+            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
                 const NodeID to = *destination;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
-                    if (!forward_heap.WasInserted(to))
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        forward_heap.Insert(to, to_weight, {node, true});
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                     }
-                    else if (to_weight < forward_heap.GetKey(to))
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        forward_heap.GetData(to) = {node, true};
-                        forward_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->data = {heapNode.node, true};
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++destination;
@@ -271,25 +272,28 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
         else
         {
             // Shortcuts in backward direction
-            const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, node));
+            const auto &cell =
+                cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto source = cell.GetSourceNodes().begin();
-            for (auto shortcut_weight : cell.GetInWeight(node))
+            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
                 const NodeID to = *source;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const EdgeWeight to_weight = weight + shortcut_weight;
-                    BOOST_ASSERT(to_weight >= weight);
-                    if (!forward_heap.WasInserted(to))
+                    const EdgeWeight to_weight = heapNode.weight + shortcut_weight;
+                    BOOST_ASSERT(to_weight >= heapNode.weight);
+                    const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        forward_heap.Insert(to, to_weight, {node, true});
+                        forward_heap.Insert(to, to_weight, {heapNode.node, true});
                     }
-                    else if (to_weight < forward_heap.GetKey(to))
+                    else if (to_weight < toHeapNode->weight)
                     {
-                        forward_heap.GetData(to) = {node, true};
-                        forward_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->data = {heapNode.node, true};
+                        toHeapNode->weight = to_weight;
+                        forward_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++source;
@@ -298,7 +302,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
     }
 
     // Boundary edges
-    for (const auto edge : facade.GetBorderEdgeRange(level, node))
+    for (const auto edge : facade.GetBorderEdgeRange(level, heapNode.node))
     {
         const auto &edge_data = facade.GetEdgeData(edge);
 
@@ -311,21 +315,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                 checkParentCellRestriction(partition.GetCell(level + 1, to), args...))
             {
                 const auto node_weight =
-                    facade.GetNodeWeight(DIRECTION == FORWARD_DIRECTION ? node : to);
+                    facade.GetNodeWeight(DIRECTION == FORWARD_DIRECTION ? heapNode.node : to);
                 const auto turn_penalty = facade.GetWeightPenaltyForEdgeID(edge_data.turn_id);
 
                 // TODO: BOOST_ASSERT(edge_data.weight == node_weight + turn_penalty);
 
-                const EdgeWeight to_weight = weight + node_weight + turn_penalty;
+                const EdgeWeight to_weight = heapNode.weight + node_weight + turn_penalty;
 
-                if (!forward_heap.WasInserted(to))
+                const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
+                if (!toHeapNode)
                 {
-                    forward_heap.Insert(to, to_weight, {node, false});
+                    forward_heap.Insert(to, to_weight, {heapNode.node, false});
                 }
-                else if (to_weight < forward_heap.GetKey(to))
+                else if (to_weight < toHeapNode->weight)
                 {
-                    forward_heap.GetData(to) = {node, false};
-                    forward_heap.DecreaseKey(to, to_weight);
+                    toHeapNode->data = {heapNode.node, false};
+                    toHeapNode->weight = to_weight;
+                    forward_heap.DecreaseKey(*toHeapNode);
                 }
             }
         }
@@ -342,34 +348,35 @@ void routingStep(const DataFacade<Algorithm> &facade,
                  const bool force_loop_reverse,
                  Args... args)
 {
-    const auto node = forward_heap.DeleteMin();
-    const auto weight = forward_heap.GetKey(node);
+    const auto heapNode = forward_heap.DeleteMinGetHeapNode();
+    const auto weight = heapNode.weight;
 
-    BOOST_ASSERT(!facade.ExcludeNode(node));
+    BOOST_ASSERT(!facade.ExcludeNode(heapNode.node));
 
     // Upper bound for the path source -> target with
     // weight(source -> node) = weight weight(to -> target) ≤ reverse_weight
     // is weight + reverse_weight
     // More tighter upper bound requires additional condition reverse_heap.WasRemoved(to)
     // with weight(to -> target) = reverse_weight and all weights ≥ 0
-    if (reverse_heap.WasInserted(node))
+    const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
+    if (reverseHeapNode)
     {
-        auto reverse_weight = reverse_heap.GetKey(node);
+        auto reverse_weight = reverseHeapNode->weight;
         auto path_weight = weight + reverse_weight;
 
         // MLD uses loops forcing only to prune single node paths in forward and/or
         // backward direction (there is no need to force loops in MLD but in CH)
-        if (!(force_loop_forward && forward_heap.GetData(node).parent == node) &&
-            !(force_loop_reverse && reverse_heap.GetData(node).parent == node) &&
+        if (!(force_loop_forward && heapNode.data.parent == heapNode.node) &&
+            !(force_loop_reverse && reverseHeapNode->data.parent == heapNode.node) &&
             (path_weight >= 0) && (path_weight < path_upper_bound))
         {
-            middle_node = node;
+            middle_node = heapNode.node;
             path_upper_bound = path_weight;
         }
     }
 
     // Relax outgoing edges from node
-    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, node, weight, args...);
+    relaxOutgoingEdges<DIRECTION>(facade, forward_heap, heapNode, args...);
 }
 
 // With (s, middle, t) we trace back the paths middle -> s and middle -> t.
diff --git a/include/engine/routing_algorithms/shortest_path_impl.hpp b/include/engine/routing_algorithms/shortest_path_impl.hpp
index 0dea19897..304f5ee5e 100644
--- a/include/engine/routing_algorithms/shortest_path_impl.hpp
+++ b/include/engine/routing_algorithms/shortest_path_impl.hpp
@@ -226,7 +226,7 @@ inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &eng
     const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number, border_nodes_number);
 }
-}
+} // namespace
 
 template <typename Algorithm>
 InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_working_data,
@@ -304,6 +304,7 @@ InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_worki
                 {
                     BOOST_ASSERT(target_phantom.IsValidReverseTarget());
                     new_total_weight_to_reverse = new_total_weight_to_forward;
+                    // NOLINTNEXTLINE(bugprone-use-after-move)
                     packed_leg_to_reverse = std::move(packed_leg_to_forward);
                     new_total_weight_to_forward = INVALID_EDGE_WEIGHT;
 
@@ -354,6 +355,7 @@ InternalRouteResult shortestPathSearch(SearchEngineData<Algorithm> &engine_worki
         {
             bool forward_to_forward =
                 (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
+                // NOLINTNEXTLINE(bugprone-use-after-move)
                 packed_leg_to_forward.front() == source_phantom.forward_segment_id.id;
             bool reverse_to_forward =
                 (new_total_weight_to_forward != INVALID_EDGE_WEIGHT) &&
diff --git a/include/engine/search_engine_data.hpp b/include/engine/search_engine_data.hpp
index 353076162..4dafdd1a2 100644
--- a/include/engine/search_engine_data.hpp
+++ b/include/engine/search_engine_data.hpp
@@ -120,7 +120,7 @@ template <> struct SearchEngineData<routing_algorithms::mld::Algorithm>
     void InitializeOrClearManyToManyThreadLocalStorage(unsigned number_of_nodes,
                                                        unsigned number_of_boundary_nodes);
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif // SEARCH_ENGINE_DATA_HPP
diff --git a/include/engine/status.hpp b/include/engine/status.hpp
index c2c31cdfb..7b08db1d6 100644
--- a/include/engine/status.hpp
+++ b/include/engine/status.hpp
@@ -42,7 +42,7 @@ enum class Status
     Ok,
     Error
 };
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/engine/trip/trip_farthest_insertion.hpp b/include/engine/trip/trip_farthest_insertion.hpp
index e4f459b77..74ed56e8c 100644
--- a/include/engine/trip/trip_farthest_insertion.hpp
+++ b/include/engine/trip/trip_farthest_insertion.hpp
@@ -48,13 +48,14 @@ GetShortestRoundTrip(const NodeID new_loc,
 
         const auto dist_from = dist_table(*from_node, new_loc);
         const auto dist_to = dist_table(new_loc, *to_node);
-        const auto trip_dist = dist_from + dist_to - dist_table(*from_node, *to_node);
-
         // If the edge_weight is very large (INVALID_EDGE_WEIGHT) then the algorithm will not choose
         // this edge in final minimal path. So instead of computing all the permutations after this
         // large edge, discard this edge right here and don't consider the path after this edge.
         if (dist_from == INVALID_EDGE_WEIGHT || dist_to == INVALID_EDGE_WEIGHT)
             continue;
+
+        const auto trip_dist = dist_from + dist_to - dist_table(*from_node, *to_node);
+
         // This is not neccessarily true:
         // Lets say you have an edge (u, v) with duration 100. If you place a coordinate exactly in
         // the middle of the segment yielding (u, v'), the adjusted duration will be 100 * 0.5 = 50.
diff --git a/include/engine/trip/trip_nearest_neighbour.hpp b/include/engine/trip/trip_nearest_neighbour.hpp
index 6243c8711..29aca8e72 100644
--- a/include/engine/trip/trip_nearest_neighbour.hpp
+++ b/include/engine/trip/trip_nearest_neighbour.hpp
@@ -92,8 +92,8 @@ std::vector<NodeID> NearestNeighbourTrip(const NodeIDIterator &start,
     }
     return route;
 }
-}
-}
-}
+} // namespace trip
+} // namespace engine
+} // namespace osrm
 
 #endif // TRIP_NEAREST_NEIGHBOUR_HPP
diff --git a/include/extractor/class_data.hpp b/include/extractor/class_data.hpp
index 11b07ffcd..5e5cf3087 100644
--- a/include/extractor/class_data.hpp
+++ b/include/extractor/class_data.hpp
@@ -33,7 +33,7 @@ inline bool isValidClassName(const std::string &name)
                return std::isalnum(c);
            }) == name.end();
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/compressed_edge_container.hpp b/include/extractor/compressed_edge_container.hpp
index 5b570e724..ec9e1f9ea 100644
--- a/include/extractor/compressed_edge_container.hpp
+++ b/include/extractor/compressed_edge_container.hpp
@@ -82,7 +82,7 @@ class CompressedEdgeContainer
     std::unordered_map<EdgeID, unsigned> m_reverse_edge_id_to_zipped_index_map;
     std::unique_ptr<SegmentDataContainer> segment_data;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // GEOMETRY_COMPRESSOR_HPP_
diff --git a/include/extractor/compressed_node_based_graph_edge.hpp b/include/extractor/compressed_node_based_graph_edge.hpp
index 06c01d538..279be7c1c 100644
--- a/include/extractor/compressed_node_based_graph_edge.hpp
+++ b/include/extractor/compressed_node_based_graph_edge.hpp
@@ -14,7 +14,7 @@ struct CompressedNodeBasedGraphEdge
     NodeID source;
     NodeID target;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // OSRM_EXTRACTOR_COMPRESSED_NODE_BASED_GRAPH_EDGE_HPP
diff --git a/include/extractor/datasources.hpp b/include/extractor/datasources.hpp
index 03af4deea..a4f872656 100644
--- a/include/extractor/datasources.hpp
+++ b/include/extractor/datasources.hpp
@@ -42,7 +42,7 @@ class Datasources
     std::array<std::uint32_t, MAX_NUM_SOURES> lengths;
     std::array<char, MAX_LENGTH_NAME * MAX_NUM_SOURES> sources;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/edge_based_edge.hpp b/include/extractor/edge_based_edge.hpp
index 28ebf934a..6c9aaa974 100644
--- a/include/extractor/edge_based_edge.hpp
+++ b/include/extractor/edge_based_edge.hpp
@@ -96,7 +96,7 @@ inline bool EdgeBasedEdge::operator<(const EdgeBasedEdge &other) const
     return std::tie(source, target, data.weight, unidirectional) <
            std::tie(other.source, other.target, other.data.weight, other_is_unidirectional);
 }
-} // ns extractor
-} // ns osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* EDGE_BASED_EDGE_HPP */
diff --git a/include/extractor/edge_based_graph_factory.hpp b/include/extractor/edge_based_graph_factory.hpp
index b99ec2c2c..01a3122ea 100644
--- a/include/extractor/edge_based_graph_factory.hpp
+++ b/include/extractor/edge_based_graph_factory.hpp
@@ -12,8 +12,8 @@
 #include "extractor/name_table.hpp"
 #include "extractor/nbg_to_ebg.hpp"
 #include "extractor/node_data_container.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/query_node.hpp"
-#include "extractor/restriction_index.hpp"
 #include "extractor/turn_lane_types.hpp"
 #include "extractor/way_restriction_map.hpp"
 
@@ -54,7 +54,7 @@ struct TurnIndexBlock
 #pragma pack(pop)
 static_assert(std::is_trivial<TurnIndexBlock>::value, "TurnIndexBlock is not trivial");
 static_assert(sizeof(TurnIndexBlock) == 12, "TurnIndexBlock is not packed correctly");
-} // ns lookup
+} // namespace lookup
 
 struct NodeBasedGraphToEdgeBasedGraphMappingWriter; // fwd. decl
 
diff --git a/include/extractor/edge_based_node_segment.hpp b/include/extractor/edge_based_node_segment.hpp
index b85131e02..ff2198803 100644
--- a/include/extractor/edge_based_node_segment.hpp
+++ b/include/extractor/edge_based_node_segment.hpp
@@ -20,8 +20,9 @@ namespace extractor
 struct EdgeBasedNodeSegment
 {
     EdgeBasedNodeSegment()
-        : forward_segment_id{SPECIAL_SEGMENTID, false},
-          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
+        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
+                                                                           false},
+          u(SPECIAL_NODEID), v(SPECIAL_NODEID),
           fwd_segment_position(std::numeric_limits<unsigned short>::max() >>
                                1), // >> 1 because we've only got 15 bits
           is_startpoint(false)
@@ -47,7 +48,7 @@ struct EdgeBasedNodeSegment
     unsigned short fwd_segment_position : 15; // segment id in a compressed geometry
     bool is_startpoint : 1;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // OSRM_EXTRACT_EDGE_BASED_NODE_SEGMENT_HPP
diff --git a/include/extractor/extraction_containers.hpp b/include/extractor/extraction_containers.hpp
index 184db7739..a8b8f7767 100644
--- a/include/extractor/extraction_containers.hpp
+++ b/include/extractor/extraction_containers.hpp
@@ -1,14 +1,16 @@
 #ifndef EXTRACTION_CONTAINERS_HPP
 #define EXTRACTION_CONTAINERS_HPP
 
-#include "extractor/first_and_last_segment_of_way.hpp"
 #include "extractor/internal_extractor_edge.hpp"
+#include "extractor/nodes_of_way.hpp"
 #include "extractor/query_node.hpp"
 #include "extractor/restriction.hpp"
 #include "extractor/scripting_environment.hpp"
 
 #include "storage/tar_fwd.hpp"
 
+#include <unordered_map>
+
 namespace osrm
 {
 namespace extractor
@@ -22,9 +24,16 @@ namespace extractor
  */
 class ExtractionContainers
 {
+    using ReferencedWays = std::unordered_map<OSMWayID, NodesOfWay>;
+    // The relationship between way and nodes is lost during node preparation.
+    // We identify the ways and nodes relevant to restrictions/overrides prior to
+    // node processing so that they can be referenced in the preparation phase.
+    ReferencedWays IdentifyRestrictionWays();
+    ReferencedWays IdentifyManeuverOverrideWays();
+
     void PrepareNodes();
-    void PrepareManeuverOverrides();
-    void PrepareRestrictions();
+    void PrepareManeuverOverrides(const ReferencedWays &maneuver_override_ways);
+    void PrepareRestrictions(const ReferencedWays &restriction_ways);
     void PrepareEdges(ScriptingEnvironment &scripting_environment);
 
     void WriteNodes(storage::tar::FileWriter &file_out) const;
@@ -37,9 +46,10 @@ class ExtractionContainers
     using NodeVector = std::vector<QueryNode>;
     using EdgeVector = std::vector<InternalExtractorEdge>;
     using AnnotationDataVector = std::vector<NodeBasedEdgeAnnotation>;
-    using WayIDStartEndVector = std::vector<FirstAndLastSegmentOfWay>;
     using NameCharData = std::vector<unsigned char>;
-    using NameOffsets = std::vector<unsigned>;
+    using NameOffsets = std::vector<size_t>;
+    using WayIDVector = std::vector<OSMWayID>;
+    using WayNodeIDOffsets = std::vector<size_t>;
 
     std::vector<OSMNodeID> barrier_nodes;
     std::vector<OSMNodeID> traffic_signals;
@@ -49,20 +59,18 @@ class ExtractionContainers
     AnnotationDataVector all_edges_annotation_data_list;
     NameCharData name_char_data;
     NameOffsets name_offsets;
-    // an adjacency array containing all turn lane masks
-    WayIDStartEndVector way_start_end_id_list;
+    WayIDVector ways_list;
+    // Offsets into used nodes for each way_list entry
+    WayNodeIDOffsets way_node_id_offsets;
 
     unsigned max_internal_node_id;
 
-    // list of restrictions before we transform them into the output types. Input containers
-    // reference OSMNodeIDs. We can only transform them to the correct internal IDs after we've read
-    // everything. Without a multi-parse approach, we have to remember the output restrictions
-    // before converting them to the internal formats
-    std::vector<InputConditionalTurnRestriction> restrictions_list;
-
-    // turn restrictions split into conditional and unconditional turn restrictions
-    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
-    std::vector<TurnRestriction> unconditional_turn_restrictions;
+    // List of restrictions (conditional and unconditional) before we transform them into the
+    // output types. Input containers reference OSMNodeIDs. We can only transform them to the
+    // correct internal IDs after we've read everything. Without a multi-parse approach,
+    // we have to remember the output restrictions before converting them to the internal formats
+    std::vector<InputTurnRestriction> restrictions_list;
+    std::vector<TurnRestriction> turn_restrictions;
 
     std::vector<InputManeuverOverride> external_maneuver_overrides_list;
     std::vector<UnresolvedManeuverOverride> internal_maneuver_overrides;
@@ -73,7 +81,7 @@ class ExtractionContainers
                      const std::string &osrm_path,
                      const std::string &names_data_path);
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* EXTRACTION_CONTAINERS_HPP */
diff --git a/include/extractor/extraction_helper_functions.hpp b/include/extractor/extraction_helper_functions.hpp
index af6ec86de..d9e0f9b44 100644
--- a/include/extractor/extraction_helper_functions.hpp
+++ b/include/extractor/extraction_helper_functions.hpp
@@ -82,7 +82,7 @@ template <typename Iterator> struct iso_8601_grammar : qi::grammar<Iterator, uns
     qi::uint_parser<unsigned, 10, 1, 2> uint_p;
     qi::uint_parser<unsigned, 10, 2, 2> uint2_p;
 };
-}
+} // namespace detail
 
 inline bool durationIsValid(const std::string &s)
 {
@@ -127,14 +127,16 @@ inline std::string canonicalizeStringList(std::string strlist, const std::string
 
     // collapse spaces; this is needed in case we expand "; X" => ";  X" above
     // but also makes sense to do irregardless of the fact - canonicalizing strings.
-    const auto spaces = [](auto lhs, auto rhs) { return ::isspace(lhs) && ::isspace(rhs); };
+    const auto spaces = [](unsigned char lhs, unsigned char rhs) {
+        return ::isspace(lhs) && ::isspace(rhs);
+    };
     auto it = std::unique(begin(strlist), end(strlist), spaces);
     strlist.erase(it, end(strlist));
 
     return strlist;
 }
 
-} // extractor
-} // osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif // EXTRACTION_HELPER_FUNCTIONS_HPP
diff --git a/include/extractor/extraction_node.hpp b/include/extractor/extraction_node.hpp
index e82f298ba..065ff4a3f 100644
--- a/include/extractor/extraction_node.hpp
+++ b/include/extractor/extraction_node.hpp
@@ -13,7 +13,7 @@ struct ExtractionNode
     bool traffic_lights;
     bool barrier;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // EXTRACTION_NODE_HPP
diff --git a/include/extractor/extraction_relation.hpp b/include/extractor/extraction_relation.hpp
index 033aea8a1..6c4203b75 100644
--- a/include/extractor/extraction_relation.hpp
+++ b/include/extractor/extraction_relation.hpp
@@ -93,6 +93,10 @@ class ExtractionRelationContainer
     using RelationIDList = std::vector<ExtractionRelation::OsmIDTyped>;
     using RelationRefMap = std::unordered_map<std::uint64_t, RelationIDList>;
 
+    ExtractionRelationContainer() = default;
+    ExtractionRelationContainer(ExtractionRelationContainer &&) = default;
+    ExtractionRelationContainer(const ExtractionRelationContainer &) = delete;
+
     void AddRelation(ExtractionRelation &&rel)
     {
         rel.Prepare();
diff --git a/include/extractor/extraction_segment.hpp b/include/extractor/extraction_segment.hpp
index 6e3f3b5d5..4330e5c99 100644
--- a/include/extractor/extraction_segment.hpp
+++ b/include/extractor/extraction_segment.hpp
@@ -26,7 +26,7 @@ struct ExtractionSegment
     double weight;
     double duration;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/extraction_turn.hpp b/include/extractor/extraction_turn.hpp
index 0480d7073..9e32712d3 100644
--- a/include/extractor/extraction_turn.hpp
+++ b/include/extractor/extraction_turn.hpp
@@ -33,16 +33,16 @@ struct ExtractionTurnLeg
     {
     }
 
-    const bool is_restricted;
-    const bool is_motorway;
-    const bool is_link;
-    const int number_of_lanes;
-    const int highway_turn_classification;
-    const int access_turn_classification;
-    const int speed;
-    const RoadPriorityClass::Enum priority_class;
-    const bool is_incoming;
-    const bool is_outgoing;
+    bool is_restricted;
+    bool is_motorway;
+    bool is_link;
+    int number_of_lanes;
+    int highway_turn_classification;
+    int access_turn_classification;
+    int speed;
+    RoadPriorityClass::Enum priority_class;
+    bool is_incoming;
+    bool is_outgoing;
 };
 
 struct ExtractionTurn
@@ -130,7 +130,7 @@ struct ExtractionTurn
     double weight;
     double duration;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/extraction_way.hpp b/include/extractor/extraction_way.hpp
index e5f8693ba..674555c81 100644
--- a/include/extractor/extraction_way.hpp
+++ b/include/extractor/extraction_way.hpp
@@ -26,7 +26,7 @@ inline void maybeSetString(std::string &str, const char *value)
         str = std::string(value);
     }
 }
-}
+} // namespace detail
 
 /**
  * This struct is the direct result of the call to ```way_function```
@@ -130,7 +130,7 @@ struct ExtractionWay
     std::uint8_t highway_turn_classification : 4;
     std::uint8_t access_turn_classification : 4;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // EXTRACTION_WAY_HPP
diff --git a/include/extractor/extractor.hpp b/include/extractor/extractor.hpp
index 29dec218b..070a3b4ef 100644
--- a/include/extractor/extractor.hpp
+++ b/include/extractor/extractor.hpp
@@ -42,6 +42,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "util/guidance/entry_class.hpp"
 #include "util/guidance/turn_lanes.hpp"
 
+#include "restriction_graph.hpp"
 #include "util/typedefs.hpp"
 
 namespace osrm
@@ -63,7 +64,6 @@ class Extractor
 
     std::tuple<LaneDescriptionMap,
                std::vector<TurnRestriction>,
-               std::vector<ConditionalTurnRestriction>,
                std::vector<UnresolvedManeuverOverride>>
     ParseOSMData(ScriptingEnvironment &scripting_environment, const unsigned number_of_threads);
 
@@ -74,8 +74,7 @@ class Extractor
         const CompressedEdgeContainer &compressed_edge_container,
         const std::unordered_set<NodeID> &barrier_nodes,
         const std::unordered_set<NodeID> &traffic_lights,
-        const std::vector<TurnRestriction> &turn_restrictions,
-        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
+        const RestrictionGraph &restriction_graph,
         const std::unordered_set<EdgeID> &segregated_edges,
         const NameTable &name_table,
         const std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
@@ -97,25 +96,18 @@ class Extractor
                         EdgeBasedNodeDataContainer &nodes_container) const;
     void BuildRTree(std::vector<EdgeBasedNodeSegment> edge_based_node_segments,
                     const std::vector<util::Coordinate> &coordinates);
-    std::shared_ptr<RestrictionMap> LoadRestrictionMap();
 
-    void WriteConditionalRestrictions(
-        const std::string &path,
-        std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions);
-
-    void ProcessGuidanceTurns(
-        const util::NodeBasedDynamicGraph &node_based_graph,
-        const EdgeBasedNodeDataContainer &edge_based_node_container,
-        const std::vector<util::Coordinate> &node_coordinates,
-        const CompressedEdgeContainer &compressed_edge_container,
-        const std::unordered_set<NodeID> &barrier_nodes,
-        const std::vector<TurnRestriction> &turn_restrictions,
-        const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
-        const NameTable &name_table,
-        LaneDescriptionMap lane_description_map,
-        ScriptingEnvironment &scripting_environment);
+    void ProcessGuidanceTurns(const util::NodeBasedDynamicGraph &node_based_graph,
+                              const EdgeBasedNodeDataContainer &edge_based_node_container,
+                              const std::vector<util::Coordinate> &node_coordinates,
+                              const CompressedEdgeContainer &compressed_edge_container,
+                              const std::unordered_set<NodeID> &barrier_nodes,
+                              const RestrictionGraph &restriction_graph,
+                              const NameTable &name_table,
+                              LaneDescriptionMap lane_description_map,
+                              ScriptingEnvironment &scripting_environment);
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* EXTRACTOR_HPP */
diff --git a/include/extractor/extractor_callbacks.hpp b/include/extractor/extractor_callbacks.hpp
index 865f1e2ad..9939a4963 100644
--- a/include/extractor/extractor_callbacks.hpp
+++ b/include/extractor/extractor_callbacks.hpp
@@ -16,15 +16,15 @@ namespace osmium
 class Node;
 class Way;
 class Relation;
-}
+} // namespace osmium
 
 namespace std
 {
 template <> struct hash<std::tuple<std::string, std::string, std::string, std::string, std::string>>
 {
     std::size_t operator()(
-        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk) const
-        noexcept
+        const std::tuple<std::string, std::string, std::string, std::string, std::string> &mk)
+        const noexcept
     {
         std::size_t seed = 0;
         boost::hash_combine(seed, std::get<0>(mk));
@@ -35,7 +35,7 @@ template <> struct hash<std::tuple<std::string, std::string, std::string, std::s
         return seed;
     }
 };
-}
+} // namespace std
 
 namespace osrm
 {
@@ -47,7 +47,7 @@ struct ExtractionNode;
 struct ExtractionWay;
 struct ExtractionRelation;
 struct ProfileProperties;
-struct InputConditionalTurnRestriction;
+struct InputTurnRestriction;
 struct InputManeuverOverride;
 
 /**
@@ -87,15 +87,15 @@ class ExtractorCallbacks
     void ProcessNode(const osmium::Node &current_node, const ExtractionNode &result_node);
 
     // warning: caller needs to take care of synchronization!
-    void ProcessRestriction(const InputConditionalTurnRestriction &restriction);
+    void ProcessRestriction(const InputTurnRestriction &restriction);
 
     // warning: caller needs to take care of synchronization!
     void ProcessWay(const osmium::Way &current_way, const ExtractionWay &result_way);
 
     // warning: caller needs to take care of synchronization!
-    void ProcessManeuverOverride(const InputManeuverOverride & override);
+    void ProcessManeuverOverride(const InputManeuverOverride &override);
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* EXTRACTOR_CALLBACKS_HPP */
diff --git a/include/extractor/extractor_config.hpp b/include/extractor/extractor_config.hpp
index 1ca72a7dd..848d97add 100644
--- a/include/extractor/extractor_config.hpp
+++ b/include/extractor/extractor_config.hpp
@@ -42,36 +42,34 @@ namespace extractor
 
 struct ExtractorConfig final : storage::IOConfig
 {
-    ExtractorConfig() noexcept : IOConfig(
-                                     {
-                                         "",
-                                     },
-                                     {},
-                                     {".osrm",
-                                      ".osrm.restrictions",
-                                      ".osrm.names",
-                                      ".osrm.tls",
-                                      ".osrm.tld",
-                                      ".osrm.geometry",
-                                      ".osrm.nbg_nodes",
-                                      ".osrm.ebg_nodes",
-                                      ".osrm.timestamp",
-                                      ".osrm.edges",
-                                      ".osrm.ebg",
-                                      ".osrm.ramIndex",
-                                      ".osrm.fileIndex",
-                                      ".osrm.turn_duration_penalties",
-                                      ".osrm.turn_weight_penalties",
-                                      ".osrm.turn_penalties_index",
-                                      ".osrm.enw",
-                                      ".osrm.properties",
-                                      ".osrm.icd",
-                                      ".osrm.cnbg",
-                                      ".osrm.cnbg_to_ebg",
-                                      ".osrm.maneuver_overrides"}),
-                                 requested_num_threads(0),
-                                 parse_conditionals(false),
-                                 use_locations_cache(true)
+    ExtractorConfig() noexcept
+        : IOConfig(
+              {
+                  "",
+              },
+              {},
+              {".osrm",
+               ".osrm.restrictions",
+               ".osrm.names",
+               ".osrm.tls",
+               ".osrm.tld",
+               ".osrm.geometry",
+               ".osrm.nbg_nodes",
+               ".osrm.ebg_nodes",
+               ".osrm.timestamp",
+               ".osrm.edges",
+               ".osrm.ebg",
+               ".osrm.ramIndex",
+               ".osrm.fileIndex",
+               ".osrm.turn_duration_penalties",
+               ".osrm.turn_weight_penalties",
+               ".osrm.turn_penalties_index",
+               ".osrm.enw",
+               ".osrm.properties",
+               ".osrm.icd",
+               ".osrm.cnbg",
+               ".osrm.cnbg_to_ebg",
+               ".osrm.maneuver_overrides"})
     {
     }
 
@@ -85,16 +83,14 @@ struct ExtractorConfig final : storage::IOConfig
     std::vector<boost::filesystem::path> location_dependent_data_paths;
     std::string data_version;
 
-    unsigned requested_num_threads;
-    unsigned small_component_size;
+    unsigned requested_num_threads = 0;
+    unsigned small_component_size = 1000;
 
-    bool generate_edge_lookup;
-
-    bool use_metadata;
-    bool parse_conditionals;
-    bool use_locations_cache;
+    bool use_metadata = false;
+    bool parse_conditionals = false;
+    bool use_locations_cache = true;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // EXTRACTOR_CONFIG_HPP
diff --git a/include/extractor/files.hpp b/include/extractor/files.hpp
index 493c54765..6c0445e9b 100644
--- a/include/extractor/files.hpp
+++ b/include/extractor/files.hpp
@@ -399,6 +399,28 @@ inline void readTurnDurationPenalty(const boost::filesystem::path &path, TurnPen
     storage::serialization::read(reader, "/common/turn_penalty/duration", turn_penalty);
 }
 
+// writes .osrm.turn_penalties_index
+template <typename TurnIndexT>
+inline void writeTurnPenaltiesIndex(const boost::filesystem::path &path,
+                                    const TurnIndexT &turn_penalties_index)
+{
+    const auto fingerprint = storage::tar::FileWriter::GenerateFingerprint;
+    storage::tar::FileWriter writer{path, fingerprint};
+
+    storage::serialization::write(writer, "/extractor/turn_index", turn_penalties_index);
+}
+
+// read .osrm.turn_penalties_index
+template <typename TurnIndexT>
+inline void readTurnPenaltiesIndex(const boost::filesystem::path &path,
+                                   TurnIndexT &turn_penalties_index)
+{
+    const auto fingerprint = storage::tar::FileReader::VerifyFingerprint;
+    storage::tar::FileReader reader{path, fingerprint};
+
+    storage::serialization::read(reader, "/extractor/turn_index", turn_penalties_index);
+}
+
 // writes .osrm.restrictions
 template <typename ConditionalRestrictionsT>
 inline void writeConditionalRestrictions(const boost::filesystem::path &path,
@@ -564,8 +586,8 @@ void readCompressedNodeBasedGraph(const boost::filesystem::path &path, EdgeListT
 
     storage::serialization::read(reader, "/extractor/cnbg", edge_list);
 }
-}
-}
-}
+} // namespace files
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/first_and_last_segment_of_way.hpp b/include/extractor/first_and_last_segment_of_way.hpp
deleted file mode 100644
index 5759e97ad..000000000
--- a/include/extractor/first_and_last_segment_of_way.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#ifndef FIRST_AND_LAST_SEGMENT_OF_WAY_HPP
-#define FIRST_AND_LAST_SEGMENT_OF_WAY_HPP
-
-#include "util/typedefs.hpp"
-
-#include <limits>
-#include <string>
-
-namespace osrm
-{
-namespace extractor
-{
-
-struct FirstAndLastSegmentOfWay
-{
-    OSMWayID way_id;
-    OSMNodeID first_segment_source_id;
-    OSMNodeID first_segment_target_id;
-    OSMNodeID last_segment_source_id;
-    OSMNodeID last_segment_target_id;
-
-    FirstAndLastSegmentOfWay()
-        : way_id(SPECIAL_OSM_WAYID), first_segment_source_id(SPECIAL_OSM_NODEID),
-          first_segment_target_id(SPECIAL_OSM_NODEID), last_segment_source_id(SPECIAL_OSM_NODEID),
-          last_segment_target_id(SPECIAL_OSM_NODEID)
-    {
-    }
-
-    FirstAndLastSegmentOfWay(OSMWayID w, OSMNodeID fs, OSMNodeID ft, OSMNodeID ls, OSMNodeID lt)
-        : way_id(std::move(w)), first_segment_source_id(std::move(fs)),
-          first_segment_target_id(std::move(ft)), last_segment_source_id(std::move(ls)),
-          last_segment_target_id(std::move(lt))
-    {
-    }
-
-    static FirstAndLastSegmentOfWay min_value()
-    {
-        return {MIN_OSM_WAYID, MIN_OSM_NODEID, MIN_OSM_NODEID, MIN_OSM_NODEID, MIN_OSM_NODEID};
-    }
-    static FirstAndLastSegmentOfWay max_value()
-    {
-        return {MAX_OSM_WAYID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID};
-    }
-};
-
-struct FirstAndLastSegmentOfWayCompare
-{
-    using value_type = FirstAndLastSegmentOfWay;
-    bool operator()(const FirstAndLastSegmentOfWay &a, const FirstAndLastSegmentOfWay &b) const
-    {
-        return a.way_id < b.way_id;
-    }
-    value_type max_value() { return FirstAndLastSegmentOfWay::max_value(); }
-    value_type min_value() { return FirstAndLastSegmentOfWay::min_value(); }
-};
-}
-}
-
-#endif /* FIRST_AND_LAST_SEGMENT_OF_WAY_HPP */
diff --git a/include/extractor/geojson_debug_policies.hpp b/include/extractor/geojson_debug_policies.hpp
index a0ccaf4a0..f02577dc1 100644
--- a/include/extractor/geojson_debug_policies.hpp
+++ b/include/extractor/geojson_debug_policies.hpp
@@ -53,11 +53,11 @@ IntersectionPrinter<IntersectionType>::IntersectionPrinter(
 }
 
 template <typename IntersectionType>
-util::json::Array IntersectionPrinter<IntersectionType>::
-operator()(const NodeID intersection_node,
-           const IntersectionType &intersection,
-           const boost::optional<util::json::Object> &node_style,
-           const boost::optional<util::json::Object> &way_style) const
+util::json::Array IntersectionPrinter<IntersectionType>::operator()(
+    const NodeID intersection_node,
+    const IntersectionType &intersection,
+    const boost::optional<util::json::Object> &node_style,
+    const boost::optional<util::json::Object> &way_style) const
 {
     // request the number of lanes. This process needs to be in sync with what happens over at
     // intersection analysis
diff --git a/include/extractor/graph_compressor.hpp b/include/extractor/graph_compressor.hpp
index 99d4cf85b..9a976e327 100644
--- a/include/extractor/graph_compressor.hpp
+++ b/include/extractor/graph_compressor.hpp
@@ -28,7 +28,6 @@ class GraphCompressor
                   const std::unordered_set<NodeID> &traffic_lights,
                   ScriptingEnvironment &scripting_environment,
                   std::vector<TurnRestriction> &turn_restrictions,
-                  std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                   std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
                   util::NodeBasedDynamicGraph &graph,
                   const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
@@ -39,7 +38,7 @@ class GraphCompressor
                          unsigned original_number_of_edges,
                          const util::NodeBasedDynamicGraph &graph) const;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/internal_extractor_edge.hpp b/include/extractor/internal_extractor_edge.hpp
index 5b2007fa7..c7ee904d9 100644
--- a/include/extractor/internal_extractor_edge.hpp
+++ b/include/extractor/internal_extractor_edge.hpp
@@ -49,7 +49,7 @@ struct ByEdgeOrByMeterValue
     using value_type = float;
     value_type value;
 };
-}
+} // namespace detail
 
 struct InternalExtractorEdge
 {
@@ -86,7 +86,7 @@ struct InternalExtractorEdge
     // coordinate of the source node
     util::Coordinate source_coordinate;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // INTERNAL_EXTRACTOR_EDGE_HPP
diff --git a/include/extractor/intersection/intersection_analysis.hpp b/include/extractor/intersection/intersection_analysis.hpp
index e5ed8ede3..aa4a1e939 100644
--- a/include/extractor/intersection/intersection_analysis.hpp
+++ b/include/extractor/intersection/intersection_analysis.hpp
@@ -5,7 +5,7 @@
 #include "extractor/intersection/intersection_edge.hpp"
 #include "extractor/intersection/intersection_view.hpp"
 #include "extractor/intersection/mergable_road_detector.hpp"
-#include "extractor/restriction_index.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/turn_lane_types.hpp"
 
 #include "util/coordinate.hpp"
@@ -70,6 +70,16 @@ IntersectionView getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
                                    const TurnLanesIndexedArray &turn_lanes_data,
                                    const IntersectionEdge &incoming_edge);
 
+IntersectionView
+getConnectedRoadsForEdgeGeometries(const util::NodeBasedDynamicGraph &graph,
+                                   const EdgeBasedNodeDataContainer &node_data_container,
+                                   const RestrictionMap &node_restriction_map,
+                                   const std::unordered_set<NodeID> &barrier_nodes,
+                                   const TurnLanesIndexedArray &turn_lanes_data,
+                                   const IntersectionEdge &incoming_edge,
+                                   const IntersectionEdgeGeometries &edge_geometries,
+                                   const std::unordered_set<EdgeID> &merged_edge_ids);
+
 // Graph Compression cannot compress every setting. For example any barrier/traffic light cannot
 // be compressed. As a result, a simple road of the form `a ----- b` might end up as having an
 // intermediate intersection, if there is a traffic light in between. If we want to look farther
@@ -79,8 +89,8 @@ IntersectionView getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
 // for getConnectedRoads.
 IntersectionEdge skipDegreeTwoNodes(const util::NodeBasedDynamicGraph &graph,
                                     IntersectionEdge road);
-}
-}
-}
+} // namespace intersection
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/intersection/intersection_edge.hpp b/include/extractor/intersection/intersection_edge.hpp
index 954184abe..fcf5bc5d4 100644
--- a/include/extractor/intersection/intersection_edge.hpp
+++ b/include/extractor/intersection/intersection_edge.hpp
@@ -42,8 +42,8 @@ struct IntersectionEdgeGeometry
 };
 
 using IntersectionEdgeGeometries = std::vector<IntersectionEdgeGeometry>;
-}
-}
-}
+} // namespace intersection
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/intersection/mergable_road_detector.hpp b/include/extractor/intersection/mergable_road_detector.hpp
index 5f5ae5359..4871ad829 100644
--- a/include/extractor/intersection/mergable_road_detector.hpp
+++ b/include/extractor/intersection/mergable_road_detector.hpp
@@ -5,7 +5,7 @@
 #include "extractor/intersection/coordinate_extractor.hpp"
 #include "extractor/intersection/have_identical_names.hpp"
 #include "extractor/name_table.hpp"
-#include "extractor/restriction_index.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/turn_lane_types.hpp"
 
 #include "guidance/intersection.hpp"
diff --git a/include/extractor/intersection/node_based_graph_walker.hpp b/include/extractor/intersection/node_based_graph_walker.hpp
index 64f6a0b80..d076e5e43 100644
--- a/include/extractor/intersection/node_based_graph_walker.hpp
+++ b/include/extractor/intersection/node_based_graph_walker.hpp
@@ -301,7 +301,7 @@ struct DistanceToNextIntersectionAccumulator
         using namespace util::coordinate_calculation;
 
         const auto coords = extractor.GetForwardCoordinatesAlongRoad(start, onto);
-        distance += getLength(coords.begin(), coords.end(), &haversineDistance);
+        distance += getLength(coords.begin(), coords.end(), &greatCircleDistance);
     }
 
     const extractor::intersection::CoordinateExtractor &extractor;
diff --git a/include/extractor/intersection_bearings_container.hpp b/include/extractor/intersection_bearings_container.hpp
index 879d38a98..7c6d025d2 100644
--- a/include/extractor/intersection_bearings_container.hpp
+++ b/include/extractor/intersection_bearings_container.hpp
@@ -17,7 +17,7 @@ namespace extractor
 namespace detail
 {
 template <storage::Ownership Ownership> class IntersectionBearingsContainer;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -30,7 +30,7 @@ template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const detail::IntersectionBearingsContainer<Ownership> &turn_data);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -46,42 +46,44 @@ template <storage::Ownership Ownership> class IntersectionBearingsContainer
     IntersectionBearingsContainer &operator=(IntersectionBearingsContainer &&) = default;
     IntersectionBearingsContainer &operator=(const IntersectionBearingsContainer &) = default;
 
-    IntersectionBearingsContainer(std::vector<BearingClassID> node_to_class_id_,
+    // NOLINTNEXTLINE(performance-unnecessary-value-param)
+    IntersectionBearingsContainer(std::vector<BearingClassID> node_to_class_id,
                                   const std::vector<util::guidance::BearingClass> &bearing_classes)
-        : node_to_class_id(std::move(node_to_class_id_))
+        : node_to_class_id_(std::move(node_to_class_id))
     {
         std::vector<unsigned> bearing_counts(bearing_classes.size());
         std::transform(bearing_classes.begin(),
                        bearing_classes.end(),
                        bearing_counts.begin(),
                        [](const auto &bearings) { return bearings.getAvailableBearings().size(); });
+        // NOLINTNEXTLINE(bugprone-fold-init-type)
         auto total_bearings = std::accumulate(bearing_counts.begin(), bearing_counts.end(), 0);
-        class_id_to_ranges_table = RangeTable<16>{bearing_counts};
+        class_id_to_ranges_table_ = RangeTable<16>{bearing_counts};
 
-        values.reserve(total_bearings);
+        values_.reserve(total_bearings);
         for (const auto &bearing_class : bearing_classes)
         {
             const auto &bearings = bearing_class.getAvailableBearings();
-            values.insert(values.end(), bearings.begin(), bearings.end());
+            values_.insert(values_.end(), bearings.begin(), bearings.end());
         }
     }
 
-    IntersectionBearingsContainer(Vector<DiscreteBearing> values_,
-                                  Vector<BearingClassID> node_to_class_id_,
-                                  RangeTable<16> class_id_to_ranges_table_)
-        : values(std::move(values_)), node_to_class_id(std::move(node_to_class_id_)),
-          class_id_to_ranges_table(std::move(class_id_to_ranges_table_))
+    IntersectionBearingsContainer(Vector<DiscreteBearing> values,
+                                  Vector<BearingClassID> node_to_class_id,
+                                  RangeTable<16> class_id_to_ranges_table)
+        : values_(std::move(values)), node_to_class_id_(std::move(node_to_class_id)),
+          class_id_to_ranges_table_(std::move(class_id_to_ranges_table))
     {
     }
 
     // Returns the bearing class for an intersection node
     util::guidance::BearingClass GetBearingClass(const NodeID node) const
     {
-        auto class_id = node_to_class_id[node];
-        auto range = class_id_to_ranges_table.GetRange(class_id);
+        auto class_id = node_to_class_id_[node];
+        auto range = class_id_to_ranges_table_.GetRange(class_id);
         util::guidance::BearingClass result;
-        std::for_each(values.begin() + range.front(),
-                      values.begin() + range.back() + 1,
+        std::for_each(values_.begin() + range.front(),
+                      values_.begin() + range.back() + 1,
                       [&](const DiscreteBearing &bearing) { result.add(bearing); });
         return result;
     }
@@ -95,16 +97,16 @@ template <storage::Ownership Ownership> class IntersectionBearingsContainer
                                     const IntersectionBearingsContainer &turn_data_container);
 
   private:
-    Vector<DiscreteBearing> values;
-    Vector<BearingClassID> node_to_class_id;
-    RangeTable<16> class_id_to_ranges_table;
+    Vector<DiscreteBearing> values_;
+    Vector<BearingClassID> node_to_class_id_;
+    RangeTable<16> class_id_to_ranges_table_;
 };
-}
+} // namespace detail
 
 using IntersectionBearingsContainer =
     detail::IntersectionBearingsContainer<storage::Ownership::Container>;
 using IntersectionBearingsView = detail::IntersectionBearingsContainer<storage::Ownership::View>;
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/location_dependent_data.hpp b/include/extractor/location_dependent_data.hpp
index c8f4b9af9..afb0a66b9 100644
--- a/include/extractor/location_dependent_data.hpp
+++ b/include/extractor/location_dependent_data.hpp
@@ -48,7 +48,7 @@ struct LocationDependentData
     std::vector<std::pair<polygon_bands_t, std::size_t>> polygons;
     std::vector<properties_t> properties;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/maneuver_override.hpp b/include/extractor/maneuver_override.hpp
index 34ac6230e..ab0d2837a 100644
--- a/include/extractor/maneuver_override.hpp
+++ b/include/extractor/maneuver_override.hpp
@@ -71,19 +71,19 @@ struct UnresolvedManeuverOverride
     // check if all parts of the restriction reference an actual node
     bool Valid() const
     {
-        return !turn_sequence.empty() && std::none_of(turn_sequence.begin(),
-                                                      turn_sequence.end(),
-                                                      [](const auto &n) {
-                                                          return n.from == SPECIAL_NODEID ||
-                                                                 n.via == SPECIAL_NODEID ||
-                                                                 n.to == SPECIAL_NODEID;
-                                                      }) &&
+        return !turn_sequence.empty() &&
+               std::none_of(turn_sequence.begin(),
+                            turn_sequence.end(),
+                            [](const auto &n) {
+                                return n.from == SPECIAL_NODEID || n.via == SPECIAL_NODEID ||
+                                       n.to == SPECIAL_NODEID;
+                            }) &&
                (direction != guidance::DirectionModifier::MaxDirectionModifier ||
                 override_type != guidance::TurnType::Invalid);
     }
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 // custom specialization of std::hash can be injected in namespace std
 namespace std
@@ -104,7 +104,7 @@ template <> struct hash<osrm::extractor::NodeBasedTurn>
         return seed;
     }
 };
-}
+} // namespace std
 
 #endif
 /*
diff --git a/include/extractor/maneuver_override_relation_parser.hpp b/include/extractor/maneuver_override_relation_parser.hpp
index 902410a13..31355fcb2 100644
--- a/include/extractor/maneuver_override_relation_parser.hpp
+++ b/include/extractor/maneuver_override_relation_parser.hpp
@@ -10,7 +10,7 @@
 namespace osmium
 {
 class Relation;
-}
+} // namespace osmium
 
 namespace osrm
 {
@@ -59,7 +59,7 @@ class ManeuverOverrideRelationParser
     ManeuverOverrideRelationParser();
     boost::optional<InputManeuverOverride> TryParse(const osmium::Relation &relation) const;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* RESTRICTION_PARSER_HPP */
diff --git a/include/extractor/name_table.hpp b/include/extractor/name_table.hpp
index f50bd73e1..ff0d27ae1 100644
--- a/include/extractor/name_table.hpp
+++ b/include/extractor/name_table.hpp
@@ -15,7 +15,7 @@ namespace extractor
 namespace detail
 {
 template <storage::Ownership Ownership> class NameTableImpl;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -28,7 +28,7 @@ template <storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::NameTableImpl<Ownership> &index_data);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -111,7 +111,7 @@ template <storage::Ownership Ownership> class NameTableImpl
   private:
     IndexedData indexed_data;
 };
-}
+} // namespace detail
 
 using NameTable = detail::NameTableImpl<storage::Ownership::Container>;
 using NameTableView = detail::NameTableImpl<storage::Ownership::View>;
diff --git a/include/extractor/nbg_to_ebg.hpp b/include/extractor/nbg_to_ebg.hpp
index adbf70a4b..6859db9a8 100644
--- a/include/extractor/nbg_to_ebg.hpp
+++ b/include/extractor/nbg_to_ebg.hpp
@@ -15,7 +15,7 @@ struct NBGToEBG
     NodeID u, v;
     NodeID forward_ebg_node, backward_ebg_node;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/node_based_edge.hpp b/include/extractor/node_based_edge.hpp
index 5abcd08d3..cafb06e12 100644
--- a/include/extractor/node_based_edge.hpp
+++ b/include/extractor/node_based_edge.hpp
@@ -192,7 +192,7 @@ inline NodeBasedEdgeWithOSM::NodeBasedEdgeWithOSM(OSMNodeID source,
                     geometry_id,
                     annotation_data,
                     flags),
-      osm_source_id(std::move(source)), osm_target_id(std::move(target))
+      osm_source_id(source), osm_target_id(target)
 {
 }
 
@@ -206,7 +206,7 @@ static_assert(sizeof(extractor::NodeBasedEdge) == 32,
               "bigger than expected. This will influence "
               "memory consumption.");
 
-} // ns extractor
-} // ns osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* NODE_BASED_EDGE_HPP */
diff --git a/include/extractor/node_based_graph_factory.hpp b/include/extractor/node_based_graph_factory.hpp
index 77f6cb9af..e3fc39583 100644
--- a/include/extractor/node_based_graph_factory.hpp
+++ b/include/extractor/node_based_graph_factory.hpp
@@ -40,7 +40,6 @@ class NodeBasedGraphFactory
     NodeBasedGraphFactory(const boost::filesystem::path &input_file,
                           ScriptingEnvironment &scripting_environment,
                           std::vector<TurnRestriction> &turn_restrictions,
-                          std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                           std::vector<UnresolvedManeuverOverride> &maneuver_overrides);
 
     auto const &GetGraph() const { return compressed_output_graph; }
@@ -69,7 +68,6 @@ class NodeBasedGraphFactory
     // edges into a single representative form
     void Compress(ScriptingEnvironment &scripting_environment,
                   std::vector<TurnRestriction> &turn_restrictions,
-                  std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                   std::vector<UnresolvedManeuverOverride> &maneuver_overrides);
 
     // Most ways are bidirectional, making the geometry in forward and backward direction the same,
diff --git a/include/extractor/node_data_container.hpp b/include/extractor/node_data_container.hpp
index e60dfa2e2..b3825c314 100644
--- a/include/extractor/node_data_container.hpp
+++ b/include/extractor/node_data_container.hpp
@@ -24,7 +24,7 @@ class EdgeBasedGraphFactory;
 namespace detail
 {
 template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -37,7 +37,7 @@ template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const detail::EdgeBasedNodeDataContainerImpl<Ownership> &ebn_data);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -122,7 +122,7 @@ template <storage::Ownership Ownership> class EdgeBasedNodeDataContainerImpl
     Vector<EdgeBasedNode> nodes;
     Vector<NodeBasedEdgeAnnotation> annotation_data;
 };
-}
+} // namespace detail
 
 using EdgeBasedNodeDataExternalContainer =
     detail::EdgeBasedNodeDataContainerImpl<storage::Ownership::External>;
diff --git a/include/extractor/node_restriction_map.hpp b/include/extractor/node_restriction_map.hpp
new file mode 100644
index 000000000..f2c9f049c
--- /dev/null
+++ b/include/extractor/node_restriction_map.hpp
@@ -0,0 +1,80 @@
+#ifndef OSRM_EXTRACTOR_NODE_RESTRICTION_MAP_HPP_
+#define OSRM_EXTRACTOR_NODE_RESTRICTION_MAP_HPP_
+
+#include "extractor/restriction.hpp"
+#include "restriction_graph.hpp"
+#include "util/typedefs.hpp"
+
+#include <boost/range/adaptor/filtered.hpp>
+#include <boost/unordered_map.hpp>
+
+#include <utility>
+#include <vector>
+
+namespace osrm
+{
+namespace extractor
+{
+
+// Allows easy check for whether a node restriction is present at a given intersection
+template <typename RestrictionFilter> class NodeRestrictionMap
+{
+  public:
+    NodeRestrictionMap(const RestrictionGraph &restriction_graph)
+        : restriction_graph(restriction_graph), index_filter(RestrictionFilter{})
+    {
+    }
+
+    // Find all restrictions applicable to (from,via,*) turns
+    auto Restrictions(NodeID from, NodeID via) const
+    {
+        return getRange(from, via) | boost::adaptors::filtered(index_filter);
+    };
+
+    // Find all restrictions applicable to (from,via,to) turns
+    auto Restrictions(NodeID from, NodeID via, NodeID to) const
+    {
+        const auto turnFilter = [this, to](const auto &restriction) {
+            return index_filter(restriction) && restriction->IsTurnRestricted(to);
+        };
+        return getRange(from, via) | boost::adaptors::filtered(turnFilter);
+    };
+
+  private:
+    RestrictionGraph::RestrictionRange getRange(NodeID from, NodeID via) const
+    {
+        const auto start_node_it = restriction_graph.start_edge_to_node.find({from, via});
+        if (start_node_it != restriction_graph.start_edge_to_node.end())
+        {
+            return restriction_graph.GetRestrictions(start_node_it->second);
+        }
+        return {};
+    }
+    const RestrictionGraph &restriction_graph;
+    const RestrictionFilter index_filter;
+};
+
+// Restriction filters to use as index defaults
+struct ConditionalOnly
+{
+    bool operator()(const TurnRestriction *restriction) const
+    {
+        return !restriction->IsUnconditional();
+    };
+};
+
+struct UnconditionalOnly
+{
+    bool operator()(const TurnRestriction *restriction) const
+    {
+        return restriction->IsUnconditional();
+    };
+};
+
+using RestrictionMap = NodeRestrictionMap<UnconditionalOnly>;
+using ConditionalRestrictionMap = NodeRestrictionMap<ConditionalOnly>;
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_NODE_RESTRICTION_MAP_HPP_
diff --git a/include/extractor/nodes_of_way.hpp b/include/extractor/nodes_of_way.hpp
new file mode 100644
index 000000000..d7f19c705
--- /dev/null
+++ b/include/extractor/nodes_of_way.hpp
@@ -0,0 +1,56 @@
+#ifndef NODES_OF_WAY_HPP
+#define NODES_OF_WAY_HPP
+
+#include "util/typedefs.hpp"
+
+#include <limits>
+#include <string>
+#include <vector>
+
+namespace osrm
+{
+namespace extractor
+{
+
+// NodesOfWay contains the ordered nodes of a way and provides convenience functions for getting
+// nodes in the first and last segments.
+struct NodesOfWay
+{
+    OSMWayID way_id;
+    std::vector<OSMNodeID> node_ids;
+
+    NodesOfWay() : way_id(SPECIAL_OSM_WAYID), node_ids{SPECIAL_OSM_NODEID, SPECIAL_OSM_NODEID} {}
+
+    NodesOfWay(OSMWayID w, std::vector<OSMNodeID> ns) : way_id(w), node_ids(std::move(ns)) {}
+
+    static NodesOfWay min_value() { return {MIN_OSM_WAYID, {MIN_OSM_NODEID, MIN_OSM_NODEID}}; }
+    static NodesOfWay max_value() { return {MAX_OSM_WAYID, {MAX_OSM_NODEID, MAX_OSM_NODEID}}; }
+
+    const OSMNodeID &first_segment_source_id() const
+    {
+        BOOST_ASSERT(!node_ids.empty());
+        return node_ids[0];
+    }
+
+    const OSMNodeID &first_segment_target_id() const
+    {
+        BOOST_ASSERT(node_ids.size() > 1);
+        return node_ids[1];
+    }
+
+    const OSMNodeID &last_segment_source_id() const
+    {
+        BOOST_ASSERT(node_ids.size() > 1);
+        return node_ids[node_ids.size() - 2];
+    }
+
+    const OSMNodeID &last_segment_target_id() const
+    {
+        BOOST_ASSERT(!node_ids.empty());
+        return node_ids[node_ids.size() - 1];
+    }
+};
+} // namespace extractor
+} // namespace osrm
+
+#endif /* NODES_OF_WAY_HPP */
diff --git a/include/extractor/packed_osm_ids.hpp b/include/extractor/packed_osm_ids.hpp
index 0f97d4b06..137c2f67a 100644
--- a/include/extractor/packed_osm_ids.hpp
+++ b/include/extractor/packed_osm_ids.hpp
@@ -11,12 +11,12 @@ namespace extractor
 namespace detail
 {
 template <storage::Ownership Ownership>
-using PackedOSMIDs = util::detail::PackedVector<OSMNodeID, 33, Ownership>;
-}
+using PackedOSMIDs = util::detail::PackedVector<OSMNodeID, 34, Ownership>;
+} // namespace detail
 
 using PackedOSMIDsView = detail::PackedOSMIDs<storage::Ownership::View>;
 using PackedOSMIDs = detail::PackedOSMIDs<storage::Ownership::Container>;
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/profile_properties.hpp b/include/extractor/profile_properties.hpp
index 7960544d8..ccfd0f348 100644
--- a/include/extractor/profile_properties.hpp
+++ b/include/extractor/profile_properties.hpp
@@ -138,7 +138,7 @@ struct ProfileProperties
     bool force_split_edges = false;
     bool call_tagless_node_function = true;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/query_node.hpp b/include/extractor/query_node.hpp
index 53c7adad7..557c80eea 100644
--- a/include/extractor/query_node.hpp
+++ b/include/extractor/query_node.hpp
@@ -48,7 +48,7 @@ struct QueryNode
                          MAX_OSM_NODEID);
     }
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // QUERY_NODE_HPP
diff --git a/include/extractor/raster_source.hpp b/include/extractor/raster_source.hpp
old mode 100755
new mode 100644
index eebe62979..e91089252
--- a/include/extractor/raster_source.hpp
+++ b/include/extractor/raster_source.hpp
@@ -18,7 +18,6 @@
 #include <iterator>
 #include <string>
 #include <unordered_map>
-using namespace std;
 
 namespace osrm
 {
@@ -47,7 +46,7 @@ class RasterGrid
     {
         xdim = _xdim;
         ydim = _ydim;
-        _data.reserve(ydim * xdim);
+        _data.resize(ydim * xdim);
         BOOST_ASSERT(ydim * xdim <= _data.capacity());
 
         // Construct FileReader
@@ -164,6 +163,7 @@ class RasterCache
     // get reference of cache
     std::vector<RasterSource> &getLoadedSources() { return LoadedSources; }
     std::unordered_map<std::string, int> &getLoadedSourcePaths() { return LoadedSourcePaths; }
+
   private:
     // constructor
     RasterCache() = default;
@@ -173,7 +173,7 @@ class RasterCache
     // the instance
     static RasterCache *g_instance;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* RASTER_SOURCE_HPP */
diff --git a/include/extractor/restriction.hpp b/include/extractor/restriction.hpp
index 4f7f59a0e..7f17eaeae 100644
--- a/include/extractor/restriction.hpp
+++ b/include/extractor/restriction.hpp
@@ -30,17 +30,19 @@ struct InputNodeRestriction
     OSMWayID to;
 };
 
-// A restriction that uses a single via-way in between
+// A restriction that uses one or more via-way in between
 //
-// f - e - d
+// e - f - g
+//     |
+//     d
 //     |
 // a - b - c
 //
-// ab via be to ef -- no u turn
+// ab via bd,df to fe -- no u turn
 struct InputWayRestriction
 {
     OSMWayID from;
-    OSMWayID via;
+    std::vector<OSMWayID> via;
     OSMWayID to;
 };
 
@@ -57,6 +59,9 @@ struct InputTurnRestriction
     // keep in the same order as the turn restrictions below
     mapbox::util::variant<InputNodeRestriction, InputWayRestriction> node_or_way;
     bool is_only;
+    // We represent conditional and unconditional restrictions with the same structure.
+    // Unconditional restrictions will have empty conditions.
+    std::vector<util::OpeningHours> condition;
 
     OSMWayID From() const
     {
@@ -102,13 +107,15 @@ struct InputTurnRestriction
         return mapbox::util::get<InputNodeRestriction>(node_or_way);
     }
 };
-struct InputConditionalTurnRestriction : InputTurnRestriction
-{
-    std::vector<util::OpeningHours> condition;
-};
 
 // OSRM manages restrictions based on node IDs which refer to the last node along the edge. Note
 // that this has the side-effect of not allowing parallel edges!
+//
+// a - b - c
+//     |
+//     d
+//
+// ab via b to bd
 struct NodeRestriction
 {
     NodeID from;
@@ -131,39 +138,46 @@ struct NodeRestriction
 // compression happening in the graph creation process which would make it difficult to track
 // way-ids over a series of operations. Having access to the nodes directly allows look-up of the
 // edges in the processed structures
+//
+// e - f - g
+//     |
+//     d
+//     |
+// a - b - c
+//
+// ab via bd,df to fe -- no u turn
 struct WayRestriction
 {
-    // a way restriction in OSRM is essentially a dual node turn restriction;
-    //
-    // |     |
-    // c -x- b
-    // |     |
-    // d     a
-    //
-    // from ab via bxc to cd: no_uturn
-    //
-    // Technically, we would need only a,b,c,d to describe the full turn in terms of nodes. When
-    // parsing the relation, though, we do not know about the final representation in the node-based
-    // graph for the restriction. In case of a traffic light, for example, we might end up with bxc
-    // not being compressed to bc. For that reason, we need to maintain two node restrictions in
-    // case a way restrction is not fully collapsed
-    NodeRestriction in_restriction;
-    NodeRestriction out_restriction;
+    // A way restriction in OSRM needs to track all nodes that make up the via ways. Whilst most
+    // of these nodes will be removed by compression, some nodes will contain features that need to
+    // be considered when routing (e.g. intersections, nested restrictions, etc).
+    NodeID from;
+    std::vector<NodeID> via;
+    NodeID to;
+
+    // check if all parts of the restriction reference an actual node
+    bool Valid() const
+    {
+        return from != SPECIAL_NODEID && to != SPECIAL_NODEID && via.size() >= 2 &&
+               std::all_of(via.begin(), via.end(), [](NodeID i) { return i != SPECIAL_NODEID; });
+    };
 
     bool operator==(const WayRestriction &other) const
     {
-        return std::tie(in_restriction, out_restriction) ==
-               std::tie(other.in_restriction, other.out_restriction);
+        return std::tie(from, via, to) == std::tie(other.from, other.via, other.to);
     }
 };
 
 // Wrapper for turn restrictions that gives more information on its type / handles the switch
-// between node/way/multi-way restrictions
+// between node/way restrictions
 struct TurnRestriction
 {
     // keep in the same order as the turn restrictions above
     mapbox::util::variant<NodeRestriction, WayRestriction> node_or_way;
     bool is_only;
+    // We represent conditional and unconditional restrictions with the same structure.
+    // Unconditional restrictions will have empty conditions.
+    std::vector<util::OpeningHours> condition;
 
     // construction for NodeRestrictions
     explicit TurnRestriction(NodeRestriction node_restriction, bool is_only = false)
@@ -172,16 +186,47 @@ struct TurnRestriction
     }
 
     // construction for WayRestrictions
-    explicit TurnRestriction(WayRestriction way_restriction, bool is_only = false)
+    explicit TurnRestriction(const WayRestriction &way_restriction, bool is_only = false)
         : node_or_way(way_restriction), is_only(is_only)
     {
     }
 
     explicit TurnRestriction()
     {
-        node_or_way = NodeRestriction{SPECIAL_EDGEID, SPECIAL_NODEID, SPECIAL_EDGEID};
+        node_or_way = NodeRestriction{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
     }
 
+    NodeID To() const
+    {
+        return node_or_way.which() == RestrictionType::NODE_RESTRICTION
+                   ? mapbox::util::get<NodeRestriction>(node_or_way).to
+                   : mapbox::util::get<WayRestriction>(node_or_way).to;
+    }
+
+    NodeID From() const
+    {
+        return node_or_way.which() == RestrictionType::NODE_RESTRICTION
+                   ? mapbox::util::get<NodeRestriction>(node_or_way).from
+                   : mapbox::util::get<WayRestriction>(node_or_way).from;
+    }
+
+    NodeID FirstVia() const
+    {
+        if (node_or_way.which() == RestrictionType::NODE_RESTRICTION)
+        {
+            return mapbox::util::get<NodeRestriction>(node_or_way).via;
+        }
+        else
+        {
+            BOOST_ASSERT(!mapbox::util::get<WayRestriction>(node_or_way).via.empty());
+            return mapbox::util::get<WayRestriction>(node_or_way).via[0];
+        }
+    }
+
+    bool IsTurnRestricted(NodeID to) const { return is_only ? To() != to : To() == to; }
+
+    bool IsUnconditional() const { return condition.empty(); }
+
     WayRestriction &AsWayRestriction()
     {
         BOOST_ASSERT(node_or_way.which() == RestrictionType::WAY_RESTRICTION);
@@ -218,7 +263,7 @@ struct TurnRestriction
         if (node_or_way.which() == RestrictionType::WAY_RESTRICTION)
         {
             auto const &restriction = AsWayRestriction();
-            return restriction.in_restriction.Valid() && restriction.out_restriction.Valid();
+            return restriction.Valid();
         }
         else
         {
@@ -245,12 +290,7 @@ struct TurnRestriction
         }
     }
 };
-
-struct ConditionalTurnRestriction : TurnRestriction
-{
-    std::vector<util::OpeningHours> condition;
-};
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif // RESTRICTION_HPP
diff --git a/include/extractor/restriction_compressor.hpp b/include/extractor/restriction_compressor.hpp
index 42675e716..500ec18e3 100644
--- a/include/extractor/restriction_compressor.hpp
+++ b/include/extractor/restriction_compressor.hpp
@@ -16,8 +16,8 @@ namespace extractor
 struct NodeRestriction;
 struct TurnRestriction;
 
-// OSRM stores restrictions in the form node -> node -> node instead of way -> node -> way (or
-// way->way->way) as it is done in OSM. These restrictions need to match the state of graph
+// OSRM stores restrictions as node -> [node] -> node instead of way -> node -> way (or
+// way->[way]->way) as it is done in OSM. These restrictions need to match the state of graph
 // compression which we perform in the graph compressor that removes certain degree two nodes from
 // the graph (all but the ones with penalties/barriers, as of the state of writing).
 // Since this graph compression ins performed after creating the restrictions in the extraction
@@ -29,19 +29,22 @@ class RestrictionCompressor
 {
   public:
     RestrictionCompressor(std::vector<TurnRestriction> &restrictions,
-                          std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
                           std::vector<UnresolvedManeuverOverride> &maneuver_overrides);
 
     // account for the compression of `from-via-to` into `from-to`
     void Compress(const NodeID from, const NodeID via, const NodeID to);
 
   private:
-    // a turn restriction is given as `from star via node to end`. Edges ending at `head` being
+    // A turn restriction is given as `from star via node to end`. Edges ending at `head` being
     // contracted move the head pointer to their respective head. Edges starting at tail move the
-    // tail values to their respective tails. Way turn restrictions are represented by two
-    // node-restrictions, so we can focus on them alone
-    boost::unordered_multimap<NodeID, NodeRestriction *> starts;
-    boost::unordered_multimap<NodeID, NodeRestriction *> ends;
+    // tail values to their respective tails.
+    // Via nodes that are compressed are removed from the restriction representation.
+    // We do not compress the first and last via nodes of a restriction as they act as
+    // entrance/exit points into the restriction graph. For a node restriction, the first and last
+    // via nodes are the same.
+    boost::unordered_multimap<NodeID, TurnRestriction *> starts;
+    boost::unordered_multimap<NodeID, TurnRestriction *> vias;
+    boost::unordered_multimap<NodeID, TurnRestriction *> ends;
 
     boost::unordered_multimap<NodeID, NodeBasedTurn *> maneuver_starts;
     boost::unordered_multimap<NodeID, NodeBasedTurn *> maneuver_ends;
diff --git a/include/extractor/restriction_filter.hpp b/include/extractor/restriction_filter.hpp
index 0b23e3076..2bdc8831e 100644
--- a/include/extractor/restriction_filter.hpp
+++ b/include/extractor/restriction_filter.hpp
@@ -14,10 +14,8 @@ namespace extractor
 // To avoid handling invalid restrictions / creating unnecessary duplicate nodes for via-ways, we do
 // a pre-flight check for restrictions and remove all invalid restrictions from the data. Use as
 // `restrictions = removeInvalidRestrictions(std::move(restrictions))`
-std::vector<ConditionalTurnRestriction>
-removeInvalidRestrictions(std::vector<ConditionalTurnRestriction>,
-                          const util::NodeBasedDynamicGraph &);
-
+std::vector<TurnRestriction> removeInvalidRestrictions(std::vector<TurnRestriction>,
+                                                       const util::NodeBasedDynamicGraph &);
 } // namespace extractor
 } // namespace osrm
 
diff --git a/include/extractor/restriction_graph.hpp b/include/extractor/restriction_graph.hpp
new file mode 100644
index 000000000..7f880b1fc
--- /dev/null
+++ b/include/extractor/restriction_graph.hpp
@@ -0,0 +1,134 @@
+#ifndef OSRM_EXTRACTOR_RESTRICTION_GRAPH_HPP_
+#define OSRM_EXTRACTOR_RESTRICTION_GRAPH_HPP_
+
+#include <boost/assert.hpp>
+#include <boost/unordered_map.hpp>
+
+#include "extractor/restriction_filter.hpp"
+#include "util/node_based_graph.hpp"
+#include "util/typedefs.hpp"
+
+namespace osrm
+{
+namespace extractor
+{
+
+namespace restriction_graph_details
+{
+struct transferBuilder;
+struct pathBuilder;
+} // namespace restriction_graph_details
+
+struct RestrictionEdge
+{
+    NodeID node_based_to;
+    RestrictionID target;
+    bool is_transfer;
+};
+
+struct RestrictionNode
+{
+    size_t restrictions_begin_idx;
+    size_t num_restrictions;
+    size_t edges_begin_idx;
+    size_t num_edges;
+};
+
+/**
+ * The restriction graph is used to represent all possible restrictions within the routing graph.
+ * The graph uses an edge-based node representation. Each node represents a compressed
+ * node-based edge along a restriction path.
+ *
+ * Given a list of turn restrictions, the graph is created in multiple steps.
+ *
+ * INPUT
+ * a -> b -> d: no_e
+ * a -> b -> c: only_d
+ * b -> c -> d: only_f
+ * b -> c: no_g
+ * e -> b -> d: no_g
+ *
+ * Step 1: create a disjoint union of prefix trees for all restriction paths.
+ * The restriction instructions are added to the final node in its path.
+ *
+ * STEP 1
+ * (a,b) -> (b,d,[no_e])
+ *      \->(b,c,[only_d])
+ *
+ * (b,c,[no_g]) -> (c,d,[only_f])
+ * (e,b) -> (b,d,[no_g])
+ *
+ * Step 2: add transfers between restriction paths that overlap.
+ * We do this by traversing each restriction path, tracking where the suffix of our current path
+ * matches the prefix of any other. If it does, there's opportunity to transfer to the suffix
+ * restriction path *if* the transfer would not be restricted *and* that edge does not take us
+ * further on our current path. Nested restrictions are also added from any of the suffix paths.
+ *
+ * STEP 2
+ * (a,b) -> (b,d,[no_e])
+ *      \->(b,c,[only_d,no_g])
+ *                \
+ * (b,c,[no_g]) -> \-> (c,d,[only_f])
+ *
+ * (e,b) -> (b,d,[no_g])
+ * If a transfer applies to multiple suffix paths, we only add the edge to the largest suffix path.
+ * This ensures we correctly track all overlapping paths.
+ *
+ *
+ * Step 3: The nodes are split into
+ * start nodes - compressed edges that are entry points into a restriction path.
+ * via nodes - compressed edges that are intermediate steps along a restriction path.
+ * Start nodes and via nodes are indexed by the compressed node-based edge for easy retrieval
+ *
+ * STEP 3
+ * Start Node Index
+ * (a,b) => (a,b)
+ * (b,c) => (b,c,[no_g])
+ * (e,b) => (e,b)
+ *
+ * Via Nodes Index
+ * (b,c) => (b,c,[only_d,no_g])
+ * (b,d) => (b,d,[no_e]) , (b,d,[no_g])
+ * (c,d) => (c,d,[only_f])
+ *
+ * Duplicate Nodes:
+ * There is a 1-1 mapping between restriction graph via nodes and edge-based-graph duplicate nodes.
+ * This relationship is used in the creation of restrictions in the routing edge-based graph.
+ * */
+struct RestrictionGraph
+{
+    friend restriction_graph_details::pathBuilder;
+    friend restriction_graph_details::transferBuilder;
+    friend RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &);
+
+    using EdgeRange = boost::iterator_range<std::vector<RestrictionEdge>::const_iterator>;
+    using RestrictionRange =
+        boost::iterator_range<std::vector<const TurnRestriction *>::const_iterator>;
+    using EdgeKey = std::pair<NodeID, NodeID>;
+
+    // Helper functions for iterating over node restrictions and edges
+    EdgeRange GetEdges(RestrictionID id) const;
+    RestrictionRange GetRestrictions(RestrictionID id) const;
+
+    // A compressed node-based edge can only have one start node in the restriction graph.
+    boost::unordered_map<EdgeKey, RestrictionID> start_edge_to_node{};
+    // A compressed node-based edge can have multiple via nodes in the restriction graph
+    // (as the compressed edge can appear in paths with different prefixes).
+    boost::unordered_multimap<EdgeKey, RestrictionID> via_edge_to_node{};
+    std::vector<RestrictionNode> nodes;
+    // TODO: Investigate reusing DynamicGraph. Currently it requires specific attributes
+    // (e.g. reversed, weight) that would not make sense for restrictions.
+    std::vector<RestrictionEdge> edges;
+    std::vector<const TurnRestriction *> restrictions;
+    size_t num_via_nodes{};
+
+  private:
+    RestrictionGraph() = default;
+};
+
+RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &turn_restrictions);
+
+} // namespace extractor
+} // namespace osrm
+
+#endif // OSRM_EXTRACTOR_RESTRICTION_GRAPH_HPP_
diff --git a/include/extractor/restriction_index.hpp b/include/extractor/restriction_index.hpp
deleted file mode 100644
index 350a89d5e..000000000
--- a/include/extractor/restriction_index.hpp
+++ /dev/null
@@ -1,101 +0,0 @@
-#ifndef OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_
-#define OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_
-
-#include "extractor/restriction.hpp"
-#include "util/typedefs.hpp"
-
-#include <boost/unordered_map.hpp>
-
-#include <utility>
-#include <vector>
-
-namespace osrm
-{
-namespace extractor
-{
-
-// allows easy check for whether a node intersection is present at a given intersection
-template <typename restriction_type> class RestrictionIndex
-{
-  public:
-    using value_type = restriction_type;
-
-    template <typename extractor_type>
-    RestrictionIndex(std::vector<restriction_type> &restrictions, extractor_type extractor);
-
-    bool IsIndexed(NodeID first, NodeID second) const;
-
-    auto Restrictions(NodeID first, NodeID second) const
-    {
-        return restriction_hash.equal_range(std::make_pair(first, second));
-    };
-
-    auto Size() const { return restriction_hash.size(); }
-
-  private:
-    boost::unordered_multimap<std::pair<NodeID, NodeID>, restriction_type *> restriction_hash;
-};
-
-template <typename restriction_type>
-template <typename extractor_type>
-RestrictionIndex<restriction_type>::RestrictionIndex(std::vector<restriction_type> &restrictions,
-                                                     extractor_type extractor)
-{
-    // build a multi-map
-    for (auto &restriction : restrictions)
-        restriction_hash.insert(std::make_pair(extractor(restriction), &restriction));
-}
-
-template <typename restriction_type>
-bool RestrictionIndex<restriction_type>::IsIndexed(const NodeID first, const NodeID second) const
-{
-    return restriction_hash.count(std::make_pair(first, second));
-}
-
-struct IndexNodeByFromAndVia
-{
-    std::pair<NodeID, NodeID> operator()(const TurnRestriction &restriction)
-    {
-        const auto &node = restriction.AsNodeRestriction();
-        return std::make_pair(node.from, node.via);
-    };
-};
-
-// check wheter a turn is restricted within a restriction_index
-template <typename restriction_map_type>
-std::pair<bool, typename restriction_map_type::value_type *>
-isRestricted(const NodeID from,
-             const NodeID via,
-             const NodeID to,
-             const restriction_map_type &restriction_map)
-{
-    const auto range = restriction_map.Restrictions(from, via);
-
-    // check if a given node_restriction is targeting node
-    const auto to_is_restricted = [to](const auto &pair) {
-        const auto &restriction = *pair.second;
-        if (restriction.Type() == RestrictionType::NODE_RESTRICTION)
-        {
-            auto const &as_node = restriction.AsNodeRestriction();
-            auto const restricted = restriction.is_only ? (to != as_node.to) : (to == as_node.to);
-
-            return restricted;
-        }
-        return false;
-    };
-
-    auto itr = std::find_if(range.first, range.second, to_is_restricted);
-
-    if (itr != range.second)
-        return {true, itr->second};
-    else
-        return {false, NULL};
-}
-
-using RestrictionMap = RestrictionIndex<TurnRestriction>;
-using ConditionalRestrictionMap = RestrictionIndex<ConditionalTurnRestriction>;
-
-} // namespace extractor
-} // namespace osrm
-
-#endif // OSRM_EXTRACTOR_RESTRICTION_INDEX_HPP_
diff --git a/include/extractor/restriction_parser.hpp b/include/extractor/restriction_parser.hpp
index 25a2a95e0..33367ae14 100644
--- a/include/extractor/restriction_parser.hpp
+++ b/include/extractor/restriction_parser.hpp
@@ -11,7 +11,7 @@
 namespace osmium
 {
 class Relation;
-}
+} // namespace osmium
 
 namespace osrm
 {
@@ -44,8 +44,7 @@ class RestrictionParser
     RestrictionParser(bool use_turn_restrictions,
                       bool parse_conditionals,
                       std::vector<std::string> &restrictions);
-    boost::optional<InputConditionalTurnRestriction>
-    TryParse(const osmium::Relation &relation) const;
+    boost::optional<InputTurnRestriction> TryParse(const osmium::Relation &relation) const;
 
   private:
     bool ShouldIgnoreRestriction(const std::string &except_tag_string) const;
@@ -54,7 +53,7 @@ class RestrictionParser
     bool parse_conditionals;
     std::vector<std::string> restrictions;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* RESTRICTION_PARSER_HPP */
diff --git a/include/extractor/road_classification.hpp b/include/extractor/road_classification.hpp
index da7b2638a..bac267bb3 100644
--- a/include/extractor/road_classification.hpp
+++ b/include/extractor/road_classification.hpp
@@ -50,7 +50,7 @@ const constexpr Enum FOOT_PATH = 18;
 // a road simply offered for connectivity. Will be ignored in forks/other decisions. Always
 // considered non-obvious to continue on
 const constexpr Enum CONNECTIVITY = 31;
-} // namespace Road Class
+} // namespace RoadPriorityClass
 
 #pragma pack(push, 1)
 class RoadClassification
diff --git a/include/extractor/scripting_environment.hpp b/include/extractor/scripting_environment.hpp
index 0fcc4a7c9..2a11afc33 100644
--- a/include/extractor/scripting_environment.hpp
+++ b/include/extractor/scripting_environment.hpp
@@ -18,7 +18,7 @@ namespace osmium
 class Node;
 class Way;
 class Relation;
-}
+} // namespace osmium
 
 namespace osrm
 {
@@ -26,7 +26,7 @@ namespace osrm
 namespace util
 {
 struct Coordinate;
-}
+} // namespace util
 
 namespace extractor
 {
@@ -68,12 +68,12 @@ class ScriptingEnvironment
                     const ExtractionRelationContainer &relations,
                     std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
                     std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions,
+                    std::vector<InputTurnRestriction> &resulting_restrictions,
                     std::vector<InputManeuverOverride> &resulting_maneuver_overrides) = 0;
 
     virtual bool HasLocationDependentData() const = 0;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* SCRIPTING_ENVIRONMENT_HPP */
diff --git a/include/extractor/scripting_environment_lua.hpp b/include/extractor/scripting_environment_lua.hpp
index 7714831aa..f3b19ee6e 100644
--- a/include/extractor/scripting_environment_lua.hpp
+++ b/include/extractor/scripting_environment_lua.hpp
@@ -12,7 +12,7 @@
 #include <mutex>
 #include <string>
 
-#include <sol2/sol.hpp>
+#include <sol/sol.hpp>
 
 namespace osrm
 {
@@ -92,7 +92,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
                     const ExtractionRelationContainer &relations,
                     std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
                     std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-                    std::vector<InputConditionalTurnRestriction> &resulting_restrictions,
+                    std::vector<InputTurnRestriction> &resulting_restrictions,
                     std::vector<InputManeuverOverride> &resulting_maneuver_overrides) override;
 
     bool HasLocationDependentData() const override { return !location_dependent_data.empty(); }
@@ -110,7 +110,7 @@ class Sol2ScriptingEnvironment final : public ScriptingEnvironment
     tbb::enumerable_thread_specific<std::unique_ptr<LuaScriptingContext>> script_contexts;
     const LocationDependentData location_dependent_data;
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* SCRIPTING_ENVIRONMENT_LUA_HPP */
diff --git a/include/extractor/segment_data_container.hpp b/include/extractor/segment_data_container.hpp
index bb7825000..700455047 100644
--- a/include/extractor/segment_data_container.hpp
+++ b/include/extractor/segment_data_container.hpp
@@ -27,7 +27,7 @@ class CompressedEdgeContainer;
 namespace detail
 {
 template <storage::Ownership Ownership> class SegmentDataContainerImpl;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -39,7 +39,7 @@ template <storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::SegmentDataContainerImpl<Ownership> &segment_data);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -221,11 +221,11 @@ template <storage::Ownership Ownership> class SegmentDataContainerImpl
     SegmentDatasourceVector fwd_datasources;
     SegmentDatasourceVector rev_datasources;
 };
-}
+} // namespace detail
 
 using SegmentDataView = detail::SegmentDataContainerImpl<storage::Ownership::View>;
 using SegmentDataContainer = detail::SegmentDataContainerImpl<storage::Ownership::Container>;
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/serialization.hpp b/include/extractor/serialization.hpp
index 58ca81f0e..e0e0127b2 100644
--- a/include/extractor/serialization.hpp
+++ b/include/extractor/serialization.hpp
@@ -30,11 +30,11 @@ inline void read(storage::tar::FileReader &reader,
                  const std::string &name,
                  detail::IntersectionBearingsContainer<Ownership> &intersection_bearings)
 {
-    storage::serialization::read(reader, name + "/bearing_values", intersection_bearings.values);
+    storage::serialization::read(reader, name + "/bearing_values", intersection_bearings.values_);
     storage::serialization::read(
-        reader, name + "/node_to_class_id", intersection_bearings.node_to_class_id);
+        reader, name + "/node_to_class_id", intersection_bearings.node_to_class_id_);
     util::serialization::read(
-        reader, name + "/class_id_to_ranges", intersection_bearings.class_id_to_ranges_table);
+        reader, name + "/class_id_to_ranges", intersection_bearings.class_id_to_ranges_table_);
 }
 
 template <storage::Ownership Ownership>
@@ -42,11 +42,11 @@ inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::IntersectionBearingsContainer<Ownership> &intersection_bearings)
 {
-    storage::serialization::write(writer, name + "/bearing_values", intersection_bearings.values);
+    storage::serialization::write(writer, name + "/bearing_values", intersection_bearings.values_);
     storage::serialization::write(
-        writer, name + "/node_to_class_id", intersection_bearings.node_to_class_id);
+        writer, name + "/node_to_class_id", intersection_bearings.node_to_class_id_);
     util::serialization::write(
-        writer, name + "/class_id_to_ranges", intersection_bearings.class_id_to_ranges_table);
+        writer, name + "/class_id_to_ranges", intersection_bearings.class_id_to_ranges_table_);
 }
 
 // read/write for properties file
@@ -222,8 +222,8 @@ inline void read(storage::tar::FileReader &reader,
     std::string buffer;
     util::serialization::read(reader, name, name_table.indexed_data);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace extractor
+} // namespace osrm
 
 #endif
diff --git a/include/extractor/tarjan_scc.hpp b/include/extractor/tarjan_scc.hpp
index 2eea7efe7..c4ccac1ca 100644
--- a/include/extractor/tarjan_scc.hpp
+++ b/include/extractor/tarjan_scc.hpp
@@ -180,7 +180,7 @@ template <typename GraphT> class TarjanSCC
 
     unsigned GetComponentID(const NodeID node) const { return components_index[node]; }
 };
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /* TARJAN_SCC_HPP */
diff --git a/include/extractor/travel_mode.hpp b/include/extractor/travel_mode.hpp
index 59ac70d6b..5ba4bbd1f 100644
--- a/include/extractor/travel_mode.hpp
+++ b/include/extractor/travel_mode.hpp
@@ -103,7 +103,7 @@ inline std::string travelModeToString(const TravelMode mode)
     return token;
 }
 
-} // ns extractor
-} // ns osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* TRAVEL_MODE_HPP */
diff --git a/include/extractor/turn_lane_types.hpp b/include/extractor/turn_lane_types.hpp
index ac8c5e0cc..80b413ad7 100644
--- a/include/extractor/turn_lane_types.hpp
+++ b/include/extractor/turn_lane_types.hpp
@@ -52,7 +52,7 @@ const constexpr Mask uturn = 1u << 8u;
 const constexpr Mask merge_to_left = 1u << 9u;
 const constexpr Mask merge_to_right = 1u << 10u;
 
-} // TurnLaneType
+} // namespace TurnLaneType
 
 typedef std::vector<TurnLaneType::Mask> TurnLaneDescription;
 
@@ -100,7 +100,7 @@ inline TurnLanesIndexedArray transformTurnLaneMapIntoArrays(const LaneDescriptio
     return std::make_tuple(std::move(turn_lane_offsets), std::move(turn_lane_masks));
 }
 
-} // extractor
-} // osrm
+} // namespace extractor
+} // namespace osrm
 
 #endif /* OSRM_GUIDANCE_TURN_LANE_TYPES_HPP_ */
diff --git a/include/extractor/way_restriction_map.hpp b/include/extractor/way_restriction_map.hpp
index 636c12747..da29aff67 100644
--- a/include/extractor/way_restriction_map.hpp
+++ b/include/extractor/way_restriction_map.hpp
@@ -8,82 +8,66 @@
 #include <boost/unordered_map.hpp>
 
 #include "extractor/restriction.hpp"
-#include "extractor/restriction_index.hpp"
+#include "extractor/restriction_graph.hpp"
 #include "util/integer_range.hpp"
 #include "util/typedefs.hpp"
 
-// Given the compressed representation of via-way turn restrictions, we provide a fast access into
-// the restrictions to indicate which turns may be restricted due to a way in between
 namespace osrm
 {
 namespace extractor
 {
 
-// The WayRestrictionMap uses ConditionalTurnRestrictions in general. Most restrictions will have
-// empty conditions, though.
+// Given the compressed representation of via-way turn restrictions, we provide a fast access into
+// the restrictions to indicate which turns may be restricted due to a way in between.
 class WayRestrictionMap
 {
   public:
-    struct ViaWay
+    struct ViaEdge
     {
         NodeID from;
         NodeID to;
     };
-    WayRestrictionMap(const std::vector<ConditionalTurnRestriction> &conditional_restrictions);
+    WayRestrictionMap(const RestrictionGraph &restriction_graph);
 
-    // Check if an edge between two nodes is a restricted turn. The check needs to be performed to
+    // Check if an edge between two nodes is part of a via-way. The check needs to be performed to
     // find duplicated nodes during the creation of edge-based-edges
-    bool IsViaWay(const NodeID from, const NodeID to) const;
+    bool IsViaWayEdge(NodeID from, NodeID to) const;
 
-    // Every via-way results in a duplicated node that is required in the edge-based-graph. This
-    // count is essentially the same as the number of valid via-way restrictions (except for
-    // non-only restrictions that share the same in/via combination)
+    // There is a bijection between restriction graph via-nodes and edge-based duplicated nodes.
+    // This counts the number of duplicated nodes contributed by the way restrictions.
     std::size_t NumberOfDuplicatedNodes() const;
 
-    // Returns a representative for each duplicated node, consisting of the representative ID (first
-    // ID of the nodes restrictions) and the from/to vertices of the via-way
-    // This is used to construct edge based nodes that act as intermediate nodes.
-    std::vector<ViaWay> DuplicatedNodeRepresentatives() const;
+    // For each restriction graph via-node, we return its node-based edge representation (from,to).
+    // This is used to create the duplicate node in the edge based graph.
+    std::vector<ViaEdge> DuplicatedViaEdges() const;
 
-    // Access all duplicated NodeIDs for a set of nodes indicating a via way
-    std::vector<DuplicatedNodeID> DuplicatedNodeIDs(const NodeID from, const NodeID to) const;
+    // Access all duplicated NodeIDs from the restriction graph via-node represented by (from,to)
+    std::vector<DuplicatedNodeID> DuplicatedNodeIDs(NodeID from, NodeID to) const;
 
-    // check whether a turn onto a given node is restricted, when coming from a duplicated node
-    bool IsRestricted(DuplicatedNodeID duplicated_node, const NodeID to) const;
-    // Get the restriction resulting in ^ IsRestricted. Requires IsRestricted to evaluate to true
-    const ConditionalTurnRestriction &GetRestriction(DuplicatedNodeID duplicated_node,
-                                                     const NodeID to) const;
+    // Check whether a turn onto a given node is restricted, when coming from a duplicated node
+    bool IsRestricted(DuplicatedNodeID duplicated_node, NodeID to) const;
 
-    // changes edge_based_node to the correct duplicated_node_id in case node_based_from,
-    // node_based_via, node_based_to can be identified with a restriction group
-    NodeID RemapIfRestricted(const NodeID edge_based_node,
-                             const NodeID node_based_from,
-                             const NodeID node_based_via,
-                             const NodeID node_based_to,
-                             const NodeID number_of_edge_based_nodes) const;
+    // Get the restrictions resulting in ^ IsRestricted. Requires IsRestricted to evaluate to true
+    std::vector<const TurnRestriction *> GetRestrictions(DuplicatedNodeID duplicated_node,
+                                                         NodeID to) const;
+
+    // Changes edge_based_node to the correct duplicated_node_id in case node_based_from,
+    // node_based_via, node_based_to can be identified as the start of a way restriction.
+    NodeID RemapIfRestrictionStart(NodeID edge_based_node,
+                                   NodeID node_based_from,
+                                   NodeID node_based_via,
+                                   NodeID node_based_to,
+                                   NodeID number_of_edge_based_nodes) const;
+
+    // Changes edge_based_node to the correct duplicated_node_id in case node_based_from,
+    // node_based_via, node_based_to can be identified as successive via steps of a way restriction.
+    NodeID RemapIfRestrictionVia(NodeID edge_based_target_node,
+                                 NodeID edge_based_via_node,
+                                 NodeID node_based_to,
+                                 NodeID number_of_edge_based_nodes) const;
 
   private:
-    DuplicatedNodeID AsDuplicatedNodeID(const RestrictionID restriction_id) const;
-
-    // access all restrictions that have the same starting way and via way. Any duplicated node
-    // represents the same in-way + via-way combination. This vector contains data about all
-    // restrictions and their assigned duplicated nodes. It indicates the minimum restriciton ID
-    // that is represented by the next node. The ID of a node is defined as the position of the
-    // lower bound of the restrictions ID within this array
-    //
-    // a - b
-    //     |
-    // y - c - x
-    //
-    // restriction nodes | restriction id
-    // a - b - c - x : 5
-    // a - b - c - y : 6
-    //
-    //                    EBN: 0 . | 2 | 3 | 4 ...
-    // duplicated node groups: ... | 5 | 7 | ...
-    std::vector<DuplicatedNodeID> duplicated_node_groups;
-    std::vector<ConditionalTurnRestriction> restriction_data;
-    RestrictionIndex<ConditionalTurnRestriction> restriction_starts;
+    const RestrictionGraph &restriction_graph;
 };
 
 } // namespace extractor
diff --git a/include/guidance/files.hpp b/include/guidance/files.hpp
index c0d1f54e2..b57e79987 100644
--- a/include/guidance/files.hpp
+++ b/include/guidance/files.hpp
@@ -51,8 +51,8 @@ inline void writeTurnData(const boost::filesystem::path &path,
     writer.WriteFrom("/common/connectivity_checksum", connectivity_checksum);
     serialization::write(writer, "/common/turn_data", turn_data);
 }
-}
-}
-}
+} // namespace files
+} // namespace guidance
+} // namespace osrm
 
 #endif
diff --git a/include/guidance/guidance_processing.hpp b/include/guidance/guidance_processing.hpp
index 9da18abc7..6d2aadf71 100644
--- a/include/guidance/guidance_processing.hpp
+++ b/include/guidance/guidance_processing.hpp
@@ -6,6 +6,7 @@
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/name_table.hpp"
 #include "extractor/node_data_container.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/suffix_table.hpp"
 #include "extractor/turn_lane_types.hpp"
 #include "extractor/way_restriction_map.hpp"
@@ -44,7 +45,7 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
                    EntryClassesMap &entry_class_hash,
                    std::uint32_t &connectivity_checksum);
 
-} // namespace customizer
+} // namespace guidance
 } // namespace osrm
 
 #endif
diff --git a/include/guidance/intersection_handler.hpp b/include/guidance/intersection_handler.hpp
index 2b5cb6671..42221e467 100644
--- a/include/guidance/intersection_handler.hpp
+++ b/include/guidance/intersection_handler.hpp
@@ -172,7 +172,7 @@ inline bool roadHasLowerClass(const util::NodeBasedEdgeData &from_data,
 
     return false;
 }
-}
+} // namespace
 
 template <typename IntersectionType> // works with Intersection and IntersectionView
 inline bool
@@ -213,7 +213,6 @@ IntersectionHandler::IsDistinctNarrowTurn(const EdgeID via_edge,
     // check if there are other narrow turns are not considered passing a low category or simply
     // a link of the same type as the potentially obvious turn
     auto const is_similar_turn = [&](auto const &road) {
-
         // 1. Skip the candidate road
         if (road.eid == candidate->eid)
         {
@@ -409,7 +408,6 @@ IntersectionHandler::IsDistinctWideTurn(const EdgeID via_edge,
     // check if there is any turn, that might look just as obvious, even though it might not
     // be allowed. Entry-allowed isn't considered a valid distinction criterion here
     auto const is_similar_turn = [&](auto const &road) {
-
         // 1. Skip over our candidate
         if (road.eid == candidate->eid)
             return false;
@@ -644,7 +642,7 @@ std::size_t IntersectionHandler::findObviousTurn(const EdgeID via_edge,
     const auto all_roads_have_same_name =
         std::all_of(intersection.begin(),
                     intersection.end(),
-                    [ id = via_edge_annotation.name_id, this ](auto const &road) {
+                    [id = via_edge_annotation.name_id, this](auto const &road) {
                         auto const data_id = node_based_graph.GetEdgeData(road.eid).annotation_data;
                         auto const name_id = node_data_container.GetAnnotation(data_id).name_id;
                         return (name_id != EMPTY_NAMEID) && (name_id == id);
diff --git a/include/guidance/motorway_handler.hpp b/include/guidance/motorway_handler.hpp
index 5ecac8170..05f1c1630 100644
--- a/include/guidance/motorway_handler.hpp
+++ b/include/guidance/motorway_handler.hpp
@@ -18,7 +18,7 @@ namespace guidance
 {
 
 // Intersection handlers deal with all issues related to intersections.
-class MotorwayHandler : public IntersectionHandler
+class MotorwayHandler final : public IntersectionHandler
 {
   public:
     MotorwayHandler(const util::NodeBasedDynamicGraph &node_based_graph,
diff --git a/include/guidance/roundabout_handler.hpp b/include/guidance/roundabout_handler.hpp
index 2d2fe86d0..55def24e8 100644
--- a/include/guidance/roundabout_handler.hpp
+++ b/include/guidance/roundabout_handler.hpp
@@ -35,7 +35,7 @@ struct RoundaboutFlags
 // The roundabout handler processes all roundabout related instructions.
 // It performs both the distinction between rotaries and roundabouts and
 // assigns appropriate entry/exit instructions.
-class RoundaboutHandler : public IntersectionHandler
+class RoundaboutHandler final : public IntersectionHandler
 {
   public:
     RoundaboutHandler(const util::NodeBasedDynamicGraph &node_based_graph,
diff --git a/include/guidance/segregated_intersection_classification.hpp b/include/guidance/segregated_intersection_classification.hpp
index 363192921..d60d8d120 100644
--- a/include/guidance/segregated_intersection_classification.hpp
+++ b/include/guidance/segregated_intersection_classification.hpp
@@ -9,7 +9,7 @@ namespace osrm
 namespace extractor
 {
 class NodeBasedGraphFactory;
-}
+} // namespace extractor
 
 namespace guidance
 {
@@ -20,5 +20,5 @@ namespace guidance
 // - square/circle intersections
 std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFactory &factory,
                                                const extractor::NameTable &names);
-}
-}
+} // namespace guidance
+} // namespace osrm
diff --git a/include/guidance/serialization.hpp b/include/guidance/serialization.hpp
index 6917cb02e..e5cf544ff 100644
--- a/include/guidance/serialization.hpp
+++ b/include/guidance/serialization.hpp
@@ -49,8 +49,8 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(
         writer, name + "/post_turn_bearings", turn_data_container.post_turn_bearings);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace guidance
+} // namespace osrm
 
 #endif
diff --git a/include/guidance/turn_analysis.hpp b/include/guidance/turn_analysis.hpp
index 239b9365f..7a97af725 100644
--- a/include/guidance/turn_analysis.hpp
+++ b/include/guidance/turn_analysis.hpp
@@ -4,7 +4,7 @@
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/intersection/intersection_view.hpp"
 #include "extractor/name_table.hpp"
-#include "extractor/restriction_index.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/suffix_table.hpp"
 
 #include "guidance/driveway_handler.hpp"
diff --git a/include/guidance/turn_bearing.hpp b/include/guidance/turn_bearing.hpp
index ad6e3ac1a..12ba8567c 100644
--- a/include/guidance/turn_bearing.hpp
+++ b/include/guidance/turn_bearing.hpp
@@ -9,15 +9,12 @@ namespace osrm
 {
 namespace guidance
 {
-namespace
-{
-const double bearing_scale = 360.0 / 256.0;
-}
 
 #pragma pack(push, 1)
 class TurnBearing
 {
   public:
+    static constexpr double bearing_scale = 360.0 / 256.0;
     // discretizes a bearing into distinct units of 1.4 degrees
     TurnBearing(const double value = 0) : bearing(value / bearing_scale)
     {
diff --git a/include/guidance/turn_data_container.hpp b/include/guidance/turn_data_container.hpp
index ae4ecc173..de52461a2 100644
--- a/include/guidance/turn_data_container.hpp
+++ b/include/guidance/turn_data_container.hpp
@@ -19,7 +19,7 @@ namespace guidance
 namespace detail
 {
 template <storage::Ownership Ownership> class TurnDataContainerImpl;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -32,7 +32,7 @@ template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const detail::TurnDataContainerImpl<Ownership> &turn_data);
-}
+} // namespace serialization
 
 struct TurnData
 {
@@ -111,12 +111,12 @@ template <storage::Ownership Ownership> class TurnDataContainerImpl
     Vector<TurnBearing> pre_turn_bearings;
     Vector<TurnBearing> post_turn_bearings;
 };
-}
+} // namespace detail
 
 using TurnDataExternalContainer = detail::TurnDataContainerImpl<storage::Ownership::External>;
 using TurnDataContainer = detail::TurnDataContainerImpl<storage::Ownership::Container>;
 using TurnDataView = detail::TurnDataContainerImpl<storage::Ownership::View>;
-}
-}
+} // namespace guidance
+} // namespace osrm
 
 #endif
diff --git a/include/guidance/turn_discovery.hpp b/include/guidance/turn_discovery.hpp
index cff8103ff..52b72f846 100644
--- a/include/guidance/turn_discovery.hpp
+++ b/include/guidance/turn_discovery.hpp
@@ -1,7 +1,7 @@
 #ifndef OSRM_GUIDANCE_TURN_DISCOVERY_HPP_
 #define OSRM_GUIDANCE_TURN_DISCOVERY_HPP_
 
-#include "extractor/restriction_index.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "guidance/intersection.hpp"
 #include "guidance/turn_lane_data.hpp"
 #include "util/typedefs.hpp"
diff --git a/include/guidance/turn_handler.hpp b/include/guidance/turn_handler.hpp
index e50786661..63470f690 100644
--- a/include/guidance/turn_handler.hpp
+++ b/include/guidance/turn_handler.hpp
@@ -23,7 +23,7 @@ namespace guidance
 {
 
 // Intersection handlers deal with all issues related to intersections.
-class TurnHandler : public IntersectionHandler
+class TurnHandler final : public IntersectionHandler
 {
   public:
     TurnHandler(const util::NodeBasedDynamicGraph &node_based_graph,
diff --git a/include/guidance/turn_instruction.hpp b/include/guidance/turn_instruction.hpp
index 82afe8614..685c633e7 100644
--- a/include/guidance/turn_instruction.hpp
+++ b/include/guidance/turn_instruction.hpp
@@ -26,7 +26,7 @@ const constexpr Enum SlightLeft = 5;
 const constexpr Enum Left = 6;
 const constexpr Enum SharpLeft = 7;
 const constexpr Enum MaxDirectionModifier = 8;
-}
+} // namespace DirectionModifier
 
 namespace TurnType
 {
@@ -63,7 +63,7 @@ const constexpr Enum StayOnRoundabout = 25; // Continue on Either a small or a l
 const constexpr Enum Sliproad =
     26; // Something that looks like a ramp, but is actually just a small sliproad
 const constexpr Enum MaxTurnType = 27; // Special value for static asserts
-}
+} // namespace TurnType
 
 struct TurnInstruction
 {
@@ -367,7 +367,7 @@ const constexpr TurnTypeName turn_type_names[] = {
     {"invalid", "(sliproad)"},
     {"MAXVALUE", "MAXVALUE"}};
 
-} // ns detail
+} // namespace detail
 
 inline std::string instructionTypeToString(const TurnType::Enum type)
 {
diff --git a/include/guidance/turn_lane_data.hpp b/include/guidance/turn_lane_data.hpp
index e6a6c83b2..49431d25e 100644
--- a/include/guidance/turn_lane_data.hpp
+++ b/include/guidance/turn_lane_data.hpp
@@ -28,7 +28,7 @@ typedef std::vector<TurnLaneData> LaneDataVector;
 
 // convertes a string given in the OSM format into a TurnLaneData vector
 OSRM_ATTR_WARN_UNUSED
-LaneDataVector laneDataFromDescription(extractor::TurnLaneDescription turn_lane_description);
+LaneDataVector laneDataFromDescription(const extractor::TurnLaneDescription &turn_lane_description);
 
 // Locate A Tag in a lane data vector (if multiple tags are set, the first one found is returned)
 LaneDataVector::const_iterator findTag(const extractor::TurnLaneType::Mask tag,
@@ -37,7 +37,7 @@ LaneDataVector::iterator findTag(const extractor::TurnLaneType::Mask tag, LaneDa
 
 // Returns true if any of the queried tags is contained
 bool hasTag(const extractor::TurnLaneType::Mask tag, const LaneDataVector &data);
-} // namespace lane_data_generation
+} // namespace lanes
 
 } // namespace guidance
 } // namespace osrm
diff --git a/include/guidance/turn_lane_handler.hpp b/include/guidance/turn_lane_handler.hpp
index ad9a759a8..d0344ad5c 100644
--- a/include/guidance/turn_lane_handler.hpp
+++ b/include/guidance/turn_lane_handler.hpp
@@ -34,7 +34,8 @@ namespace lanes
 
 namespace
 {
-typedef enum TurnLaneScenario {
+typedef enum TurnLaneScenario
+{
     SIMPLE,             // a straightforward assignment
     PARTITION_LOCAL,    // an assignment that requires partitioning, using local turns
     SIMPLE_PREVIOUS,    // an assignemtnn using the turns specified at the previous road (e.g.
@@ -51,15 +52,6 @@ typedef enum TurnLaneScenario {
     NUM_SCENARIOS
 } TurnLaneScenario;
 
-const constexpr char *scenario_names[] = {"Simple",
-                                          "Partition Local",
-                                          "Simple Previous",
-                                          "Partition Previous",
-                                          "Sliproad",
-                                          "Merge",
-                                          "None",
-                                          "Invalid",
-                                          "Unknown"};
 } // namespace
 
 class TurnLaneHandler
@@ -149,9 +141,6 @@ class TurnLaneHandler
                          LaneDataVector &lane_data) const;
 };
 
-static_assert(sizeof(scenario_names) / sizeof(*scenario_names) == TurnLaneScenario::NUM_SCENARIOS,
-              "Number of scenarios needs to match the number of scenario names.");
-
 } // namespace lanes
 } // namespace guidance
 } // namespace osrm
diff --git a/include/nodejs/json_v8_renderer.hpp b/include/nodejs/json_v8_renderer.hpp
index ab7c89e42..6e518293c 100644
--- a/include/nodejs/json_v8_renderer.hpp
+++ b/include/nodejs/json_v8_renderer.hpp
@@ -31,7 +31,7 @@ struct V8Renderer
         {
             v8::Local<v8::Value> child;
             mapbox::util::apply_visitor(V8Renderer(child), keyValue.second);
-            obj->Set(Nan::New(keyValue.first).ToLocalChecked(), child);
+            Nan::Set(obj, Nan::New(keyValue.first).ToLocalChecked(), child);
         }
         out = obj;
     }
@@ -43,7 +43,7 @@ struct V8Renderer
         {
             v8::Local<v8::Value> child;
             mapbox::util::apply_visitor(V8Renderer(child), array.values[i]);
-            a->Set(i, child);
+            Nan::Set(a, i, child);
         }
         out = a;
     }
@@ -63,6 +63,6 @@ inline void renderToV8(v8::Local<v8::Value> &out, const osrm::json::Object &obje
     osrm::json::Value value = object;
     mapbox::util::apply_visitor(V8Renderer(out), value);
 }
-}
+} // namespace node_osrm
 
 #endif // JSON_V8_RENDERER_HPP
diff --git a/include/nodejs/node_osrm_support.hpp b/include/nodejs/node_osrm_support.hpp
index 90294a841..400d420a5 100644
--- a/include/nodejs/node_osrm_support.hpp
+++ b/include/nodejs/node_osrm_support.hpp
@@ -130,19 +130,20 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
     BOOST_ASSERT(args[0]->IsObject());
     auto params = Nan::To<v8::Object>(args[0]).ToLocalChecked();
 
-    auto path = params->Get(Nan::New("path").ToLocalChecked());
+    auto path = Nan::Get(params, Nan::New("path").ToLocalChecked()).ToLocalChecked();
     if (path.IsEmpty())
         return engine_config_ptr();
 
-    auto memory_file = params->Get(Nan::New("memory_file").ToLocalChecked());
+    auto memory_file = Nan::Get(params, Nan::New("memory_file").ToLocalChecked()).ToLocalChecked();
     if (memory_file.IsEmpty())
         return engine_config_ptr();
 
-    auto shared_memory = params->Get(Nan::New("shared_memory").ToLocalChecked());
+    auto shared_memory =
+        Nan::Get(params, Nan::New("shared_memory").ToLocalChecked()).ToLocalChecked();
     if (shared_memory.IsEmpty())
         return engine_config_ptr();
 
-    auto mmap_memory = params->Get(Nan::New("mmap_memory").ToLocalChecked());
+    auto mmap_memory = Nan::Get(params, Nan::New("mmap_memory").ToLocalChecked()).ToLocalChecked();
     if (mmap_memory.IsEmpty())
         return engine_config_ptr();
 
@@ -158,7 +159,8 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
             *Nan::Utf8String(Nan::To<v8::String>(memory_file).ToLocalChecked());
     }
 
-    auto dataset_name = params->Get(Nan::New("dataset_name").ToLocalChecked());
+    auto dataset_name =
+        Nan::Get(params, Nan::New("dataset_name").ToLocalChecked()).ToLocalChecked();
     if (dataset_name.IsEmpty())
         return engine_config_ptr();
     if (!dataset_name->IsUndefined())
@@ -214,7 +216,7 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
         return engine_config_ptr();
     }
 
-    auto algorithm = params->Get(Nan::New("algorithm").ToLocalChecked());
+    auto algorithm = Nan::Get(params, Nan::New("algorithm").ToLocalChecked()).ToLocalChecked();
     if (algorithm.IsEmpty())
         return engine_config_ptr();
 
@@ -247,16 +249,21 @@ inline engine_config_ptr argumentsToEngineConfig(const Nan::FunctionCallbackInfo
 
     // Set EngineConfig system-wide limits on construction, if requested
 
-    auto max_locations_trip = params->Get(Nan::New("max_locations_trip").ToLocalChecked());
-    auto max_locations_viaroute = params->Get(Nan::New("max_locations_viaroute").ToLocalChecked());
+    auto max_locations_trip =
+        Nan::Get(params, Nan::New("max_locations_trip").ToLocalChecked()).ToLocalChecked();
+    auto max_locations_viaroute =
+        Nan::Get(params, Nan::New("max_locations_viaroute").ToLocalChecked()).ToLocalChecked();
     auto max_locations_distance_table =
-        params->Get(Nan::New("max_locations_distance_table").ToLocalChecked());
+        Nan::Get(params, Nan::New("max_locations_distance_table").ToLocalChecked())
+            .ToLocalChecked();
     auto max_locations_map_matching =
-        params->Get(Nan::New("max_locations_map_matching").ToLocalChecked());
-    auto max_results_nearest = params->Get(Nan::New("max_results_nearest").ToLocalChecked());
-    auto max_alternatives = params->Get(Nan::New("max_alternatives").ToLocalChecked());
+        Nan::Get(params, Nan::New("max_locations_map_matching").ToLocalChecked()).ToLocalChecked();
+    auto max_results_nearest =
+        Nan::Get(params, Nan::New("max_results_nearest").ToLocalChecked()).ToLocalChecked();
+    auto max_alternatives =
+        Nan::Get(params, Nan::New("max_alternatives").ToLocalChecked()).ToLocalChecked();
     auto max_radius_map_matching =
-        params->Get(Nan::New("max_radius_map_matching").ToLocalChecked());
+        Nan::Get(params, Nan::New("max_radius_map_matching").ToLocalChecked()).ToLocalChecked();
 
     if (!max_locations_trip->IsUndefined() && !max_locations_trip->IsNumber())
     {
@@ -319,7 +326,7 @@ parseCoordinateArray(const v8::Local<v8::Array> &coordinates_array)
 
     for (uint32_t i = 0; i < coordinates_array->Length(); ++i)
     {
-        v8::Local<v8::Value> coordinate = coordinates_array->Get(i);
+        v8::Local<v8::Value> coordinate = Nan::Get(coordinates_array, i).ToLocalChecked();
         if (coordinate.IsEmpty())
             return resulting_coordinates;
 
@@ -336,14 +343,15 @@ parseCoordinateArray(const v8::Local<v8::Array> &coordinates_array)
             return resulting_coordinates;
         }
 
-        if (!coordinate_pair->Get(0)->IsNumber() || !coordinate_pair->Get(1)->IsNumber())
+        if (!Nan::Get(coordinate_pair, 0).ToLocalChecked()->IsNumber() ||
+            !Nan::Get(coordinate_pair, 1).ToLocalChecked()->IsNumber())
         {
             Nan::ThrowError("Each member of a coordinate pair must be a number");
             return resulting_coordinates;
         }
 
-        double lon = Nan::To<double>(coordinate_pair->Get(0)).FromJust();
-        double lat = Nan::To<double>(coordinate_pair->Get(1)).FromJust();
+        double lon = Nan::To<double>(Nan::Get(coordinate_pair, 0).ToLocalChecked()).FromJust();
+        double lat = Nan::To<double>(Nan::Get(coordinate_pair, 1).ToLocalChecked()).FromJust();
 
         if (std::isnan(lon) || std::isnan(lat) || std::isinf(lon) || std::isinf(lat))
         {
@@ -388,7 +396,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     v8::Local<v8::Object> obj = Nan::To<v8::Object>(args[0]).ToLocalChecked();
 
-    v8::Local<v8::Value> coordinates = obj->Get(Nan::New("coordinates").ToLocalChecked());
+    v8::Local<v8::Value> coordinates =
+        Nan::Get(obj, Nan::New("coordinates").ToLocalChecked()).ToLocalChecked();
     if (coordinates.IsEmpty())
         return false;
 
@@ -431,7 +440,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("approaches").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> approaches = obj->Get(Nan::New("approaches").ToLocalChecked());
+        v8::Local<v8::Value> approaches =
+            Nan::Get(obj, Nan::New("approaches").ToLocalChecked()).ToLocalChecked();
         if (approaches.IsEmpty())
             return false;
 
@@ -451,7 +461,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
         for (uint32_t i = 0; i < approaches_array->Length(); ++i)
         {
-            v8::Local<v8::Value> approach_raw = approaches_array->Get(i);
+            v8::Local<v8::Value> approach_raw = Nan::Get(approaches_array, i).ToLocalChecked();
             if (approach_raw.IsEmpty())
                 return false;
 
@@ -488,7 +498,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("bearings").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> bearings = obj->Get(Nan::New("bearings").ToLocalChecked());
+        v8::Local<v8::Value> bearings =
+            Nan::Get(obj, Nan::New("bearings").ToLocalChecked()).ToLocalChecked();
         if (bearings.IsEmpty())
             return false;
 
@@ -508,7 +519,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
         for (uint32_t i = 0; i < bearings_array->Length(); ++i)
         {
-            v8::Local<v8::Value> bearing_raw = bearings_array->Get(i);
+            v8::Local<v8::Value> bearing_raw = Nan::Get(bearings_array, i).ToLocalChecked();
             if (bearing_raw.IsEmpty())
                 return false;
 
@@ -521,14 +532,17 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
                 auto bearing_pair = v8::Local<v8::Array>::Cast(bearing_raw);
                 if (bearing_pair->Length() == 2)
                 {
-                    if (!bearing_pair->Get(0)->IsNumber() || !bearing_pair->Get(1)->IsNumber())
+                    if (!Nan::Get(bearing_pair, 0).ToLocalChecked()->IsNumber() ||
+                        !Nan::Get(bearing_pair, 1).ToLocalChecked()->IsNumber())
                     {
                         Nan::ThrowError("Bearing values need to be numbers in range 0..360");
                         return false;
                     }
 
-                    const auto bearing = Nan::To<int>(bearing_pair->Get(0)).FromJust();
-                    const auto range = Nan::To<int>(bearing_pair->Get(1)).FromJust();
+                    const auto bearing =
+                        Nan::To<int>(Nan::Get(bearing_pair, 0).ToLocalChecked()).FromJust();
+                    const auto range =
+                        Nan::To<int>(Nan::Get(bearing_pair, 1).ToLocalChecked()).FromJust();
 
                     if (bearing < 0 || bearing > 360 || range < 0 || range > 180)
                     {
@@ -555,7 +569,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("hints").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> hints = obj->Get(Nan::New("hints").ToLocalChecked());
+        v8::Local<v8::Value> hints =
+            Nan::Get(obj, Nan::New("hints").ToLocalChecked()).ToLocalChecked();
         if (hints.IsEmpty())
             return false;
 
@@ -575,7 +590,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
         for (uint32_t i = 0; i < hints_array->Length(); ++i)
         {
-            v8::Local<v8::Value> hint = hints_array->Get(i);
+            v8::Local<v8::Value> hint = Nan::Get(hints_array, i).ToLocalChecked();
             if (hint.IsEmpty())
                 return false;
 
@@ -603,7 +618,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("radiuses").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> radiuses = obj->Get(Nan::New("radiuses").ToLocalChecked());
+        v8::Local<v8::Value> radiuses =
+            Nan::Get(obj, Nan::New("radiuses").ToLocalChecked()).ToLocalChecked();
         if (radiuses.IsEmpty())
             return false;
 
@@ -623,7 +639,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
         for (uint32_t i = 0; i < radiuses_array->Length(); ++i)
         {
-            v8::Local<v8::Value> radius = radiuses_array->Get(i);
+            v8::Local<v8::Value> radius = Nan::Get(radiuses_array, i).ToLocalChecked();
             if (radius.IsEmpty())
                 return false;
 
@@ -645,7 +661,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("generate_hints").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> generate_hints = obj->Get(Nan::New("generate_hints").ToLocalChecked());
+        v8::Local<v8::Value> generate_hints =
+            Nan::Get(obj, Nan::New("generate_hints").ToLocalChecked()).ToLocalChecked();
         if (generate_hints.IsEmpty())
             return false;
 
@@ -660,7 +677,8 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
     if (Nan::Has(obj, Nan::New("exclude").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> exclude = obj->Get(Nan::New("exclude").ToLocalChecked());
+        v8::Local<v8::Value> exclude =
+            Nan::Get(obj, Nan::New("exclude").ToLocalChecked()).ToLocalChecked();
         if (exclude.IsEmpty())
             return false;
 
@@ -674,7 +692,7 @@ inline bool argumentsToParameter(const Nan::FunctionCallbackInfo<v8::Value> &arg
 
         for (uint32_t i = 0; i < exclude_array->Length(); ++i)
         {
-            v8::Local<v8::Value> class_name = exclude_array->Get(i);
+            v8::Local<v8::Value> class_name = Nan::Get(exclude_array, i).ToLocalChecked();
             if (class_name.IsEmpty())
                 return false;
 
@@ -699,7 +717,7 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
 {
     if (Nan::Has(obj, Nan::New("steps").ToLocalChecked()).FromJust())
     {
-        auto steps = obj->Get(Nan::New("steps").ToLocalChecked());
+        auto steps = Nan::Get(obj, Nan::New("steps").ToLocalChecked()).ToLocalChecked();
         if (steps.IsEmpty())
             return false;
 
@@ -716,7 +734,7 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
 
     if (Nan::Has(obj, Nan::New("annotations").ToLocalChecked()).FromJust())
     {
-        auto annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
+        auto annotations = Nan::Get(obj, Nan::New("annotations").ToLocalChecked()).ToLocalChecked();
         if (annotations.IsEmpty())
             return false;
 
@@ -729,7 +747,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
             v8::Local<v8::Array> annotations_array = v8::Local<v8::Array>::Cast(annotations);
             for (std::size_t i = 0; i < annotations_array->Length(); i++)
             {
-                const Nan::Utf8String annotations_utf8str(annotations_array->Get(i));
+                const Nan::Utf8String annotations_utf8str(
+                    Nan::Get(annotations_array, i).ToLocalChecked());
                 std::string annotations_str{*annotations_utf8str,
                                             *annotations_utf8str + annotations_utf8str.length()};
 
@@ -779,7 +798,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
 
     if (Nan::Has(obj, Nan::New("geometries").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> geometries = obj->Get(Nan::New("geometries").ToLocalChecked());
+        v8::Local<v8::Value> geometries =
+            Nan::Get(obj, Nan::New("geometries").ToLocalChecked()).ToLocalChecked();
         if (geometries.IsEmpty())
             return false;
 
@@ -813,7 +833,8 @@ inline bool parseCommonParameters(const v8::Local<v8::Object> &obj, ParamType &p
 
     if (Nan::Has(obj, Nan::New("overview").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> overview = obj->Get(Nan::New("overview").ToLocalChecked());
+        v8::Local<v8::Value> overview =
+            Nan::Get(obj, Nan::New("overview").ToLocalChecked()).ToLocalChecked();
         if (overview.IsEmpty())
             return false;
 
@@ -859,7 +880,8 @@ argumentsToPluginParameters(const Nan::FunctionCallbackInfo<v8::Value> &args)
     if (Nan::Has(obj, Nan::New("format").ToLocalChecked()).FromJust())
     {
 
-        v8::Local<v8::Value> format = obj->Get(Nan::New("format").ToLocalChecked());
+        v8::Local<v8::Value> format =
+            Nan::Get(obj, Nan::New("format").ToLocalChecked()).ToLocalChecked();
         if (format.IsEmpty())
         {
             return {};
@@ -905,7 +927,7 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("continue_straight").ToLocalChecked()).FromJust())
     {
-        auto value = obj->Get(Nan::New("continue_straight").ToLocalChecked());
+        auto value = Nan::Get(obj, Nan::New("continue_straight").ToLocalChecked()).ToLocalChecked();
         if (value.IsEmpty())
             return route_parameters_ptr();
 
@@ -922,7 +944,7 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("alternatives").ToLocalChecked()).FromJust())
     {
-        auto value = obj->Get(Nan::New("alternatives").ToLocalChecked());
+        auto value = Nan::Get(obj, Nan::New("alternatives").ToLocalChecked()).ToLocalChecked();
         if (value.IsEmpty())
             return route_parameters_ptr();
 
@@ -945,7 +967,8 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("waypoints").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> waypoints = obj->Get(Nan::New("waypoints").ToLocalChecked());
+        v8::Local<v8::Value> waypoints =
+            Nan::Get(obj, Nan::New("waypoints").ToLocalChecked()).ToLocalChecked();
         if (waypoints.IsEmpty())
             return route_parameters_ptr();
 
@@ -967,9 +990,12 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         auto coords_size = params->coordinates.size();
         auto waypoints_array_size = waypoints_array->Length();
 
-        const auto first_index = Nan::To<std::uint32_t>(waypoints_array->Get(0)).FromJust();
+        const auto first_index =
+            Nan::To<std::uint32_t>(Nan::Get(waypoints_array, 0).ToLocalChecked()).FromJust();
         const auto last_index =
-            Nan::To<std::uint32_t>(waypoints_array->Get(waypoints_array_size - 1)).FromJust();
+            Nan::To<std::uint32_t>(
+                Nan::Get(waypoints_array, waypoints_array_size - 1).ToLocalChecked())
+                .FromJust();
         if (first_index != 0 || last_index != coords_size - 1)
         {
             Nan::ThrowError("First and last waypoints values must correspond to first and last "
@@ -979,7 +1005,7 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
         for (uint32_t i = 0; i < waypoints_array_size; ++i)
         {
-            v8::Local<v8::Value> waypoint_value = waypoints_array->Get(i);
+            v8::Local<v8::Value> waypoint_value = Nan::Get(waypoints_array, i).ToLocalChecked();
             // all elements must be numbers
             if (!waypoint_value->IsNumber())
             {
@@ -1011,7 +1037,8 @@ argumentsToRouteParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("snapping").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> snapping = obj->Get(Nan::New("snapping").ToLocalChecked());
+        v8::Local<v8::Value> snapping =
+            Nan::Get(obj, Nan::New("snapping").ToLocalChecked()).ToLocalChecked();
         if (snapping.IsEmpty())
             return route_parameters_ptr();
 
@@ -1072,9 +1099,9 @@ argumentsToTileParameters(const Nan::FunctionCallbackInfo<v8::Value> &args, bool
         return tile_parameters_ptr();
     }
 
-    v8::Local<v8::Value> x = array->Get(0);
-    v8::Local<v8::Value> y = array->Get(1);
-    v8::Local<v8::Value> z = array->Get(2);
+    v8::Local<v8::Value> x = Nan::Get(array, 0).ToLocalChecked();
+    v8::Local<v8::Value> y = Nan::Get(array, 1).ToLocalChecked();
+    v8::Local<v8::Value> z = Nan::Get(array, 2).ToLocalChecked();
     if (x.IsEmpty() || y.IsEmpty() || z.IsEmpty())
         return tile_parameters_ptr();
 
@@ -1122,7 +1149,8 @@ argumentsToNearestParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("number").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> number = obj->Get(Nan::New("number").ToLocalChecked());
+        v8::Local<v8::Value> number =
+            Nan::Get(obj, Nan::New("number").ToLocalChecked()).ToLocalChecked();
 
         if (!number->IsUint32())
         {
@@ -1161,7 +1189,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("sources").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> sources = obj->Get(Nan::New("sources").ToLocalChecked());
+        v8::Local<v8::Value> sources =
+            Nan::Get(obj, Nan::New("sources").ToLocalChecked()).ToLocalChecked();
         if (sources.IsEmpty())
             return table_parameters_ptr();
 
@@ -1174,17 +1203,16 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         v8::Local<v8::Array> sources_array = v8::Local<v8::Array>::Cast(sources);
         for (uint32_t i = 0; i < sources_array->Length(); ++i)
         {
-            v8::Local<v8::Value> source = sources_array->Get(i);
+            v8::Local<v8::Value> source = Nan::Get(sources_array, i).ToLocalChecked();
             if (source.IsEmpty())
                 return table_parameters_ptr();
 
             if (source->IsUint32())
             {
                 size_t source_value = Nan::To<unsigned>(source).FromJust();
-                if (source_value > params->coordinates.size())
+                if (source_value >= params->coordinates.size())
                 {
-                    Nan::ThrowError(
-                        "Source indices must be less than or equal to the number of coordinates");
+                    Nan::ThrowError("Source indices must be less than the number of coordinates");
                     return table_parameters_ptr();
                 }
 
@@ -1200,7 +1228,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("destinations").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> destinations = obj->Get(Nan::New("destinations").ToLocalChecked());
+        v8::Local<v8::Value> destinations =
+            Nan::Get(obj, Nan::New("destinations").ToLocalChecked()).ToLocalChecked();
         if (destinations.IsEmpty())
             return table_parameters_ptr();
 
@@ -1213,16 +1242,16 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         v8::Local<v8::Array> destinations_array = v8::Local<v8::Array>::Cast(destinations);
         for (uint32_t i = 0; i < destinations_array->Length(); ++i)
         {
-            v8::Local<v8::Value> destination = destinations_array->Get(i);
+            v8::Local<v8::Value> destination = Nan::Get(destinations_array, i).ToLocalChecked();
             if (destination.IsEmpty())
                 return table_parameters_ptr();
 
             if (destination->IsUint32())
             {
                 size_t destination_value = Nan::To<unsigned>(destination).FromJust();
-                if (destination_value > params->coordinates.size())
+                if (destination_value >= params->coordinates.size())
                 {
-                    Nan::ThrowError("Destination indices must be less than or equal to the number "
+                    Nan::ThrowError("Destination indices must be less than the number "
                                     "of coordinates");
                     return table_parameters_ptr();
                 }
@@ -1239,7 +1268,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("annotations").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> annotations = obj->Get(Nan::New("annotations").ToLocalChecked());
+        v8::Local<v8::Value> annotations =
+            Nan::Get(obj, Nan::New("annotations").ToLocalChecked()).ToLocalChecked();
         if (annotations.IsEmpty())
             return table_parameters_ptr();
 
@@ -1255,7 +1285,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         v8::Local<v8::Array> annotations_array = v8::Local<v8::Array>::Cast(annotations);
         for (std::size_t i = 0; i < annotations_array->Length(); ++i)
         {
-            const Nan::Utf8String annotations_utf8str(annotations_array->Get(i));
+            const Nan::Utf8String annotations_utf8str(
+                Nan::Get(annotations_array, i).ToLocalChecked());
             std::string annotations_str{*annotations_utf8str,
                                         *annotations_utf8str + annotations_utf8str.length()};
 
@@ -1279,7 +1310,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("fallback_speed").ToLocalChecked()).FromJust())
     {
-        auto fallback_speed = obj->Get(Nan::New("fallback_speed").ToLocalChecked());
+        auto fallback_speed =
+            Nan::Get(obj, Nan::New("fallback_speed").ToLocalChecked()).ToLocalChecked();
 
         if (!fallback_speed->IsNumber())
         {
@@ -1297,7 +1329,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("fallback_coordinate").ToLocalChecked()).FromJust())
     {
-        auto fallback_coordinate = obj->Get(Nan::New("fallback_coordinate").ToLocalChecked());
+        auto fallback_coordinate =
+            Nan::Get(obj, Nan::New("fallback_coordinate").ToLocalChecked()).ToLocalChecked();
 
         if (!fallback_coordinate->IsString())
         {
@@ -1325,7 +1358,8 @@ argumentsToTableParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("scale_factor").ToLocalChecked()).FromJust())
     {
-        auto scale_factor = obj->Get(Nan::New("scale_factor").ToLocalChecked());
+        auto scale_factor =
+            Nan::Get(obj, Nan::New("scale_factor").ToLocalChecked()).ToLocalChecked();
 
         if (!scale_factor->IsNumber())
         {
@@ -1363,7 +1397,7 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("roundtrip").ToLocalChecked()).FromJust())
     {
-        auto roundtrip = obj->Get(Nan::New("roundtrip").ToLocalChecked());
+        auto roundtrip = Nan::Get(obj, Nan::New("roundtrip").ToLocalChecked()).ToLocalChecked();
         if (roundtrip.IsEmpty())
             return trip_parameters_ptr();
 
@@ -1380,7 +1414,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("source").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> source = obj->Get(Nan::New("source").ToLocalChecked());
+        v8::Local<v8::Value> source =
+            Nan::Get(obj, Nan::New("source").ToLocalChecked()).ToLocalChecked();
         if (source.IsEmpty())
             return trip_parameters_ptr();
 
@@ -1409,7 +1444,8 @@ argumentsToTripParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("destination").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> destination = obj->Get(Nan::New("destination").ToLocalChecked());
+        v8::Local<v8::Value> destination =
+            Nan::Get(obj, Nan::New("destination").ToLocalChecked()).ToLocalChecked();
         if (destination.IsEmpty())
             return trip_parameters_ptr();
 
@@ -1452,7 +1488,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("timestamps").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> timestamps = obj->Get(Nan::New("timestamps").ToLocalChecked());
+        v8::Local<v8::Value> timestamps =
+            Nan::Get(obj, Nan::New("timestamps").ToLocalChecked()).ToLocalChecked();
         if (timestamps.IsEmpty())
             return match_parameters_ptr();
 
@@ -1473,7 +1510,7 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
         for (uint32_t i = 0; i < timestamps_array->Length(); ++i)
         {
-            v8::Local<v8::Value> timestamp = timestamps_array->Get(i);
+            v8::Local<v8::Value> timestamp = Nan::Get(timestamps_array, i).ToLocalChecked();
             if (timestamp.IsEmpty())
                 return match_parameters_ptr();
 
@@ -1488,7 +1525,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("gaps").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> gaps = obj->Get(Nan::New("gaps").ToLocalChecked());
+        v8::Local<v8::Value> gaps =
+            Nan::Get(obj, Nan::New("gaps").ToLocalChecked()).ToLocalChecked();
         if (gaps.IsEmpty())
             return match_parameters_ptr();
 
@@ -1518,7 +1556,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("tidy").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> tidy = obj->Get(Nan::New("tidy").ToLocalChecked());
+        v8::Local<v8::Value> tidy =
+            Nan::Get(obj, Nan::New("tidy").ToLocalChecked()).ToLocalChecked();
         if (tidy.IsEmpty())
             return match_parameters_ptr();
 
@@ -1533,7 +1572,8 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
     if (Nan::Has(obj, Nan::New("waypoints").ToLocalChecked()).FromJust())
     {
-        v8::Local<v8::Value> waypoints = obj->Get(Nan::New("waypoints").ToLocalChecked());
+        v8::Local<v8::Value> waypoints =
+            Nan::Get(obj, Nan::New("waypoints").ToLocalChecked()).ToLocalChecked();
         if (waypoints.IsEmpty())
             return match_parameters_ptr();
 
@@ -1555,9 +1595,12 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
         auto coords_size = params->coordinates.size();
         auto waypoints_array_size = waypoints_array->Length();
 
-        const auto first_index = Nan::To<std::uint32_t>(waypoints_array->Get(0)).FromJust();
+        const auto first_index =
+            Nan::To<std::uint32_t>(Nan::Get(waypoints_array, 0).ToLocalChecked()).FromJust();
         const auto last_index =
-            Nan::To<std::uint32_t>(waypoints_array->Get(waypoints_array_size - 1)).FromJust();
+            Nan::To<std::uint32_t>(
+                Nan::Get(waypoints_array, waypoints_array_size - 1).ToLocalChecked())
+                .FromJust();
         if (first_index != 0 || last_index != coords_size - 1)
         {
             Nan::ThrowError("First and last waypoints values must correspond to first and last "
@@ -1567,7 +1610,7 @@ argumentsToMatchParameter(const Nan::FunctionCallbackInfo<v8::Value> &args,
 
         for (uint32_t i = 0; i < waypoints_array_size; ++i)
         {
-            v8::Local<v8::Value> waypoint_value = waypoints_array->Get(i);
+            v8::Local<v8::Value> waypoint_value = Nan::Get(waypoints_array, i).ToLocalChecked();
             // all elements must be numbers
             if (!waypoint_value->IsNumber())
             {
diff --git a/include/osrm/contractor.hpp b/include/osrm/contractor.hpp
index 9e6b67261..e6b1cafdd 100644
--- a/include/osrm/contractor.hpp
+++ b/include/osrm/contractor.hpp
@@ -34,7 +34,7 @@ namespace contractor
 {
 struct ContractorConfig;
 
-} // ns contractor
+} // namespace contractor
 
 /**
  * Runs contraction hierarchy computation process.
@@ -45,6 +45,6 @@ struct ContractorConfig;
  */
 void contract(const contractor::ContractorConfig &config);
 
-} // ns osrm
+} // namespace osrm
 
 #endif // OSRM_CONTRACTOR_HPP
diff --git a/include/osrm/coordinate.hpp b/include/osrm/coordinate.hpp
index 124fa34bc..37bcbdd87 100644
--- a/include/osrm/coordinate.hpp
+++ b/include/osrm/coordinate.hpp
@@ -39,6 +39,6 @@ using util::FloatLatitude;
 using util::FloatLongitude;
 using util::toFixed;
 using util::toFloating;
-}
+} // namespace osrm
 
 #endif
diff --git a/include/osrm/customizer.hpp b/include/osrm/customizer.hpp
index f086d2dce..d810aa60e 100644
--- a/include/osrm/customizer.hpp
+++ b/include/osrm/customizer.hpp
@@ -34,7 +34,7 @@ namespace osrm
 namespace customizer
 {
 struct CustomizationConfig;
-} // ns customizer
+} // namespace customizer
 
 /**
  * Runs customize pipeline stage.
@@ -45,6 +45,6 @@ struct CustomizationConfig;
  */
 void customize(const customizer::CustomizationConfig &config);
 
-} // ns osrm
+} // namespace osrm
 
 #endif // OSRM_CUSTOMIZER_HPP
diff --git a/include/osrm/error_codes.hpp b/include/osrm/error_codes.hpp
index 0891cc7bc..531966fd5 100644
--- a/include/osrm/error_codes.hpp
+++ b/include/osrm/error_codes.hpp
@@ -32,6 +32,6 @@ enum ErrorCode
     __ENDMARKER__
 #endif
 };
-}
+} // namespace osrm
 
 #endif // OSRM_ERRORCODES_HPP
\ No newline at end of file
diff --git a/include/osrm/exception.hpp b/include/osrm/exception.hpp
index ab0c7dfd7..97368d855 100644
--- a/include/osrm/exception.hpp
+++ b/include/osrm/exception.hpp
@@ -32,8 +32,8 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace osrm
 {
-using util::RuntimeError;
 using util::exception;
-}
+using util::RuntimeError;
+} // namespace osrm
 
 #endif
diff --git a/include/osrm/extractor.hpp b/include/osrm/extractor.hpp
index a598980b0..c7743f1b0 100644
--- a/include/osrm/extractor.hpp
+++ b/include/osrm/extractor.hpp
@@ -34,7 +34,7 @@ namespace extractor
 {
 struct ExtractorConfig;
 
-} // ns contractor
+} // namespace extractor
 
 /**
  * Runs extraction process.
@@ -45,6 +45,6 @@ struct ExtractorConfig;
  */
 void extract(const extractor::ExtractorConfig &config);
 
-} // ns osrm
+} // namespace osrm
 
 #endif // OSRM_EXTRACTOR_HPP
diff --git a/include/osrm/osrm.hpp b/include/osrm/osrm.hpp
index 74c73f7dd..557dfe2c6 100644
--- a/include/osrm/osrm.hpp
+++ b/include/osrm/osrm.hpp
@@ -84,7 +84,8 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, RouteParameters and json::Object
      */
-    Status Route(const RouteParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Route(const RouteParameters &parameters, json::Object &result) const;
+    Status Route(const RouteParameters &parameters, engine::api::ResultT &result) const;
 
     /**
      * Distance tables for coordinates.
@@ -93,7 +94,8 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, TableParameters and json::Object
      */
-    Status Table(const TableParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Table(const TableParameters &parameters, json::Object &result) const;
+    Status Table(const TableParameters &parameters, engine::api::ResultT &result) const;
 
     /**
      * Nearest street segment for coordinate.
@@ -102,7 +104,8 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, NearestParameters and json::Object
      */
-    Status Nearest(const NearestParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Nearest(const NearestParameters &parameters, json::Object &result) const;
+    Status Nearest(const NearestParameters &parameters, engine::api::ResultT &result) const;
 
     /**
      * Trip: shortest round trip between coordinates.
@@ -111,7 +114,8 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, TripParameters and json::Object
      */
-    Status Trip(const TripParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Trip(const TripParameters &parameters, json::Object &result) const;
+    Status Trip(const TripParameters &parameters, engine::api::ResultT &result) const;
 
     /**
      * Match: snaps noisy coordinate traces to the road network
@@ -120,7 +124,8 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, MatchParameters and json::Object
      */
-    Status Match(const MatchParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Match(const MatchParameters &parameters, json::Object &result) const;
+    Status Match(const MatchParameters &parameters, engine::api::ResultT &result) const;
 
     /**
      * Tile: vector tiles with internal graph representation
@@ -129,11 +134,12 @@ class OSRM final
      * \return Status indicating success for the query or failure
      * \see Status, TileParameters and json::Object
      */
-    Status Tile(const TileParameters &parameters, osrm::engine::api::ResultT &result) const;
+    Status Tile(const TileParameters &parameters, std::string &result) const;
+    Status Tile(const TileParameters &parameters, engine::api::ResultT &result) const;
 
   private:
     std::unique_ptr<engine::EngineInterface> engine_;
 };
-}
+} // namespace osrm
 
 #endif // OSRM_HPP
diff --git a/include/osrm/osrm_fwd.hpp b/include/osrm/osrm_fwd.hpp
index a232390d0..e1b0ee772 100644
--- a/include/osrm/osrm_fwd.hpp
+++ b/include/osrm/osrm_fwd.hpp
@@ -39,8 +39,8 @@ namespace util
 namespace json
 {
 struct Object;
-} // ns json
-} // ns util
+} // namespace json
+} // namespace util
 
 namespace engine
 {
@@ -52,11 +52,11 @@ struct NearestParameters;
 struct TripParameters;
 struct MatchParameters;
 struct TileParameters;
-} // ns api
+} // namespace api
 
 class EngineInterface;
 struct EngineConfig;
-} // ns engine
-} // ns osrm
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/include/osrm/partitioner.hpp b/include/osrm/partitioner.hpp
index 429e4a588..e9a91db8d 100644
--- a/include/osrm/partitioner.hpp
+++ b/include/osrm/partitioner.hpp
@@ -34,7 +34,7 @@ namespace osrm
 namespace partitioner
 {
 struct PartitionerConfig;
-} // ns partition
+} // namespace partitioner
 
 /**
  * Runs recursive partitioning process.
@@ -45,6 +45,6 @@ struct PartitionerConfig;
  */
 void partition(const partitioner::PartitionerConfig &config);
 
-} // ns osrm
+} // namespace osrm
 
 #endif // OSRM_PARTITIONER_HPP
diff --git a/include/partitioner/bisection_graph.hpp b/include/partitioner/bisection_graph.hpp
index bc2bd44ca..f0a5d62ff 100644
--- a/include/partitioner/bisection_graph.hpp
+++ b/include/partitioner/bisection_graph.hpp
@@ -77,8 +77,9 @@ inline BisectionGraph makeBisectionGraph(const std::vector<util::Coordinate> &co
     };
 
     // create a bisection node, requires the ID of the node as well as the lower bound to its edges
-    const auto make_bisection_node = [&edges, &coordinates](
-        const std::size_t node_id, const auto begin_itr, const auto end_itr) {
+    const auto make_bisection_node = [&edges, &coordinates](const std::size_t node_id,
+                                                            const auto begin_itr,
+                                                            const auto end_itr) {
         std::size_t range_begin = std::distance(edges.begin(), begin_itr);
         std::size_t range_end = std::distance(edges.begin(), end_itr);
         return BisectionGraph::NodeT(range_begin, range_end, coordinates[node_id], node_id);
diff --git a/include/partitioner/bisection_to_partition.hpp b/include/partitioner/bisection_to_partition.hpp
index 14186f3c4..03a37f19b 100644
--- a/include/partitioner/bisection_to_partition.hpp
+++ b/include/partitioner/bisection_to_partition.hpp
@@ -17,7 +17,7 @@ using Partition = std::vector<CellID>;
 std::tuple<std::vector<Partition>, std::vector<std::uint32_t>>
 bisectionToPartition(const std::vector<BisectionID> &node_to_bisection_id,
                      const std::vector<std::size_t> &max_cell_sizes);
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/cell_statistics.hpp b/include/partitioner/cell_statistics.hpp
index cf8dfd0f8..17b750e79 100644
--- a/include/partitioner/cell_statistics.hpp
+++ b/include/partitioner/cell_statistics.hpp
@@ -48,7 +48,7 @@ void printCellStatistics(const Partition &partition, const CellStorage &storage)
                     << (2 * entries * sizeof(EdgeWeight)) << " bytes)";
     }
 }
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/cell_storage.hpp b/include/partitioner/cell_storage.hpp
index b28393319..c2331f316 100644
--- a/include/partitioner/cell_storage.hpp
+++ b/include/partitioner/cell_storage.hpp
@@ -45,18 +45,16 @@ template <storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::CellStorageImpl<Ownership> &storage);
-}
+} // namespace serialization
 
 namespace detail
 {
 template <storage::Ownership Ownership> class CellStorageImpl
 {
   public:
-    using ValueOffset = std::uint32_t;
-    using BoundaryOffset = std::uint32_t;
+    using ValueOffset = std::uint64_t;
+    using BoundaryOffset = std::uint64_t;
     using BoundarySize = std::uint32_t;
-    using SourceIndex = std::uint32_t;
-    using DestinationIndex = std::uint32_t;
 
     static constexpr auto INVALID_VALUE_OFFSET = std::numeric_limits<ValueOffset>::max();
     static constexpr auto INVALID_BOUNDARY_OFFSET = std::numeric_limits<BoundaryOffset>::max();
@@ -102,10 +100,9 @@ template <storage::Ownership Ownership> class CellStorageImpl
         {
 
             using ValueT = decltype(*std::declval<ValuePtrT>());
-            typedef boost::iterator_facade<ColumnIterator<ValueT>,
-                                           ValueT,
-                                           boost::random_access_traversal_tag>
-                base_t;
+            typedef boost::
+                iterator_facade<ColumnIterator<ValueT>, ValueT, boost::random_access_traversal_tag>
+                    base_t;
 
           public:
             typedef typename base_t::value_type value_type;
@@ -195,10 +192,10 @@ template <storage::Ownership Ownership> class CellStorageImpl
                  const NodeID *const all_sources,
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
-              num_destination_nodes{data.num_destination_nodes},
-              weights{all_weights + data.value_offset},
-              durations{all_durations + data.value_offset},
-              distances{all_distances + data.value_offset},
+              num_destination_nodes{data.num_destination_nodes}, weights{all_weights +
+                                                                         data.value_offset},
+              durations{all_durations + data.value_offset}, distances{all_distances +
+                                                                      data.value_offset},
               source_boundary{all_sources + data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
@@ -216,8 +213,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
               num_destination_nodes{data.num_destination_nodes}, weights{nullptr},
-              durations{nullptr}, distances{nullptr},
-              source_boundary{all_sources + data.source_boundary_offset},
+              durations{nullptr}, distances{nullptr}, source_boundary{all_sources +
+                                                                      data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
             BOOST_ASSERT(num_source_nodes == 0 || all_sources != nullptr);
@@ -451,8 +448,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
     Vector<CellData> cells;
     Vector<std::uint64_t> level_to_cell_offset;
 };
-}
-}
-}
+} // namespace detail
+} // namespace partitioner
+} // namespace osrm
 
 #endif // OSRM_PARTITIONER_CUSTOMIZE_CELL_STORAGE_HPP
diff --git a/include/partitioner/edge_based_graph.hpp b/include/partitioner/edge_based_graph.hpp
index f39fb2732..a0f6e1986 100644
--- a/include/partitioner/edge_based_graph.hpp
+++ b/include/partitioner/edge_based_graph.hpp
@@ -53,7 +53,7 @@ struct DynamicEdgeBasedGraphEdge : DynamicEdgeBasedGraph::InputEdge
     using Base = DynamicEdgeBasedGraph::InputEdge;
     using Base::Base;
 };
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/edge_based_graph_reader.hpp b/include/partitioner/edge_based_graph_reader.hpp
index bc5ba8b96..0c5d01b70 100644
--- a/include/partitioner/edge_based_graph_reader.hpp
+++ b/include/partitioner/edge_based_graph_reader.hpp
@@ -143,22 +143,22 @@ inline std::vector<extractor::EdgeBasedEdge>
 graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
 {
     auto range = tbb::blocked_range<NodeID>(0, edge_based_graph.GetNumberOfNodes());
-    auto max_turn_id =
-        tbb::parallel_reduce(range,
-                             NodeID{0},
-                             [&edge_based_graph](const auto range, NodeID initial) {
-                                 NodeID max_turn_id = initial;
-                                 for (auto node = range.begin(); node < range.end(); ++node)
-                                 {
-                                     for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
-                                     {
-                                         const auto &data = edge_based_graph.GetEdgeData(edge);
-                                         max_turn_id = std::max(max_turn_id, data.turn_id);
-                                     }
-                                 }
-                                 return max_turn_id;
-                             },
-                             [](const NodeID lhs, const NodeID rhs) { return std::max(lhs, rhs); });
+    auto max_turn_id = tbb::parallel_reduce(
+        range,
+        NodeID{0},
+        [&edge_based_graph](const auto range, NodeID initial) {
+            NodeID max_turn_id = initial;
+            for (auto node = range.begin(); node < range.end(); ++node)
+            {
+                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
+                {
+                    const auto &data = edge_based_graph.GetEdgeData(edge);
+                    max_turn_id = std::max(max_turn_id, data.turn_id);
+                }
+            }
+            return max_turn_id;
+        },
+        [](const NodeID lhs, const NodeID rhs) { return std::max(lhs, rhs); });
 
     std::vector<extractor::EdgeBasedEdge> edges(max_turn_id + 1);
     tbb::parallel_for(range, [&](const auto range) {
@@ -198,7 +198,7 @@ inline DynamicEdgeBasedGraph LoadEdgeBasedGraph(const boost::filesystem::path &p
     return DynamicEdgeBasedGraph(number_of_edge_based_nodes, std::move(tidied), checksum);
 }
 
-} // ns partition
-} // ns osrm
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/files.hpp b/include/partitioner/files.hpp
index 30bd2942d..fe96d5c50 100644
--- a/include/partitioner/files.hpp
+++ b/include/partitioner/files.hpp
@@ -96,8 +96,8 @@ inline void writeGraph(const boost::filesystem::path &path,
     writer.WriteFrom("/mld/connectivity_checksum", connectivity_checksum);
     serialization::write(writer, "/mld/multilevelgraph", graph);
 }
-}
-}
-}
+} // namespace files
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/multi_level_graph.hpp b/include/partitioner/multi_level_graph.hpp
index 2d5635790..48a9c3ae4 100644
--- a/include/partitioner/multi_level_graph.hpp
+++ b/include/partitioner/multi_level_graph.hpp
@@ -33,7 +33,7 @@ template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const MultiLevelGraph<EdgeDataT, Ownership> &graph);
-}
+} // namespace serialization
 
 template <typename EdgeDataT, storage::Ownership Ownership>
 class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
@@ -236,7 +236,7 @@ class MultiLevelGraph : public util::StaticGraph<EdgeDataT, Ownership>
 
 using MultiLevelEdgeBasedGraph =
     MultiLevelGraph<EdgeBasedGraphEdgeData, storage::Ownership::Container>;
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/multi_level_partition.hpp b/include/partitioner/multi_level_partition.hpp
index 28f21fd4c..bbe0978d6 100644
--- a/include/partitioner/multi_level_partition.hpp
+++ b/include/partitioner/multi_level_partition.hpp
@@ -27,7 +27,7 @@ namespace partitioner
 namespace detail
 {
 template <storage::Ownership Ownership> class MultiLevelPartitionImpl;
-}
+} // namespace detail
 using MultiLevelPartition = detail::MultiLevelPartitionImpl<storage::Ownership::Container>;
 using MultiLevelPartitionView = detail::MultiLevelPartitionImpl<storage::Ownership::View>;
 
@@ -41,7 +41,7 @@ template <storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const detail::MultiLevelPartitionImpl<Ownership> &mlp);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -164,11 +164,11 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
     // of cell ids efficiently.
     inline NodeID GetSentinelNode() const { return partition.size() - 1; }
 
-    void SetCellID(LevelID l, NodeID node, std::size_t cell_id)
+    void SetCellID(LevelID l, NodeID node, CellID cell_id)
     {
         auto lidx = LevelIDToIndex(l);
 
-        auto shifted_id = cell_id << level_data->lidx_to_offset[lidx];
+        auto shifted_id = static_cast<std::uint64_t>(cell_id) << level_data->lidx_to_offset[lidx];
         auto cleared_cell = partition[node] & ~level_data->lidx_to_mask[lidx];
         partition[node] = cleared_cell | shifted_id;
     }
@@ -186,11 +186,12 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
             auto bits = static_cast<std::uint64_t>(std::ceil(std::log2(num_cells + 1)));
             offsets[lidx++] = sum_bits;
             sum_bits += bits;
-            if (sum_bits > 64)
+            if (sum_bits > NUM_PARTITION_BITS)
             {
                 throw util::exception(
                     "Can't pack the partition information at level " + std::to_string(lidx) +
-                    " into a 64bit integer. Would require " + std::to_string(sum_bits) + " bits.");
+                    " into a " + std::to_string(NUM_PARTITION_BITS) +
+                    "bit integer. Would require " + std::to_string(sum_bits) + " bits.");
             }
         }
         // sentinel
@@ -211,11 +212,15 @@ template <storage::Ownership Ownership> class MultiLevelPartitionImpl final
                             [&](const auto offset, const auto next_offset) {
                                 // create mask that has `bits` ones at its LSBs.
                                 // 000011
-                                BOOST_ASSERT(offset < NUM_PARTITION_BITS);
-                                PartitionID mask = (1UL << offset) - 1UL;
+                                BOOST_ASSERT(offset <= NUM_PARTITION_BITS);
+                                PartitionID mask = (1ULL << offset) - 1ULL;
                                 // 001111
-                                BOOST_ASSERT(next_offset < NUM_PARTITION_BITS);
-                                PartitionID next_mask = (1UL << next_offset) - 1UL;
+                                BOOST_ASSERT(next_offset <= NUM_PARTITION_BITS);
+                                // Check offset for shift overflow. Offsets are strictly increasing,
+                                // so we only need the check on the last mask.
+                                PartitionID next_mask = next_offset == NUM_PARTITION_BITS
+                                                            ? -1ULL
+                                                            : (1ULL << next_offset) - 1ULL;
                                 // 001100
                                 masks[lidx++] = next_mask ^ mask;
                             });
@@ -338,8 +343,8 @@ inline MultiLevelPartitionImpl<storage::Ownership::View>::MultiLevelPartitionImp
     : level_data(nullptr)
 {
 }
-}
-}
-}
+} // namespace detail
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/partitioner_config.hpp b/include/partitioner/partitioner_config.hpp
index 04809dff4..01189b780 100644
--- a/include/partitioner/partitioner_config.hpp
+++ b/include/partitioner/partitioner_config.hpp
@@ -44,7 +44,7 @@ struct PartitionerConfig final : storage::IOConfig
     std::size_t small_component_size;
     std::vector<std::size_t> max_cell_sizes;
 };
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif // OSRM_PARTITIONER_CONFIG_HPP
diff --git a/include/partitioner/remove_unconnected.hpp b/include/partitioner/remove_unconnected.hpp
index 7e6ac9679..2e379fa71 100644
--- a/include/partitioner/remove_unconnected.hpp
+++ b/include/partitioner/remove_unconnected.hpp
@@ -109,7 +109,7 @@ std::size_t removeUnconnectedBoundaryNodes(const GraphT &edge_based_graph,
 
     return num_unconnected;
 }
-}
-}
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/reorder_first_last.hpp b/include/partitioner/reorder_first_last.hpp
index 231509db0..da2d04157 100644
--- a/include/partitioner/reorder_first_last.hpp
+++ b/include/partitioner/reorder_first_last.hpp
@@ -49,7 +49,7 @@ void reorderFirstLast(RandomAccessRange &rng, std::size_t n, Compare comp)
     return reorderFirstLast(begin(rng), end(rng), n, comp);
 }
 
-} // ns partition
-} // ns osrm
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/partitioner/serialization.hpp b/include/partitioner/serialization.hpp
index 6f43c02ea..55e105102 100644
--- a/include/partitioner/serialization.hpp
+++ b/include/partitioner/serialization.hpp
@@ -65,8 +65,8 @@ inline void write(storage::tar::FileWriter &writer,
     storage::serialization::write(
         writer, name + "/level_to_cell_offset", storage.level_to_cell_offset);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace partitioner
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp
index 31bc4a717..7d24f909b 100644
--- a/include/server/api/base_parameters_grammar.hpp
+++ b/include/server/api/base_parameters_grammar.hpp
@@ -25,18 +25,20 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename T, char... Fmt> struct no_trailing_dot_policy : qi::real_policies<T>
 {
     template <typename Iterator> static bool parse_dot(Iterator &first, Iterator const &last)
     {
-        if (first == last || *first != '.')
+        auto diff = std::distance(first, last);
+        if (diff <= 0 || *first != '.')
             return false;
 
         static const constexpr char fmt[sizeof...(Fmt)] = {Fmt...};
 
-        if (first + sizeof(fmt) < last && std::equal(fmt, fmt + sizeof(fmt), first + 1u))
+        if (sizeof(fmt) < static_cast<size_t>(diff) &&
+            std::equal(fmt, fmt + sizeof(fmt), first + 1u))
             return false;
 
         ++first;
@@ -225,8 +227,8 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
     qi::symbols<char, engine::Approach> approach_type;
     qi::symbols<char, engine::api::BaseParameters::SnappingType> snapping_type;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/match_parameter_grammar.hpp b/include/server/api/match_parameter_grammar.hpp
index 42915fe1b..9893b01db 100644
--- a/include/server/api/match_parameter_grammar.hpp
+++ b/include/server/api/match_parameter_grammar.hpp
@@ -18,7 +18,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::MatchParameters &)>
@@ -62,8 +62,8 @@ struct MatchParametersGrammar final : public RouteParametersGrammar<Iterator, Si
 
     qi::symbols<char, engine::api::MatchParameters::GapsType> gaps_type;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/nearest_parameter_grammar.hpp b/include/server/api/nearest_parameter_grammar.hpp
index 5a6c298c9..8327a9503 100644
--- a/include/server/api/nearest_parameter_grammar.hpp
+++ b/include/server/api/nearest_parameter_grammar.hpp
@@ -18,7 +18,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::NearestParameters &)>
@@ -40,8 +40,8 @@ struct NearestParametersGrammar final : public BaseParametersGrammar<Iterator, S
     qi::rule<Iterator, Signature> root_rule;
     qi::rule<Iterator, Signature> nearest_rule;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/parameters_parser.hpp b/include/server/api/parameters_parser.hpp
index 08083edb5..05e257b53 100644
--- a/include/server/api/parameters_parser.hpp
+++ b/include/server/api/parameters_parser.hpp
@@ -25,7 +25,7 @@ using is_parameter_t =
     std::integral_constant<bool,
                            std::is_base_of<engine::api::BaseParameters, T>::value ||
                                std::is_same<engine::api::TileParameters, T>::value>;
-} // ns detail
+} // namespace detail
 
 // Starts parsing and iter and modifies it until iter == end or parsing failed
 template <typename ParameterT,
@@ -43,8 +43,8 @@ boost::optional<ParameterT> parseParameters(std::string options_string)
     return parseParameters<ParameterT>(first, last);
 }
 
-} // ns api
-} // ns server
-} // ns osrm
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/parsed_url.hpp b/include/server/api/parsed_url.hpp
index 0fefc65db..b4abf49c5 100644
--- a/include/server/api/parsed_url.hpp
+++ b/include/server/api/parsed_url.hpp
@@ -22,8 +22,8 @@ struct ParsedURL final
     std::size_t prefix_length;
 };
 
-} // api
-} // server
-} // osrm
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/route_parameters_grammar.hpp b/include/server/api/route_parameters_grammar.hpp
index 71beb971a..df5fb52df 100644
--- a/include/server/api/route_parameters_grammar.hpp
+++ b/include/server/api/route_parameters_grammar.hpp
@@ -18,7 +18,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::RouteParameters &)>
@@ -113,8 +113,8 @@ struct RouteParametersGrammar : public BaseParametersGrammar<Iterator, Signature
     qi::symbols<char, engine::api::RouteParameters::OverviewType> overview_type;
     qi::symbols<char, engine::api::RouteParameters::AnnotationsType> annotations_type;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/table_parameter_grammar.hpp b/include/server/api/table_parameter_grammar.hpp
index 7734621aa..c88f85299 100644
--- a/include/server/api/table_parameter_grammar.hpp
+++ b/include/server/api/table_parameter_grammar.hpp
@@ -18,7 +18,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::TableParameters &)>
@@ -106,8 +106,8 @@ struct TableParametersGrammar : public BaseParametersGrammar<Iterator, Signature
         fallback_coordinate_type;
     qi::real_parser<double, json_policy> double_;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/tile_parameter_grammar.hpp b/include/server/api/tile_parameter_grammar.hpp
index 42e958400..8c22b3837 100644
--- a/include/server/api/tile_parameter_grammar.hpp
+++ b/include/server/api/tile_parameter_grammar.hpp
@@ -22,7 +22,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::TileParameters &)>
@@ -40,8 +40,8 @@ struct TileParametersGrammar final : boost::spirit::qi::grammar<Iterator, Signat
   private:
     qi::rule<Iterator, Signature> root_rule;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/trip_parameter_grammar.hpp b/include/server/api/trip_parameter_grammar.hpp
index 28cf98458..ecb14db50 100644
--- a/include/server/api/trip_parameter_grammar.hpp
+++ b/include/server/api/trip_parameter_grammar.hpp
@@ -18,7 +18,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator = std::string::iterator,
           typename Signature = void(engine::api::TripParameters &)>
@@ -60,8 +60,8 @@ struct TripParametersGrammar final : public RouteParametersGrammar<Iterator, Sig
     qi::symbols<char, engine::api::TripParameters::SourceType> source_type;
     qi::symbols<char, engine::api::TripParameters::DestinationType> destination_type;
 };
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/api/url_parser.hpp b/include/server/api/url_parser.hpp
index 5fcca36d1..35a3e0a60 100644
--- a/include/server/api/url_parser.hpp
+++ b/include/server/api/url_parser.hpp
@@ -22,8 +22,8 @@ inline boost::optional<ParsedURL> parseURL(std::string url_string)
     auto iter = url_string.begin();
     return parseURL(iter, url_string.end());
 }
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/connection.hpp b/include/server/connection.hpp
index 0680735f0..100872989 100644
--- a/include/server/connection.hpp
+++ b/include/server/connection.hpp
@@ -4,14 +4,15 @@
 #include "server/http/compression_type.hpp"
 #include "server/http/reply.hpp"
 #include "server/http/request.hpp"
-#include "server/request_parser.hpp"
-
 #include <boost/array.hpp>
 #include <boost/asio.hpp>
+#include <boost/beast/core.hpp>
+#include <boost/beast/http.hpp>
 #include <boost/config.hpp>
 #include <boost/version.hpp>
 
 #include <memory>
+#include <optional>
 #include <vector>
 
 // workaround for incomplete std::shared_ptr compatibility in old boost versions
@@ -37,7 +38,7 @@ class RequestHandler;
 class Connection : public std::enable_shared_from_this<Connection>
 {
   public:
-    explicit Connection(boost::asio::io_service &io_service, RequestHandler &handler);
+    explicit Connection(boost::asio::io_context &io_context, RequestHandler &handler);
     Connection(const Connection &) = delete;
     Connection &operator=(const Connection &) = delete;
 
@@ -47,6 +48,7 @@ class Connection : public std::enable_shared_from_this<Connection>
     void start();
 
   private:
+    using RequestParser = boost::beast::http::request_parser<boost::beast::http::string_body>;
     void handle_read(const boost::system::error_code &e, std::size_t bytes_transferred);
 
     /// Handle completion of a write operation.
@@ -60,11 +62,13 @@ class Connection : public std::enable_shared_from_this<Connection>
     std::vector<char> compress_buffers(const std::vector<char> &uncompressed_data,
                                        const http::compression_type compression_type);
 
-    boost::asio::io_service::strand strand;
+    void fill_request(const RequestParser::value_type &httpMessage, http::request &request);
+
+    boost::asio::strand<boost::asio::io_context::executor_type> strand;
     boost::asio::ip::tcp::socket TCP_socket;
     boost::asio::deadline_timer timer;
     RequestHandler &request_handler;
-    RequestParser request_parser;
+    std::optional<RequestParser> http_request_parser;
     boost::array<char, 8192> incoming_data_buffer;
     http::request current_request;
     http::reply current_reply;
@@ -76,7 +80,7 @@ class Connection : public std::enable_shared_from_this<Connection>
     short processed_requests = 512;
     short keepalive_timeout = 5; // In seconds
 };
-}
-}
+} // namespace server
+} // namespace osrm
 
 #endif // CONNECTION_HPP
diff --git a/include/server/http/compression_type.hpp b/include/server/http/compression_type.hpp
index 7ff929c0e..620ca5859 100644
--- a/include/server/http/compression_type.hpp
+++ b/include/server/http/compression_type.hpp
@@ -15,7 +15,7 @@ enum compression_type
     deflate_rfc1951
 };
 }
-}
-}
+} // namespace server
+} // namespace osrm
 
 #endif // COMPRESSION_TYPE_HPP
diff --git a/include/server/http/header.hpp b/include/server/http/header.hpp
index 48111a9c8..8ceb5ae9e 100644
--- a/include/server/http/header.hpp
+++ b/include/server/http/header.hpp
@@ -27,8 +27,8 @@ struct header
     std::string name;
     std::string value;
 };
-}
-}
-}
+} // namespace http
+} // namespace server
+} // namespace osrm
 
 #endif // HEADER_HPP
diff --git a/include/server/http/reply.hpp b/include/server/http/reply.hpp
index 8474a5c2d..a7b444691 100644
--- a/include/server/http/reply.hpp
+++ b/include/server/http/reply.hpp
@@ -38,8 +38,8 @@ class reply
     std::string status_to_string(reply::status_type status);
     boost::asio::const_buffer status_to_buffer(reply::status_type status);
 };
-}
-}
-}
+} // namespace http
+} // namespace server
+} // namespace osrm
 
 #endif // REPLY_HPP
diff --git a/include/server/http/request.hpp b/include/server/http/request.hpp
index e5d867c23..69830ec0d 100644
--- a/include/server/http/request.hpp
+++ b/include/server/http/request.hpp
@@ -20,8 +20,8 @@ struct request
     std::string connection;
     boost::asio::ip::address endpoint;
 };
-}
-}
-}
+} // namespace http
+} // namespace server
+} // namespace osrm
 
 #endif // REQUEST_HPP
diff --git a/include/server/request_handler.hpp b/include/server/request_handler.hpp
index d83d088e4..e1c47fced 100644
--- a/include/server/request_handler.hpp
+++ b/include/server/request_handler.hpp
@@ -14,7 +14,7 @@ namespace http
 {
 class reply;
 struct request;
-}
+} // namespace http
 
 class RequestHandler
 {
@@ -31,7 +31,7 @@ class RequestHandler
   private:
     std::unique_ptr<ServiceHandlerInterface> service_handler;
 };
-}
-}
+} // namespace server
+} // namespace osrm
 
 #endif // REQUEST_HANDLER_HPP
diff --git a/include/server/request_parser.hpp b/include/server/request_parser.hpp
deleted file mode 100644
index 6d9093d7d..000000000
--- a/include/server/request_parser.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-#ifndef REQUEST_PARSER_HPP
-#define REQUEST_PARSER_HPP
-
-#include "server/http/compression_type.hpp"
-#include "server/http/header.hpp"
-
-#include <tuple>
-
-namespace osrm
-{
-namespace server
-{
-
-namespace http
-{
-struct request;
-}
-
-class RequestParser
-{
-  public:
-    RequestParser();
-
-    enum class RequestStatus : char
-    {
-        valid,
-        invalid,
-        indeterminate
-    };
-
-    std::tuple<RequestStatus, http::compression_type>
-    parse(http::request &current_request, char *begin, char *end);
-
-  private:
-    RequestStatus consume(http::request &current_request, const char input);
-
-    bool is_char(const int character) const;
-
-    bool is_CTL(const int character) const;
-
-    bool is_special(const int character) const;
-
-    bool is_digit(const int character) const;
-
-    enum class internal_state : unsigned char
-    {
-        method_start,
-        method,
-        uri_start,
-        uri,
-        http_version_h,
-        http_version_t_1,
-        http_version_t_2,
-        http_version_p,
-        http_version_slash,
-        http_version_major_start,
-        http_version_major,
-        http_version_minor_start,
-        http_version_minor,
-        expecting_newline_1,
-        header_line_start,
-        header_lws,
-        header_name,
-        header_value,
-        expecting_newline_2,
-        expecting_newline_3
-    } state;
-
-    http::header current_header;
-    http::compression_type selected_compression;
-};
-}
-}
-
-#endif // REQUEST_PARSER_HPP
diff --git a/include/server/server.hpp b/include/server/server.hpp
index 0b944fd4a..280b48668 100644
--- a/include/server/server.hpp
+++ b/include/server/server.hpp
@@ -43,12 +43,12 @@ class Server
     }
 
     explicit Server(const std::string &address, const int port, const unsigned thread_pool_size)
-        : thread_pool_size(thread_pool_size), acceptor(io_service),
-          new_connection(std::make_shared<Connection>(io_service, request_handler))
+        : thread_pool_size(thread_pool_size), acceptor(io_context),
+          new_connection(std::make_shared<Connection>(io_context, request_handler))
     {
         const auto port_string = std::to_string(port);
 
-        boost::asio::ip::tcp::resolver resolver(io_service);
+        boost::asio::ip::tcp::resolver resolver(io_context);
         boost::asio::ip::tcp::resolver::query query(address, port_string);
         boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
 
@@ -74,16 +74,16 @@ class Server
         for (unsigned i = 0; i < thread_pool_size; ++i)
         {
             std::shared_ptr<std::thread> thread = std::make_shared<std::thread>(
-                boost::bind(&boost::asio::io_service::run, &io_service));
+                boost::bind(&boost::asio::io_context::run, &io_context));
             threads.push_back(thread);
         }
-        for (auto thread : threads)
+        for (const auto &thread : threads)
         {
             thread->join();
         }
     }
 
-    void Stop() { io_service.stop(); }
+    void Stop() { io_context.stop(); }
 
     void RegisterServiceHandler(std::unique_ptr<ServiceHandlerInterface> service_handler_)
     {
@@ -96,20 +96,24 @@ class Server
         if (!e)
         {
             new_connection->start();
-            new_connection = std::make_shared<Connection>(io_service, request_handler);
+            new_connection = std::make_shared<Connection>(io_context, request_handler);
             acceptor.async_accept(
                 new_connection->socket(),
                 boost::bind(&Server::HandleAccept, this, boost::asio::placeholders::error));
         }
+        else
+        {
+            util::Log(logERROR) << "HandleAccept error: " << e.message();
+        }
     }
 
     unsigned thread_pool_size;
-    boost::asio::io_service io_service;
+    boost::asio::io_context io_context;
     boost::asio::ip::tcp::acceptor acceptor;
     std::shared_ptr<Connection> new_connection;
     RequestHandler request_handler;
 };
-}
-}
+} // namespace server
+} // namespace osrm
 
 #endif // SERVER_HPP
diff --git a/include/server/service/base_service.hpp b/include/server/service/base_service.hpp
index 9491fa662..d8e88e72e 100644
--- a/include/server/service/base_service.hpp
+++ b/include/server/service/base_service.hpp
@@ -31,8 +31,8 @@ class BaseService
   protected:
     OSRM &routing_machine;
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/match_service.hpp b/include/server/service/match_service.hpp
index 1c3e51226..df9b81ace 100644
--- a/include/server/service/match_service.hpp
+++ b/include/server/service/match_service.hpp
@@ -28,8 +28,8 @@ class MatchService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/nearest_service.hpp b/include/server/service/nearest_service.hpp
index 454ec710b..06495ea59 100644
--- a/include/server/service/nearest_service.hpp
+++ b/include/server/service/nearest_service.hpp
@@ -28,8 +28,8 @@ class NearestService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/route_service.hpp b/include/server/service/route_service.hpp
index 12dbe0916..033bfbd61 100644
--- a/include/server/service/route_service.hpp
+++ b/include/server/service/route_service.hpp
@@ -28,8 +28,8 @@ class RouteService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/table_service.hpp b/include/server/service/table_service.hpp
index 76f4c32fa..3eb4c72e6 100644
--- a/include/server/service/table_service.hpp
+++ b/include/server/service/table_service.hpp
@@ -28,8 +28,8 @@ class TableService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/tile_service.hpp b/include/server/service/tile_service.hpp
index 5efd2a9b2..4693c9739 100644
--- a/include/server/service/tile_service.hpp
+++ b/include/server/service/tile_service.hpp
@@ -28,8 +28,8 @@ class TileService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/trip_service.hpp b/include/server/service/trip_service.hpp
index a86657dad..0180aa8e4 100644
--- a/include/server/service/trip_service.hpp
+++ b/include/server/service/trip_service.hpp
@@ -28,8 +28,8 @@ class TripService final : public BaseService
 
     unsigned GetVersion() final override { return 1; }
 };
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/server/service/utils.hpp b/include/server/service/utils.hpp
index e4fd7df13..fc76d0d14 100644
--- a/include/server/service/utils.hpp
+++ b/include/server/service/utils.hpp
@@ -24,6 +24,6 @@ bool constrainParamSize(const char *msg_template,
     }
     return false;
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/include/server/service_handler.hpp b/include/server/service_handler.hpp
index 150174982..2b62b0687 100644
--- a/include/server/service_handler.hpp
+++ b/include/server/service_handler.hpp
@@ -16,7 +16,7 @@ namespace json
 {
 struct Object;
 }
-}
+} // namespace util
 namespace server
 {
 namespace api
@@ -44,7 +44,7 @@ class ServiceHandler final : public ServiceHandlerInterface
     std::unordered_map<std::string, std::unique_ptr<service::BaseService>> service_map;
     OSRM routing_machine;
 };
-}
-}
+} // namespace server
+} // namespace osrm
 
 #endif
diff --git a/include/storage/block.hpp b/include/storage/block.hpp
index 60271f4ea..d8ba76859 100644
--- a/include/storage/block.hpp
+++ b/include/storage/block.hpp
@@ -33,10 +33,11 @@ using NamedBlock = std::tuple<std::string, Block>;
 
 template <typename T> Block make_block(uint64_t num_entries)
 {
+    // NOLINTNEXTLINE(misc-redundant-expression)
     static_assert(sizeof(T) % alignof(T) == 0, "aligned T* can't be used as an array pointer");
     return Block{num_entries, sizeof(T) * num_entries, 0};
 }
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/io.hpp b/include/storage/io.hpp
old mode 100755
new mode 100644
index 750605ac1..dc681c2fe
--- a/include/storage/io.hpp
+++ b/include/storage/io.hpp
@@ -388,8 +388,8 @@ class BufferWriter
   private:
     std::ostringstream output_stream;
 };
-} // ns io
-} // ns storage
-} // ns osrm
+} // namespace io
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/io_config.hpp b/include/storage/io_config.hpp
index e52eb928b..831382df7 100644
--- a/include/storage/io_config.hpp
+++ b/include/storage/io_config.hpp
@@ -18,8 +18,9 @@ struct IOConfig
     IOConfig(std::vector<boost::filesystem::path> required_input_files_,
              std::vector<boost::filesystem::path> optional_input_files_,
              std::vector<boost::filesystem::path> output_files_)
-        : required_input_files(required_input_files_), optional_input_files(optional_input_files_),
-          output_files(output_files_)
+        : required_input_files(std::move(required_input_files_)),
+          optional_input_files(std::move(optional_input_files_)),
+          output_files(std::move(output_files_))
     {
     }
 
@@ -48,7 +49,7 @@ struct IOConfig
 
         std::array<std::string, 6> known_extensions{
             {".osm.bz2", ".osm.pbf", ".osm.xml", ".pbf", ".osm", ".osrm"}};
-        for (auto ext : known_extensions)
+        for (const auto &ext : known_extensions)
         {
             const auto pos = path.find(ext);
             if (pos != std::string::npos)
@@ -80,7 +81,7 @@ struct IOConfig
     std::vector<boost::filesystem::path> optional_input_files;
     std::vector<boost::filesystem::path> output_files;
 };
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/io_fwd.hpp b/include/storage/io_fwd.hpp
index d88af1347..8bfef5728 100644
--- a/include/storage/io_fwd.hpp
+++ b/include/storage/io_fwd.hpp
@@ -11,8 +11,8 @@ namespace io
 class FileReader;
 class FileWriter;
 
-} // ns io
-} // ns storage
-} // ns osrm
+} // namespace io
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/serialization.hpp b/include/storage/serialization.hpp
index 07655ba4d..d83abfd9a 100644
--- a/include/storage/serialization.hpp
+++ b/include/storage/serialization.hpp
@@ -104,7 +104,7 @@ void writeBoolVector(tar::FileWriter &writer, const std::string &name, const Vec
         boost::make_function_input_iterator(encode_function, boost::infinite()),
         number_of_blocks);
 }
-}
+} // namespace detail
 
 /* All vector formats here use the same on-disk format.
  * This is important because we want to be able to write from a vector
@@ -268,8 +268,8 @@ inline void write(io::BufferWriter &writer, const BaseDataLayout &layout)
 {
     write(writer, layout.blocks);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/shared_data_index.hpp b/include/storage/shared_data_index.hpp
index 9041bc100..41ae6dabb 100644
--- a/include/storage/shared_data_index.hpp
+++ b/include/storage/shared_data_index.hpp
@@ -95,7 +95,7 @@ class SharedDataIndex
     std::vector<AllocatedRegion> regions;
     std::unordered_map<std::string, std::uint32_t> block_to_region;
 };
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/shared_datatype.hpp b/include/storage/shared_datatype.hpp
index 5677c8af0..bc4bf4efc 100644
--- a/include/storage/shared_datatype.hpp
+++ b/include/storage/shared_datatype.hpp
@@ -36,7 +36,7 @@ inline std::string trimName(const std::string &name_prefix, const std::string &n
     // list directory and
     if (!name_prefix.empty() && name_prefix.back() == '/')
     {
-        auto directory_position = name.find_first_of("/", name_prefix.length());
+        auto directory_position = name.find_first_of('/', name_prefix.length());
         // this is a "file" in the directory of name_prefix
         if (directory_position == std::string::npos)
         {
diff --git a/include/storage/shared_memory_ownership.hpp b/include/storage/shared_memory_ownership.hpp
index c1c7e40d9..5c3074e5e 100644
--- a/include/storage/shared_memory_ownership.hpp
+++ b/include/storage/shared_memory_ownership.hpp
@@ -12,7 +12,7 @@ enum class Ownership
     View,
     External
 };
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif // SHARED_MEMORY_OWNERSHIP_HPP
diff --git a/include/storage/storage.hpp b/include/storage/storage.hpp
index b03669db0..8c8b974f6 100644
--- a/include/storage/storage.hpp
+++ b/include/storage/storage.hpp
@@ -61,7 +61,7 @@ class Storage
   private:
     StorageConfig config;
 };
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/storage_config.hpp b/include/storage/storage_config.hpp
index 83b51a0bd..581b45e32 100644
--- a/include/storage/storage_config.hpp
+++ b/include/storage/storage_config.hpp
@@ -75,7 +75,7 @@ struct StorageConfig final : IOConfig
     {
     }
 };
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/tar.hpp b/include/storage/tar.hpp
index d7f4d0022..a13893589 100644
--- a/include/storage/tar.hpp
+++ b/include/storage/tar.hpp
@@ -9,7 +9,8 @@
 
 #include <boost/filesystem/path.hpp>
 
-extern "C" {
+extern "C"
+{
 #include "microtar.h"
 }
 
@@ -70,7 +71,7 @@ checkMTarError(int error_code, const boost::filesystem::path &filepath, const st
         throw util::exception(filepath.string() + " : " + name + ":" + mtar_strerror(error_code));
     }
 }
-}
+} // namespace detail
 
 class FileReader
 {
@@ -311,8 +312,8 @@ class FileWriter
     boost::filesystem::path path;
     mtar_t handle;
 };
-}
-}
-}
+} // namespace tar
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/tar_fwd.hpp b/include/storage/tar_fwd.hpp
index cc19ad484..b8503e003 100644
--- a/include/storage/tar_fwd.hpp
+++ b/include/storage/tar_fwd.hpp
@@ -11,8 +11,8 @@ namespace tar
 class FileReader;
 class FileWriter;
 
-} // ns io
-} // ns storage
-} // ns osrm
+} // namespace tar
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/storage/view_factory.hpp b/include/storage/view_factory.hpp
index fb45b57d6..1153103b9 100644
--- a/include/storage/view_factory.hpp
+++ b/include/storage/view_factory.hpp
@@ -100,8 +100,7 @@ inline auto make_ebn_data_view(const SharedDataIndex &index, const std::string &
     auto annotation_data =
         make_vector_view<extractor::NodeBasedEdgeAnnotation>(index, name + "/annotations");
 
-    return extractor::EdgeBasedNodeDataView(std::move(edge_based_node_data),
-                                            std::move(annotation_data));
+    return extractor::EdgeBasedNodeDataView(edge_based_node_data, annotation_data);
 }
 
 inline auto make_turn_data_view(const SharedDataIndex &index, const std::string &name)
@@ -119,11 +118,8 @@ inline auto make_turn_data_view(const SharedDataIndex &index, const std::string
     const auto post_turn_bearings =
         make_vector_view<guidance::TurnBearing>(index, name + "/post_turn_bearings");
 
-    return guidance::TurnDataView(std::move(turn_instructions),
-                                  std::move(lane_data_ids),
-                                  std::move(entry_class_ids),
-                                  std::move(pre_turn_bearings),
-                                  std::move(post_turn_bearings));
+    return guidance::TurnDataView(
+        turn_instructions, lane_data_ids, entry_class_ids, pre_turn_bearings, post_turn_bearings);
 }
 
 inline auto make_segment_data_view(const SharedDataIndex &index, const std::string &name)
@@ -379,7 +375,7 @@ inline auto make_filtered_graph_view(const SharedDataIndex &index,
 
     return util::FilteredGraphView<contractor::QueryGraphView>({node_list, edge_list}, edge_filter);
 }
-}
-}
+} // namespace storage
+} // namespace osrm
 
 #endif
diff --git a/include/updater/csv_file_parser.hpp b/include/updater/csv_file_parser.hpp
index 1d746cdc0..c9841798e 100644
--- a/include/updater/csv_file_parser.hpp
+++ b/include/updater/csv_file_parser.hpp
@@ -48,18 +48,16 @@ template <typename Key, typename Value> struct CSVFilesParser
         {
             tbb::spin_mutex mutex;
             std::vector<std::pair<Key, Value>> lookup;
-            tbb::parallel_for(std::size_t{0},
-                              csv_filenames.size(),
-                              [&](const std::size_t idx) {
-                                  auto local = ParseCSVFile(csv_filenames[idx], start_index + idx);
+            tbb::parallel_for(std::size_t{0}, csv_filenames.size(), [&](const std::size_t idx) {
+                auto local = ParseCSVFile(csv_filenames[idx], start_index + idx);
 
-                                  { // Merge local CSV results into a flat global vector
-                                      tbb::spin_mutex::scoped_lock _{mutex};
-                                      lookup.insert(end(lookup),
-                                                    std::make_move_iterator(begin(local)),
-                                                    std::make_move_iterator(end(local)));
-                                  }
-                              });
+                { // Merge local CSV results into a flat global vector
+                    tbb::spin_mutex::scoped_lock _{mutex};
+                    lookup.insert(end(lookup),
+                                  std::make_move_iterator(begin(local)),
+                                  std::make_move_iterator(end(local)));
+                }
+            });
 
             // With flattened map-ish view of all the files, make a stable sort on key and source
             // and unique them on key to keep only the value with the largest file index
@@ -140,7 +138,7 @@ template <typename Key, typename Value> struct CSVFilesParser
     const KeyRule key_rule;
     const ValueRule value_rule;
 };
-}
-}
+} // namespace updater
+} // namespace osrm
 
 #endif
diff --git a/include/updater/csv_source.hpp b/include/updater/csv_source.hpp
index 08c8d22bb..8fa00941a 100644
--- a/include/updater/csv_source.hpp
+++ b/include/updater/csv_source.hpp
@@ -11,8 +11,8 @@ namespace csv
 {
 SegmentLookupTable readSegmentValues(const std::vector<std::string> &paths);
 TurnLookupTable readTurnValues(const std::vector<std::string> &paths);
-}
-}
-}
+} // namespace csv
+} // namespace updater
+} // namespace osrm
 
 #endif
diff --git a/include/updater/source.hpp b/include/updater/source.hpp
index d03cc76bf..58a19e080 100644
--- a/include/updater/source.hpp
+++ b/include/updater/source.hpp
@@ -88,7 +88,7 @@ struct PenaltySource final
 
 using SegmentLookupTable = LookupTable<Segment, SpeedSource>;
 using TurnLookupTable = LookupTable<Turn, PenaltySource>;
-}
-}
+} // namespace updater
+} // namespace osrm
 
 #endif
diff --git a/include/updater/updater.hpp b/include/updater/updater.hpp
index 565b293cb..e5610c6bd 100644
--- a/include/updater/updater.hpp
+++ b/include/updater/updater.hpp
@@ -37,7 +37,7 @@ class Updater
   private:
     UpdaterConfig config;
 };
-}
-}
+} // namespace updater
+} // namespace osrm
 
 #endif
diff --git a/include/updater/updater_config.hpp b/include/updater/updater_config.hpp
index 64306a609..30c2cec9f 100644
--- a/include/updater/updater_config.hpp
+++ b/include/updater/updater_config.hpp
@@ -73,7 +73,7 @@ struct UpdaterConfig final : storage::IOConfig
     std::vector<std::string> turn_penalty_lookup_paths;
     std::string tz_file_path;
 };
-}
-}
+} // namespace updater
+} // namespace osrm
 
 #endif // EXTRACTOR_OPTIONS_HPP
diff --git a/include/util/alias.hpp b/include/util/alias.hpp
index 43b007a19..23f614298 100644
--- a/include/util/alias.hpp
+++ b/include/util/alias.hpp
@@ -130,7 +130,7 @@ inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &in
 {
     return stream << inst.__value;
 }
-}
+} // namespace osrm
 
 namespace std
 {
@@ -143,6 +143,6 @@ template <typename From, typename Tag> struct hash<osrm::Alias<From, Tag>>
         return std::hash<From>()(static_cast<const From>(s));
     }
 };
-}
+} // namespace std
 
 #endif // OSRM_ALIAS_HPP
diff --git a/include/util/bit_range.hpp b/include/util/bit_range.hpp
index f1f1d4ba9..6d7ffcae4 100644
--- a/include/util/bit_range.hpp
+++ b/include/util/bit_range.hpp
@@ -39,7 +39,7 @@ inline std::size_t countOnes(unsigned int value) { return __builtin_popcount(val
 inline std::size_t countOnes(unsigned long value) { return __builtin_popcountl(value); }
 inline std::size_t countOnes(unsigned long long value) { return __builtin_popcountll(value); }
 #endif
-}
+} // namespace detail
 
 // Investigate if we can replace this with
 // http://www.boost.org/doc/libs/1_64_0/libs/dynamic_bitset/dynamic_bitset.html
@@ -93,7 +93,7 @@ template <typename T> auto makeBitRange(const T value)
 {
     return boost::make_iterator_range(BitIterator<T>{value}, BitIterator<T>{});
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/cast.hpp b/include/util/cast.hpp
index 0b4468d75..1a420fa3a 100644
--- a/include/util/cast.hpp
+++ b/include/util/cast.hpp
@@ -42,8 +42,8 @@ template <typename T, int Precision = 6> inline std::string to_string_with_preci
 
     return rv;
 }
-}
-}
-}
+} // namespace cast
+} // namespace util
+} // namespace osrm
 
 #endif // CAST_HPP
diff --git a/include/util/concurrent_id_map.hpp b/include/util/concurrent_id_map.hpp
index bd15f44d8..f5fbb4374 100644
--- a/include/util/concurrent_id_map.hpp
+++ b/include/util/concurrent_id_map.hpp
@@ -74,7 +74,7 @@ struct ConcurrentIDMap
     }
 };
 
-} // util
-} // osrm
+} // namespace util
+} // namespace osrm
 
 #endif // CONCURRENT_ID_MAP_HPP
diff --git a/include/util/conditional_restrictions.hpp b/include/util/conditional_restrictions.hpp
index 18c0463e6..e18379698 100644
--- a/include/util/conditional_restrictions.hpp
+++ b/include/util/conditional_restrictions.hpp
@@ -21,7 +21,7 @@ struct ConditionalRestriction
 
 std::vector<ConditionalRestriction> ParseConditionalRestrictions(const std::string &str);
 
-} // util
-} // osrm
+} // namespace util
+} // namespace osrm
 
 #endif // OSRM_CONDITIONAL_RESTRICTIONS_HPP
diff --git a/include/util/connectivity_checksum.hpp b/include/util/connectivity_checksum.hpp
index a39a98064..25893a8d2 100644
--- a/include/util/connectivity_checksum.hpp
+++ b/include/util/connectivity_checksum.hpp
@@ -84,7 +84,7 @@ struct ConnectivityChecksum
     std::size_t byte_number;
     unsigned char bit_number;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/container.hpp b/include/util/container.hpp
index 91b1cccb1..68ab7e526 100644
--- a/include/util/container.hpp
+++ b/include/util/container.hpp
@@ -16,7 +16,7 @@ void append_to_container(Container &&container, T value, Args &&... args)
     container.emplace_back(value);
     append_to_container(std::forward<Container>(container), std::forward<Args>(args)...);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/coordinate.hpp b/include/util/coordinate.hpp
index 6f2096703..bb03c9107 100644
--- a/include/util/coordinate.hpp
+++ b/include/util/coordinate.hpp
@@ -60,7 +60,7 @@ struct unsafelatitude
 struct unsafelongitude
 {
 };
-}
+} // namespace tag
 
 // Internal lon/lat types - assumed to be range safe
 using FixedLatitude = Alias<std::int32_t, tag::latitude>;
@@ -265,7 +265,7 @@ inline Coordinate::Coordinate(const FloatCoordinate &other)
     : Coordinate(toFixed(other.lon), toFixed(other.lat))
 {
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* COORDINATE_HPP_ */
diff --git a/include/util/coordinate_calculation.hpp b/include/util/coordinate_calculation.hpp
index c946842a2..959a74107 100644
--- a/include/util/coordinate_calculation.hpp
+++ b/include/util/coordinate_calculation.hpp
@@ -38,16 +38,11 @@ inline double radToDeg(const double radian)
     using namespace boost::math::constants;
     return radian * (180.0 * (1. / pi<double>()));
 }
-}
+} // namespace detail
 
 //! Takes the squared euclidean distance of the input coordinates. Does not return meters!
 std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rhs);
 
-double fccApproximateDistance(const Coordinate first_coordinate,
-                              const Coordinate second_coordinate);
-
-double haversineDistance(const Coordinate first_coordinate, const Coordinate second_coordinate);
-
 double greatCircleDistance(const Coordinate first_coordinate, const Coordinate second_coordinate);
 
 // get the length of a full coordinate vector, using one of our basic functions to compute distances
@@ -224,7 +219,7 @@ double findClosestDistance(const iterator_type lhs_begin,
     double current_min = std::numeric_limits<double>::max();
 
     const auto compute_minimum_distance_in_rhs = [&current_min, rhs_begin, rhs_end](
-        const Coordinate coordinate) {
+                                                     const Coordinate coordinate) {
         current_min = std::min(current_min, findClosestDistance(coordinate, rhs_begin, rhs_end));
         return false;
     };
@@ -320,10 +315,9 @@ std::pair<Coordinate, Coordinate> leastSquareRegression(const iterator_type begi
                         end,
                         0.,
                         [&](const auto sum_so_far, const auto current_coordinate) {
-                            return sum_so_far +
-                                   (extract_lon(current_coordinate) - mean_lon) *
-                                       (extract_lat(current_coordinate) - mean_lat) /
-                                       (sample_variance_lon * sample_variance_lat);
+                            return sum_so_far + (extract_lon(current_coordinate) - mean_lon) *
+                                                    (extract_lat(current_coordinate) - mean_lat) /
+                                                    (sample_variance_lon * sample_variance_lat);
                         }) /
         (number_of_coordinates - 1);
 
@@ -383,8 +377,8 @@ bool areParallel(const iterator_type lhs_begin,
 
 double computeArea(const std::vector<Coordinate> &polygon);
 
-} // ns coordinate_calculation
-} // ns util
-} // ns osrm
+} // namespace coordinate_calculation
+} // namespace util
+} // namespace osrm
 
 #endif // COORDINATE_CALCULATION
diff --git a/include/util/deallocating_vector.hpp b/include/util/deallocating_vector.hpp
index 1a160271b..afc357f6f 100644
--- a/include/util/deallocating_vector.hpp
+++ b/include/util/deallocating_vector.hpp
@@ -273,7 +273,9 @@ template <typename ElementT> class DeallocatingVector
         ++current_size;
     }
 
-    void reserve(const std::size_t) const { /* don't do anything */}
+    void reserve(const std::size_t) const
+    { /* don't do anything */
+    }
 
     void resize(const std::size_t new_size)
     {
@@ -350,7 +352,7 @@ template <typename T> void swap(DeallocatingVector<T> &lhs, DeallocatingVector<T
 {
     lhs.swap(rhs);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* DEALLOCATING_VECTOR_HPP */
diff --git a/include/util/debug.hpp b/include/util/debug.hpp
index 001e31e82..d318a7249 100644
--- a/include/util/debug.hpp
+++ b/include/util/debug.hpp
@@ -27,7 +27,7 @@ inline std::ostream &operator<<(std::ostream &out, const Coordinate &coordinate)
         << toFloating(coordinate.lat) << "}";
     return out;
 }
-}
+} // namespace util
 
 namespace engine
 {
@@ -62,8 +62,8 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
 
     return out;
 }
-}
-}
+} // namespace guidance
+} // namespace engine
 
 namespace guidance
 {
@@ -76,7 +76,7 @@ inline std::ostream &operator<<(std::ostream &out, const ConnectedRoad &road)
         << static_cast<std::int32_t>(road.lane_data_id) << "}";
     return out;
 }
-}
+} // namespace guidance
 
 namespace extractor
 {
@@ -95,7 +95,7 @@ inline std::ostream &operator<<(std::ostream &out, const IntersectionViewData &v
         << " angle: " << view.angle << " bearing: " << view.perceived_bearing << "}";
     return out;
 }
-}
+} // namespace intersection
 
 namespace TurnLaneType
 {
@@ -125,9 +125,9 @@ inline std::ostream &operator<<(std::ostream &out, const Mask lane_type)
 
     return out;
 }
-}
-}
-}
+} // namespace TurnLaneType
+} // namespace extractor
+} // namespace osrm
 
 namespace std
 {
@@ -147,7 +147,7 @@ inline std::ostream &operator<<(std::ostream &out,
 
     return out;
 }
-}
+} // namespace std
 
 namespace osrm
 {
@@ -186,8 +186,8 @@ inline std::ostream &operator<<(std::ostream &out, const LaneDataVector &turn_la
 
     return out;
 }
-}
-}
+} // namespace lanes
+} // namespace guidance
 
 namespace extractor
 {
@@ -204,7 +204,7 @@ inline std::ostream &operator<<(std::ostream &out, const EdgeBasedEdge &edge)
     out << "}";
     return out;
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
 
 #endif /*OSRM_ENGINE_GUIDANCE_DEBUG_HPP_*/
diff --git a/include/util/dist_table_wrapper.hpp b/include/util/dist_table_wrapper.hpp
index 56c750244..8344a3178 100644
--- a/include/util/dist_table_wrapper.hpp
+++ b/include/util/dist_table_wrapper.hpp
@@ -77,7 +77,7 @@ template <typename T> class DistTableWrapper
     std::vector<T> table_;
     const std::size_t number_of_nodes_;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // DIST_TABLE_WRAPPER_H
diff --git a/include/util/dynamic_graph.hpp b/include/util/dynamic_graph.hpp
index 2a22aeae7..5cee5b3e0 100644
--- a/include/util/dynamic_graph.hpp
+++ b/include/util/dynamic_graph.hpp
@@ -41,7 +41,7 @@ template <typename NodeIterator, typename EdgeDataT> struct DynamicEdge
     NodeIterator target;
     EdgeDataT data;
 };
-}
+} // namespace detail
 
 template <typename EdgeDataT> class DynamicGraph
 {
@@ -468,7 +468,7 @@ template <typename EdgeDataT> class DynamicGraph
     std::vector<Node> node_array;
     DeallocatingVector<Edge> edge_list;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // DYNAMICGRAPH_HPP
diff --git a/include/util/exception.hpp b/include/util/exception.hpp
index 26e219f8e..7a4b89ca4 100644
--- a/include/util/exception.hpp
+++ b/include/util/exception.hpp
@@ -47,7 +47,7 @@ class exception : public std::exception
   public:
     explicit exception(const char *message) : message(message) {}
     explicit exception(std::string message) : message(std::move(message)) {}
-    explicit exception(boost::format message) : message(message.str()) {}
+    explicit exception(const boost::format &message) : message(message.str()) {}
     const char *what() const noexcept override { return message.c_str(); }
 
   private:
@@ -65,18 +65,19 @@ class exception : public std::exception
  */
 
 constexpr const std::array<const char *, 11> ErrorDescriptions = {{
-    "",                                                      // Dummy - ErrorCode values start at 2
-    "",                                                      // Dummy - ErrorCode values start at 2
-    "Fingerprint did not match the expected value",          // InvalidFingerprint
-    "File is incompatible with this version of OSRM",        // IncompatibleFileVersion
-    "Problem opening file",                                  // FileOpenError
-    "Problem reading from file",                             // FileReadError
-    "Problem writing to file",                               // FileWriteError
-    "I/O error occurred",                                    // FileIOError
-    "Unexpected end of file",                                // UnexpectedEndOfFile
-    "The dataset you are trying to load is not "             // IncompatibleDataset
-    "compatible with the routing algorithm you want to use." // ...continued...
-    "Incompatible algorithm"                                 // IncompatibleAlgorithm
+    "",                                               // Dummy - ErrorCode values start at 2
+    "",                                               // Dummy - ErrorCode values start at 2
+    "Fingerprint did not match the expected value",   // InvalidFingerprint
+    "File is incompatible with this version of OSRM", // IncompatibleFileVersion
+    "Problem opening file",                           // FileOpenError
+    "Problem reading from file",                      // FileReadError
+    "Problem writing to file",                        // FileWriteError
+    "I/O error occurred",                             // FileIOError
+    "Unexpected end of file",                         // UnexpectedEndOfFile
+    // NOLINTNEXTLINE(bugprone-suspicious-missing-comma)
+    "The dataset you are trying to load is not "              // IncompatibleDataset
+    "compatible with the routing algorithm you want to use.", // ...continued...
+    "Incompatible algorithm"                                  // IncompatibleAlgorithm
 }};
 
 #ifndef NDEBUG
@@ -123,7 +124,7 @@ class RuntimeError : public exception
         return result;
     }
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* OSRM_EXCEPTION_HPP */
diff --git a/include/util/exception_utils.hpp b/include/util/exception_utils.hpp
index e933fcb4e..58c128af0 100644
--- a/include/util/exception_utils.hpp
+++ b/include/util/exception_utils.hpp
@@ -10,6 +10,6 @@
 #define OSRM_SOURCE_FILE_ PROJECT_RELATIVE_PATH_(__FILE__)
 
 // This is the macro to use
-#define SOURCE_REF OSRM_SOURCE_FILE_ + ":" + std::to_string(__LINE__)
+#define SOURCE_REF (OSRM_SOURCE_FILE_ + ":" + std::to_string(__LINE__))
 
 #endif // SOURCE_MACROS_HPP
diff --git a/include/util/exclude_flag.hpp b/include/util/exclude_flag.hpp
index ffec32c80..373faeb90 100644
--- a/include/util/exclude_flag.hpp
+++ b/include/util/exclude_flag.hpp
@@ -29,7 +29,7 @@ excludeFlagsToNodeFilter(const NodeID number_of_nodes,
     }
     return filters;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/filtered_graph.hpp b/include/util/filtered_graph.hpp
index c4df051d0..3efdf7b9b 100644
--- a/include/util/filtered_graph.hpp
+++ b/include/util/filtered_graph.hpp
@@ -153,13 +153,13 @@ class FilteredGraphImpl<util::StaticGraph<EdgeDataT, Ownership>, Ownership>
     Graph graph;
     Vector<bool> edge_filter;
 };
-}
+} // namespace detail
 
 template <typename GraphT>
 using FilteredGraphContainer = detail::FilteredGraphImpl<GraphT, storage::Ownership::Container>;
 template <typename GraphT>
 using FilteredGraphView = detail::FilteredGraphImpl<GraphT, storage::Ownership::View>;
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/filtered_integer_range.hpp b/include/util/filtered_integer_range.hpp
index dd3f61b3d..ec0ac596b 100644
--- a/include/util/filtered_integer_range.hpp
+++ b/include/util/filtered_integer_range.hpp
@@ -95,7 +95,7 @@ filtered_irange(const Integer first,
 {
     return filtered_range<Integer, Filter>(first, last, filter);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // INTEGER_RANGE_HPP
diff --git a/include/util/fingerprint.hpp b/include/util/fingerprint.hpp
index 1c99a3a6b..14a9b4b2b 100644
--- a/include/util/fingerprint.hpp
+++ b/include/util/fingerprint.hpp
@@ -36,7 +36,7 @@ struct FingerPrint
 static_assert(sizeof(FingerPrint) == 8, "FingerPrint has unexpected size");
 static_assert(std::is_trivial<FingerPrint>::value, "FingerPrint needs to be trivial.");
 static_assert(std::is_pod<FingerPrint>::value, "FingerPrint needs to be a POD.");
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* FingerPrint_H */
diff --git a/include/util/for_each_indexed.hpp b/include/util/for_each_indexed.hpp
new file mode 100644
index 000000000..86655416b
--- /dev/null
+++ b/include/util/for_each_indexed.hpp
@@ -0,0 +1,31 @@
+#ifndef FOR_EACH_INDEXED_HPP
+#define FOR_EACH_INDEXED_HPP
+
+#include <iterator>
+#include <numeric>
+#include <utility>
+
+namespace osrm
+{
+namespace util
+{
+
+template <typename ForwardIterator, typename Function>
+void for_each_indexed(ForwardIterator first, ForwardIterator last, Function function)
+{
+    for (size_t i = 0; first != last; ++first, ++i)
+    {
+        function(i, *first);
+    }
+}
+
+template <class ContainerT, typename Function>
+void for_each_indexed(ContainerT &container, Function function)
+{
+    for_each_indexed(std::begin(container), std::end(container), function);
+}
+
+} // namespace util
+} // namespace osrm
+
+#endif /* FOR_EACH_INDEXED_HPP */
diff --git a/include/util/for_each_range.hpp b/include/util/for_each_range.hpp
index 01f29e781..6df81b4da 100644
--- a/include/util/for_each_range.hpp
+++ b/include/util/for_each_range.hpp
@@ -20,7 +20,7 @@ template <typename Iter, typename Func> void for_each_range(Iter begin, Iter end
         f(begin_range, iter);
     }
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/geojson_validation.hpp b/include/util/geojson_validation.hpp
index 97fcbc807..8482395be 100644
--- a/include/util/geojson_validation.hpp
+++ b/include/util/geojson_validation.hpp
@@ -76,7 +76,15 @@ inline void validateFeature(const rapidjson::Value &feature)
     const auto coord_array = feature["geometry"].GetObject()["coordinates"].GetArray();
     if (coord_array.Empty())
         throw osrm::util::exception("Feature geometry coordinates member is empty.");
+
+    if (feature["geometry"]["type"] == "polygon" || feature["geometry"]["type"] == "Polygon")
+    {
+        if (!coord_array[0].IsArray() || !coord_array[0][0].IsArray())
+        {
+            throw osrm::util::exception("Polygon geometry missing outer ring");
+        }
+    }
 }
-}
-}
+} // namespace util
+} // namespace osrm
 #endif // OSRM_GEOJSON_VALIDATION_HPP
diff --git a/include/util/graph_traits.hpp b/include/util/graph_traits.hpp
index 419e6e276..31edfadf1 100644
--- a/include/util/graph_traits.hpp
+++ b/include/util/graph_traits.hpp
@@ -49,8 +49,8 @@ struct HasFirstEdgeMember<T, decltype((void)(sizeof(std::declval<T>().first_edge
 {
 };
 
-} // ns traits
-} // ns util
-} // ns osrm
+} // namespace traits
+} // namespace util
+} // namespace osrm
 
 #endif // STATIC_GRAPH_TRAITS_HPP
diff --git a/include/util/graph_utils.hpp b/include/util/graph_utils.hpp
index e135873ab..bb0bebf66 100644
--- a/include/util/graph_utils.hpp
+++ b/include/util/graph_utils.hpp
@@ -96,7 +96,7 @@ std::vector<OutputEdgeT> directedEdgesFromCompressed(const std::vector<InputEdge
 
     return output_edge_list;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/group_by.hpp b/include/util/group_by.hpp
index db8a312e8..22473729e 100644
--- a/include/util/group_by.hpp
+++ b/include/util/group_by.hpp
@@ -34,7 +34,7 @@ Fn group_by(Iter first, Iter last, Pred pred, Fn fn)
     return fn;
 }
 
-} // ns util
-} // ns osrm
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/guidance/bearing_class.hpp b/include/util/guidance/bearing_class.hpp
index ce727b67e..57e364190 100644
--- a/include/util/guidance/bearing_class.hpp
+++ b/include/util/guidance/bearing_class.hpp
@@ -71,8 +71,8 @@ class BearingClass
 // make Bearing Class hasbable
 namespace std
 {
-inline size_t hash<::osrm::util::guidance::BearingClass>::
-operator()(const ::osrm::util::guidance::BearingClass &bearing_class) const
+inline size_t hash<::osrm::util::guidance::BearingClass>::operator()(
+    const ::osrm::util::guidance::BearingClass &bearing_class) const
 {
     return boost::hash_value(bearing_class.available_bearings);
 }
diff --git a/include/util/guidance/entry_class.hpp b/include/util/guidance/entry_class.hpp
index 458303644..6d6838e27 100644
--- a/include/util/guidance/entry_class.hpp
+++ b/include/util/guidance/entry_class.hpp
@@ -72,7 +72,7 @@ static_assert(std::is_trivially_copyable<EntryClass>::value,
 #endif
 
 } // namespace guidance
-} // namespace utilr
+} // namespace util
 
 constexpr const util::guidance::EntryClass EMPTY_ENTRY_CLASS{};
 } // namespace osrm
@@ -80,8 +80,8 @@ constexpr const util::guidance::EntryClass EMPTY_ENTRY_CLASS{};
 // make Entry Class hasbable
 namespace std
 {
-inline size_t hash<::osrm::util::guidance::EntryClass>::
-operator()(const ::osrm::util::guidance::EntryClass &entry_class) const
+inline size_t hash<::osrm::util::guidance::EntryClass>::operator()(
+    const ::osrm::util::guidance::EntryClass &entry_class) const
 {
     return hash<::osrm::util::guidance::EntryClass::FlagBaseType>()(
         entry_class.enabled_entries_flags);
diff --git a/include/util/guidance/name_announcements.hpp b/include/util/guidance/name_announcements.hpp
index 2a3953ead..fa8f9db43 100644
--- a/include/util/guidance/name_announcements.hpp
+++ b/include/util/guidance/name_announcements.hpp
@@ -71,12 +71,12 @@ template <typename StringView> inline auto decompose(const StringView &lhs, cons
         // we compare suffixes based on this value, it might break UTF chars, but as long as we are
         // consistent in handling, we do not create bad results
         std::string str = boost::to_lower_copy(view.to_string());
-        auto front = str.find_first_not_of(" ");
+        auto front = str.find_first_not_of(' ');
 
         if (front == std::string::npos)
             return str;
 
-        auto back = str.find_last_not_of(" ");
+        auto back = str.find_last_not_of(' ');
         return str.substr(front, back - front + 1);
     };
 
diff --git a/include/util/hilbert_value.hpp b/include/util/hilbert_value.hpp
index c5f9245b0..7521cbd92 100644
--- a/include/util/hilbert_value.hpp
+++ b/include/util/hilbert_value.hpp
@@ -69,7 +69,7 @@ inline std::uint64_t GetHilbertCode(const Coordinate &coordinate)
                             static_cast<std::int32_t>(90 * COORDINATE_PRECISION);
     return HilbertToLinear(x, y);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* HILBERT_VALUE_HPP */
diff --git a/include/util/ieee754.hpp b/include/util/ieee754.hpp
index 16f37e15d..a6112ec2f 100644
--- a/include/util/ieee754.hpp
+++ b/include/util/ieee754.hpp
@@ -52,7 +52,8 @@ struct DiyFp
 
     DiyFp(double d)
     {
-        union {
+        union
+        {
             double d;
             uint64_t u64;
         } u = {d};
@@ -247,8 +248,9 @@ inline DiyFp GetCachedPower(int e, int *K)
 inline void
 GrisuRound(char *buffer, int len, uint64_t delta, uint64_t rest, uint64_t ten_kappa, uint64_t wp_w)
 {
-    while (rest < wp_w && delta - rest >= ten_kappa && (rest + ten_kappa < wp_w || /// closer
-                                                        wp_w - rest > rest + ten_kappa - wp_w))
+    while (rest < wp_w && delta - rest >= ten_kappa &&
+           (rest + ten_kappa < wp_w || /// closer
+            wp_w - rest > rest + ten_kappa - wp_w))
     {
         buffer[len - 1]--;
         rest += ten_kappa;
diff --git a/include/util/indexed_data.hpp b/include/util/indexed_data.hpp
index 080311040..5ce5bd4b3 100644
--- a/include/util/indexed_data.hpp
+++ b/include/util/indexed_data.hpp
@@ -23,7 +23,7 @@ namespace util
 namespace detail
 {
 template <typename GroupBlockPolicy, storage::Ownership Ownership> struct IndexedDataImpl;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -36,7 +36,7 @@ template <typename BlockPolicy, storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::IndexedDataImpl<BlockPolicy, Ownership> &index_data);
-}
+} // namespace serialization
 
 template <int N, typename T = std::string> struct VariableGroupBlock
 {
@@ -69,9 +69,7 @@ template <int N, typename T = std::string> struct VariableGroupBlock
     inline void
     var_advance(DataIterator &data, DataIterator &length, std::uint32_t byte_length) const
     {
-        if (byte_length == 0)
-        {
-        }
+        if (byte_length == 0) {}
         else if (byte_length == 1)
         {
             data += static_cast<unsigned char>(*length++);
@@ -331,6 +329,9 @@ template <typename GroupBlockPolicy, storage::Ownership Ownership> struct Indexe
     // Return value at the given index
     ResultType at(std::uint32_t index) const
     {
+        if (values.empty())
+            return ResultType();
+
         // Get block external ad internal indices
         const BlocksNumberType block_idx = index / (BLOCK_SIZE + 1);
         const std::uint32_t internal_idx = index % (BLOCK_SIZE + 1);
@@ -346,7 +347,7 @@ template <typename GroupBlockPolicy, storage::Ownership Ownership> struct Indexe
         const GroupBlockPolicy block;
         block.ReadRefrencedBlock(blocks[block_idx], internal_idx, first, last);
 
-        return adapt(&*first, &*last);
+        return adapt(first, last);
     }
 
     friend void serialization::read<GroupBlockPolicy, Ownership>(storage::tar::FileReader &reader,
@@ -359,30 +360,35 @@ template <typename GroupBlockPolicy, storage::Ownership Ownership> struct Indexe
                                                       const IndexedDataImpl &index_data);
 
   private:
-    template <class T = ResultType>
+    template <typename Iter, typename T>
+    using IsValueIterator =
+        std::enable_if_t<std::is_same<T, typename std::iterator_traits<Iter>::value_type>::value>;
+
+    template <typename T = ResultType, typename Iter, typename = IsValueIterator<Iter, ValueType>>
     typename std::enable_if<!std::is_same<T, StringView>::value, T>::type
-    adapt(const ValueType *first, const ValueType *last) const
+    adapt(const Iter first, const Iter last) const
     {
         return ResultType(first, last);
     }
 
-    template <class T = ResultType>
+    template <typename T = ResultType, typename Iter, typename = IsValueIterator<Iter, ValueType>>
     typename std::enable_if<std::is_same<T, StringView>::value, T>::type
-    adapt(const ValueType *first, const ValueType *last) const
+    adapt(const Iter first, const Iter last) const
     {
-        return ResultType(first, std::distance(first, last));
+        auto diff = std::distance(first, last);
+        return diff == 0 ? ResultType() : ResultType(&*first, diff);
     }
 
     template <typename T> using Vector = util::ViewOrVector<T, Ownership>;
     Vector<BlockReference> blocks;
     Vector<ValueType> values;
 };
-}
+} // namespace detail
 
 template <typename GroupBlockPolicy>
 using IndexedData = detail::IndexedDataImpl<GroupBlockPolicy, storage::Ownership::Container>;
 template <typename GroupBlockPolicy>
 using IndexedDataView = detail::IndexedDataImpl<GroupBlockPolicy, storage::Ownership::View>;
-}
-}
+} // namespace util
+} // namespace osrm
 #endif // OSRM_INDEXED_DATA_HPP
diff --git a/include/util/integer_range.hpp b/include/util/integer_range.hpp
index befaa3275..c8f56b8f7 100644
--- a/include/util/integer_range.hpp
+++ b/include/util/integer_range.hpp
@@ -90,7 +90,7 @@ irange(const Integer first,
 {
     return range<Integer>(first, last);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // INTEGER_RANGE_HPP
diff --git a/include/util/json_deep_compare.hpp b/include/util/json_deep_compare.hpp
index 9c202a527..53df4fdb3 100644
--- a/include/util/json_deep_compare.hpp
+++ b/include/util/json_deep_compare.hpp
@@ -40,8 +40,8 @@ struct Comparator
         bool is_same = lhs.value == rhs.value;
         if (!is_same)
         {
-            reason = lhs_path + " (= " + std::to_string(lhs.value) + ") != " + rhs_path + " (= " +
-                     std::to_string(rhs.value) + ")";
+            reason = lhs_path + " (= " + std::to_string(lhs.value) + ") != " + rhs_path +
+                     " (= " + std::to_string(rhs.value) + ")";
         }
         return is_same;
     }
@@ -158,8 +158,8 @@ inline bool compare(const Value &reference, const Value &result, std::string &re
     return mapbox::util::apply_visitor(
         Comparator(reason, "reference", "result"), reference, result);
 }
-}
-}
-}
+} // namespace json
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/log.hpp b/include/util/log.hpp
index d4b5f9c47..48bb0305f 100644
--- a/include/util/log.hpp
+++ b/include/util/log.hpp
@@ -85,6 +85,9 @@ class Log
         return *this;
     }
 
+  private:
+    void Init();
+
   protected:
     const LogLevel level;
     std::ostringstream buffer;
@@ -101,7 +104,7 @@ class UnbufferedLog : public Log
   public:
     UnbufferedLog(LogLevel level_ = logINFO);
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* LOG_HPP */
diff --git a/include/util/lua_util.hpp b/include/util/lua_util.hpp
index b5b64aada..0504834fd 100644
--- a/include/util/lua_util.hpp
+++ b/include/util/lua_util.hpp
@@ -1,7 +1,8 @@
 #ifndef LUA_UTIL_HPP
 #define LUA_UTIL_HPP
 
-extern "C" {
+extern "C"
+{
 #include <lauxlib.h>
 #include <lua.h>
 #include <lualib.h>
@@ -27,7 +28,7 @@ inline void luaAddScriptFolderToLoadPath(lua_State *lua_state, const char *file_
     const std::string lua_code = "package.path = \"" + folder + "/?.lua;\" .. package.path";
     luaL_dostring(lua_state, lua_code.c_str());
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // LUA_UTIL_HPP
diff --git a/include/util/matrix_graph_wrapper.hpp b/include/util/matrix_graph_wrapper.hpp
index 7889a6301..189ddfeea 100644
--- a/include/util/matrix_graph_wrapper.hpp
+++ b/include/util/matrix_graph_wrapper.hpp
@@ -46,7 +46,7 @@ template <typename T> class MatrixGraphWrapper
     const std::vector<T> table_;
     const std::size_t number_of_nodes_;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // MATRIX_GRAPH_WRAPPER_H
diff --git a/include/util/meminfo.hpp b/include/util/meminfo.hpp
index 1fe9d4d28..3409a4380 100644
--- a/include/util/meminfo.hpp
+++ b/include/util/meminfo.hpp
@@ -28,7 +28,7 @@ inline void DumpMemoryStats()
     util::Log() << "RAM: peak bytes used: <not implemented on Windows>";
 #endif // _WIN32
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/mmap_file.hpp b/include/util/mmap_file.hpp
index d55203d72..01e829b71 100644
--- a/include/util/mmap_file.hpp
+++ b/include/util/mmap_file.hpp
@@ -60,7 +60,7 @@ util::vector_view<T> mmapFile(const boost::filesystem::path &file,
             SOURCE_REF);
     }
 }
-}
+} // namespace detail
 
 template <typename T>
 util::vector_view<const T> mmapFile(const boost::filesystem::path &file,
@@ -83,7 +83,7 @@ util::vector_view<T> mmapFile(const boost::filesystem::path &file,
 {
     return detail::mmapFile<T>(file, mmap_container, size);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/mmap_tar.hpp b/include/util/mmap_tar.hpp
index b9129ba87..26f223159 100644
--- a/include/util/mmap_tar.hpp
+++ b/include/util/mmap_tar.hpp
@@ -38,7 +38,7 @@ inline DataMap mmapTarFile(const boost::filesystem::path &path,
 
     return map;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/msb.hpp b/include/util/msb.hpp
index 37e3a31a1..96e88d987 100644
--- a/include/util/msb.hpp
+++ b/include/util/msb.hpp
@@ -47,7 +47,7 @@ inline std::size_t msb(unsigned int v)
     return MSB_INDEX - __builtin_clz(v);
 }
 #endif
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/node_based_graph.hpp b/include/util/node_based_graph.hpp
index 1c31f8f7d..ba3126369 100644
--- a/include/util/node_based_graph.hpp
+++ b/include/util/node_based_graph.hpp
@@ -97,7 +97,7 @@ NodeBasedDynamicGraphFromEdges(NodeID number_of_nodes,
 
     return NodeBasedDynamicGraph(number_of_nodes, edges_list);
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // NODE_BASED_GRAPH_HPP
diff --git a/include/util/opening_hours.hpp b/include/util/opening_hours.hpp
index 63b82c453..e506bd0fa 100644
--- a/include/util/opening_hours.hpp
+++ b/include/util/opening_hours.hpp
@@ -223,7 +223,7 @@ std::vector<OpeningHours> ParseOpeningHours(const std::string &str);
 
 bool CheckOpeningHours(const std::vector<OpeningHours> &input, const struct tm &time);
 
-} // util
-} // osrm
+} // namespace util
+} // namespace osrm
 
 #endif // OSRM_OPENING_HOURS_HPP
diff --git a/include/util/packed_vector.hpp b/include/util/packed_vector.hpp
index 94ee4f19f..dfe4ef7e3 100644
--- a/include/util/packed_vector.hpp
+++ b/include/util/packed_vector.hpp
@@ -24,7 +24,7 @@ namespace util
 namespace detail
 {
 template <typename T, std::size_t Bits, storage::Ownership Ownership> class PackedVector;
-}
+} // namespace detail
 
 namespace serialization
 {
@@ -37,7 +37,7 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership>
 inline void write(storage::tar::FileWriter &writer,
                   const std::string &name,
                   const detail::PackedVector<T, Bits, Ownership> &vec);
-}
+} // namespace serialization
 
 namespace detail
 {
@@ -546,13 +546,13 @@ template <typename T, std::size_t Bits, storage::Ownership Ownership> class Pack
     util::ViewOrVector<WordT, Ownership> vec;
     std::uint64_t num_elements = 0;
 };
-}
+} // namespace detail
 
 template <typename T, std::size_t Bits>
 using PackedVector = detail::PackedVector<T, Bits, storage::Ownership::Container>;
 template <typename T, std::size_t Bits>
 using PackedVectorView = detail::PackedVector<T, Bits, storage::Ownership::View>;
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif /* PACKED_VECTOR_HPP */
diff --git a/include/util/percent.hpp b/include/util/percent.hpp
index 1ec1f2c13..f812558e7 100644
--- a/include/util/percent.hpp
+++ b/include/util/percent.hpp
@@ -87,7 +87,7 @@ class Percent
         }
     }
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // PERCENT_HPP
diff --git a/include/util/permutation.hpp b/include/util/permutation.hpp
index f558b1312..664889cc0 100644
--- a/include/util/permutation.hpp
+++ b/include/util/permutation.hpp
@@ -10,11 +10,22 @@ namespace osrm
 namespace util
 {
 
-template <typename RandomAccesIterator, typename IndexT>
-void inplacePermutation(RandomAccesIterator begin,
-                        RandomAccesIterator end,
+namespace permutation_detail
+{
+template <typename T> static inline void swap(T &a, T &b) { std::swap(a, b); }
+
+static inline void swap(std::vector<bool>::reference a, std::vector<bool>::reference b)
+{
+    std::vector<bool>::swap(a, b);
+}
+} // namespace permutation_detail
+
+template <typename RandomAccessIterator, typename IndexT>
+void inplacePermutation(RandomAccessIterator begin,
+                        RandomAccessIterator end,
                         const std::vector<IndexT> &old_to_new)
 {
+
     std::size_t size = std::distance(begin, end);
     BOOST_ASSERT(old_to_new.size() == size);
     // we need a little bit auxililary space since we need to mark
@@ -40,23 +51,23 @@ void inplacePermutation(RandomAccesIterator begin,
         for (; new_index != index; old_index = new_index, new_index = old_to_new[new_index])
         {
             was_replaced[old_index] = true;
-            std::swap(buffer, begin[new_index]);
+            permutation_detail::swap(buffer, begin[new_index]);
         }
         was_replaced[old_index] = true;
-        std::swap(buffer, begin[index]);
+        permutation_detail::swap(buffer, begin[index]);
     }
 }
 
 template <typename IndexT>
 std::vector<IndexT> orderingToPermutation(const std::vector<IndexT> &ordering)
 {
-    std::vector<std::uint32_t> permutation(ordering.size());
-    for (auto index : util::irange<std::uint32_t>(0, ordering.size()))
+    std::vector<IndexT> permutation(ordering.size());
+    for (auto index : util::irange<IndexT>(0, ordering.size()))
         permutation[ordering[index]] = index;
 
     return permutation;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/query_heap.hpp b/include/util/query_heap.hpp
index f4b9e626a..dc8a2ee53 100644
--- a/include/util/query_heap.hpp
+++ b/include/util/query_heap.hpp
@@ -3,6 +3,7 @@
 
 #include <boost/assert.hpp>
 #include <boost/heap/d_ary_heap.hpp>
+#include <boost/optional.hpp>
 
 #include <algorithm>
 #include <limits>
@@ -194,10 +195,26 @@ template <typename NodeID,
           typename IndexStorage = ArrayStorage<NodeID, NodeID>>
 class QueryHeap
 {
+  private:
+    using HeapData = std::pair<Weight, Key>;
+    using HeapContainer = boost::heap::d_ary_heap<HeapData,
+                                                  boost::heap::arity<4>,
+                                                  boost::heap::mutable_<true>,
+                                                  boost::heap::compare<std::greater<HeapData>>>;
+    using HeapHandle = typename HeapContainer::handle_type;
+
   public:
     using WeightType = Weight;
     using DataType = Data;
 
+    struct HeapNode
+    {
+        HeapHandle handle;
+        NodeID node;
+        Weight weight;
+        Data data;
+    };
+
     template <typename... StorageArgs> explicit QueryHeap(StorageArgs... args) : node_index(args...)
     {
         Clear();
@@ -230,6 +247,13 @@ class QueryHeap
         return inserted_nodes[index].data;
     }
 
+    HeapNode &getHeapNode(NodeID node)
+    {
+        const auto index = node_index.peek_index(node);
+        BOOST_ASSERT((int)index >= 0 && (int)index < (int)inserted_nodes.size());
+        return inserted_nodes[index];
+    }
+
     Data const &GetData(NodeID node) const
     {
         const auto index = node_index.peek_index(node);
@@ -269,6 +293,28 @@ class QueryHeap
         return inserted_nodes[index].node == node;
     }
 
+    boost::optional<HeapNode &> GetHeapNodeIfWasInserted(const NodeID node)
+    {
+        const auto index = node_index.peek_index(node);
+        if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
+            inserted_nodes[index].node != node)
+        {
+            return {};
+        }
+        return inserted_nodes[index];
+    }
+
+    boost::optional<const HeapNode &> GetHeapNodeIfWasInserted(const NodeID node) const
+    {
+        const auto index = node_index.peek_index(node);
+        if (index >= static_cast<decltype(index)>(inserted_nodes.size()) ||
+            inserted_nodes[index].node != node)
+        {
+            return {};
+        }
+        return inserted_nodes[index];
+    }
+
     NodeID Min() const
     {
         BOOST_ASSERT(!heap.empty());
@@ -290,6 +336,15 @@ class QueryHeap
         return inserted_nodes[removedIndex].node;
     }
 
+    HeapNode &DeleteMinGetHeapNode()
+    {
+        BOOST_ASSERT(!heap.empty());
+        const Key removedIndex = heap.top().second;
+        heap.pop();
+        inserted_nodes[removedIndex].handle = heap.s_handle_from_iterator(heap.end());
+        return inserted_nodes[removedIndex];
+    }
+
     void DeleteAll()
     {
         auto const none_handle = heap.s_handle_from_iterator(heap.end());
@@ -308,27 +363,18 @@ class QueryHeap
         heap.increase(reference.handle, std::make_pair(weight, index));
     }
 
-  private:
-    using HeapData = std::pair<Weight, Key>;
-    using HeapContainer = boost::heap::d_ary_heap<HeapData,
-                                                  boost::heap::arity<4>,
-                                                  boost::heap::mutable_<true>,
-                                                  boost::heap::compare<std::greater<HeapData>>>;
-    using HeapHandle = typename HeapContainer::handle_type;
-
-    struct HeapNode
+    void DecreaseKey(const HeapNode &heapNode)
     {
-        HeapHandle handle;
-        NodeID node;
-        Weight weight;
-        Data data;
-    };
+        BOOST_ASSERT(!WasRemoved(heapNode.node));
+        heap.increase(heapNode.handle, std::make_pair(heapNode.weight, (*heapNode.handle).second));
+    }
 
+  private:
     std::vector<HeapNode> inserted_nodes;
     HeapContainer heap;
     IndexStorage node_index;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // OSRM_UTIL_QUERY_HEAP_HPP
diff --git a/include/util/range_table.hpp b/include/util/range_table.hpp
index fcb732b24..aa1b89f1c 100644
--- a/include/util/range_table.hpp
+++ b/include/util/range_table.hpp
@@ -33,7 +33,7 @@ template <unsigned BlockSize, storage::Ownership Ownership>
 void read(storage::tar::FileReader &reader,
           const std::string &name,
           util::RangeTable<BlockSize, Ownership> &table);
-}
+} // namespace serialization
 
 /**
  * Stores adjacent ranges in a compressed format.
@@ -83,19 +83,25 @@ template <unsigned BLOCK_SIZE, storage::Ownership Ownership> class RangeTable
         unsigned block_idx = 0;
         unsigned block_counter = 0;
         BlockT block;
+#ifndef BOOST_ASSERT_IS_VOID
         unsigned block_sum = 0;
+#endif
         for (const unsigned l : lengths)
         {
             // first entry of a block: encode absolute offset
             if (block_idx == 0)
             {
                 block_offsets.push_back(lengths_prefix_sum);
+#ifndef BOOST_ASSERT_IS_VOID
                 block_sum = 0;
+#endif
             }
             else
             {
                 block[block_idx - 1] = last_length;
+#ifndef BOOST_ASSERT_IS_VOID
                 block_sum += last_length;
+#endif
             }
 
             BOOST_ASSERT((block_idx == 0 && block_offsets[block_counter] == lengths_prefix_sum) ||
@@ -209,7 +215,7 @@ unsigned RangeTable<BLOCK_SIZE, Ownership>::PrefixSumAtIndex(int index, const Bl
 
     return sum;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // RANGE_TABLE_HPP
diff --git a/include/util/rectangle.hpp b/include/util/rectangle.hpp
index 2b2fb83ce..eb53396d1 100644
--- a/include/util/rectangle.hpp
+++ b/include/util/rectangle.hpp
@@ -171,7 +171,7 @@ struct RectangleInt2D
                max_lat != FixedLatitude{std::numeric_limits<std::int32_t>::min()};
     }
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/serialization.hpp b/include/util/serialization.hpp
index 6245c43f0..c4205e67d 100644
--- a/include/util/serialization.hpp
+++ b/include/util/serialization.hpp
@@ -143,8 +143,8 @@ void write(storage::tar::FileWriter &writer,
     storage::serialization::write(
         writer, name + "/search_tree_level_starts", rtree.m_tree_level_starts);
 }
-}
-}
-}
+} // namespace serialization
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/static_assert.hpp b/include/util/static_assert.hpp
index 25484a57f..985324c96 100644
--- a/include/util/static_assert.hpp
+++ b/include/util/static_assert.hpp
@@ -20,7 +20,7 @@ template <typename It, typename Category> inline void static_assert_iter_categor
     static_assert(std::is_base_of<Category, IterCategoryType>::value, "");
 }
 
-} // ns util
-} // ns osrm
+} // namespace util
+} // namespace osrm
 
 #endif // OSRM_STATIC_ASSERT_HPP
diff --git a/include/util/static_graph.hpp b/include/util/static_graph.hpp
index 6092dd955..a38ba68d1 100644
--- a/include/util/static_graph.hpp
+++ b/include/util/static_graph.hpp
@@ -36,7 +36,7 @@ template <typename EdgeDataT, storage::Ownership Ownership>
 void write(storage::tar::FileWriter &writer,
            const std::string &name,
            const StaticGraph<EdgeDataT, Ownership> &graph);
-}
+} // namespace serialization
 
 namespace static_graph_details
 {
diff --git a/include/util/static_rtree.hpp b/include/util/static_rtree.hpp
index b0a3c76e3..333855974 100644
--- a/include/util/static_rtree.hpp
+++ b/include/util/static_rtree.hpp
@@ -64,7 +64,7 @@ inline void
 write(storage::tar::FileWriter &writer,
       const std::string &name,
       const util::StaticRTree<EdgeDataT, Ownership, BRANCHING_FACTOR, LEAF_PAGE_SIZE> &rtree);
-}
+} // namespace serialization
 
 /***
  * Static RTree for serving nearest neighbour queries
@@ -461,9 +461,9 @@ class StaticRTree
     template <typename = std::enable_if<Ownership == storage::Ownership::Container>>
     explicit StaticRTree(const boost::filesystem::path &on_disk_file_name,
                          const Vector<Coordinate> &coordinate_list)
-        : m_coordinate_list(coordinate_list.data(), coordinate_list.size())
+        : m_coordinate_list(coordinate_list.data(), coordinate_list.size()),
+          m_objects(mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region))
     {
-        m_objects = mmapFile<EdgeDataT>(on_disk_file_name, m_objects_region);
     }
 
     /**
@@ -559,11 +559,12 @@ class StaticRTree
     std::vector<EdgeDataT> Nearest(const Coordinate input_coordinate,
                                    const std::size_t max_results) const
     {
-        return Nearest(input_coordinate,
-                       [](const CandidateSegment &) { return std::make_pair(true, true); },
-                       [max_results](const std::size_t num_results, const CandidateSegment &) {
-                           return num_results >= max_results;
-                       });
+        return Nearest(
+            input_coordinate,
+            [](const CandidateSegment &) { return std::make_pair(true, true); },
+            [max_results](const std::size_t num_results, const CandidateSegment &) {
+                return num_results >= max_results;
+            });
     }
 
     // Override filter and terminator for the desired behaviour.
@@ -773,7 +774,7 @@ class StaticRTree
 //[2] "Nearest Neighbor Queries", N. Roussopulos et al; 1995; DOI: 10.1145/223784.223794
 //[3] "Distance Browsing in Spatial Databases"; G. Hjaltason, H. Samet; 1999; ACM Trans. DB Sys
 // Vol.24 No.2, pp.265-318
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // STATIC_RTREE_HPP
diff --git a/include/util/std_hash.hpp b/include/util/std_hash.hpp
index b456ab1ca..b4010f439 100644
--- a/include/util/std_hash.hpp
+++ b/include/util/std_hash.hpp
@@ -36,6 +36,6 @@ template <typename T1, typename T2> struct hash<std::pair<T1, T2>>
         return hash_val(pair.first, pair.second);
     }
 };
-}
+} // namespace std
 
 #endif // STD_HASH_HPP
diff --git a/include/util/string_util.hpp b/include/util/string_util.hpp
index 35a70762e..3235d4915 100644
--- a/include/util/string_util.hpp
+++ b/include/util/string_util.hpp
@@ -125,7 +125,7 @@ inline std::size_t URIDecode(const std::string &input, std::string &output)
 }
 
 inline std::size_t URIDecodeInPlace(std::string &URI) { return URIDecode(URI, URI); }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // STRING_UTIL_HPP
diff --git a/include/util/timed_histogram.hpp b/include/util/timed_histogram.hpp
index 7653ebe1f..955fe013e 100644
--- a/include/util/timed_histogram.hpp
+++ b/include/util/timed_histogram.hpp
@@ -16,7 +16,7 @@ namespace util
 namespace detail
 {
 extern std::atomic_uint operation;
-}
+} // namespace detail
 
 /**
  * Captures a histogram with a bin size of `IndexBinSize` every `TimeBinSize` count operations.
@@ -88,7 +88,7 @@ template <std::size_t TimeBinSize = 1000, std::size_t IndexBinSize = 1000> class
     std::vector<std::uint32_t> frame_offsets;
     std::vector<std::uint32_t> frame_counters;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/timezones.hpp b/include/util/timezones.hpp
index a00872064..fd7c85369 100644
--- a/include/util/timezones.hpp
+++ b/include/util/timezones.hpp
@@ -44,7 +44,7 @@ class Timezoner
     rtree_t rtree;
     std::vector<local_time_t> local_times;
 };
-}
-}
+} // namespace updater
+} // namespace osrm
 
 #endif
diff --git a/include/util/timing_util.hpp b/include/util/timing_util.hpp
index c248559df..29e9ba8d5 100644
--- a/include/util/timing_util.hpp
+++ b/include/util/timing_util.hpp
@@ -23,7 +23,7 @@ namespace util
      std::chrono::duration_cast<std::chrono::microseconds>(_X##_stop - _X##_start).count())
 #define TIMER_MIN(_X)                                                                              \
     std::chrono::duration_cast<std::chrono::minutes>(_X##_stop - _X##_start).count()
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // TIMING_UTIL_HPP
diff --git a/include/util/to_osm_link.hpp b/include/util/to_osm_link.hpp
index ee388a684..0b583041e 100644
--- a/include/util/to_osm_link.hpp
+++ b/include/util/to_osm_link.hpp
@@ -25,7 +25,7 @@ inline std::string toOSMLink(const util::Coordinate &c)
          << toFloating(c.lat) << "&mlon=" << toFloating(c.lon);
     return link.str();
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/trigonometry_table.hpp b/include/util/trigonometry_table.hpp
index 86cca41ce..c268d676f 100644
--- a/include/util/trigonometry_table.hpp
+++ b/include/util/trigonometry_table.hpp
@@ -431,7 +431,7 @@ inline double atan2_lookup(double y, double x)
     }
     return angle;
 }
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // TRIGONOMETRY_TABLE_HPP
diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp
index f29406d8b..9868ee2ff 100644
--- a/include/util/typedefs.hpp
+++ b/include/util/typedefs.hpp
@@ -48,10 +48,13 @@ struct osm_way_id
 struct duplicated_node
 {
 };
-}
+} // namespace tag
 using OSMNodeID = osrm::Alias<std::uint64_t, tag::osm_node_id>;
+// clang-tidy fires `bugprone-throw-keyword-missing` here for unknown reason
+// NOLINTNEXTLINE(bugprone-throw-keyword-missing)
 static_assert(std::is_pod<OSMNodeID>(), "OSMNodeID is not a valid alias");
 using OSMWayID = osrm::Alias<std::uint64_t, tag::osm_way_id>;
+// NOLINTNEXTLINE(bugprone-throw-keyword-missing)
 static_assert(std::is_pod<OSMWayID>(), "OSMWayID is not a valid alias");
 
 using DuplicatedNodeID = std::uint64_t;
@@ -103,6 +106,7 @@ static const NodeID SPECIAL_NODEID = std::numeric_limits<NodeID>::max();
 static const NodeID SPECIAL_SEGMENTID = std::numeric_limits<NodeID>::max() >> 1;
 static const NodeID SPECIAL_GEOMETRYID = std::numeric_limits<NodeID>::max() >> 1;
 static const EdgeID SPECIAL_EDGEID = std::numeric_limits<EdgeID>::max();
+static const RestrictionID SPECIAL_RESTRICTIONID = std::numeric_limits<RestrictionID>::max();
 static const NameID INVALID_NAMEID = std::numeric_limits<NameID>::max();
 static const NameID EMPTY_NAMEID = 0;
 static const unsigned INVALID_COMPONENTID = 0;
diff --git a/include/util/vector_tile.hpp b/include/util/vector_tile.hpp
index d3d4978b1..9d4ae6e36 100644
--- a/include/util/vector_tile.hpp
+++ b/include/util/vector_tile.hpp
@@ -12,7 +12,7 @@ namespace vector_tile
 // Vector tiles are 4096 virtual pixels on each side
 const constexpr double EXTENT = 4096.0;
 const constexpr double BUFFER = 128.0;
-}
-}
-}
+} // namespace vector_tile
+} // namespace util
+} // namespace osrm
 #endif
diff --git a/include/util/vector_view.hpp b/include/util/vector_view.hpp
index 288029a70..3d9a2e2c1 100644
--- a/include/util/vector_view.hpp
+++ b/include/util/vector_view.hpp
@@ -268,7 +268,7 @@ struct is_view_or_vector
                                  std::is_same<util::vector_view<ValueT>, VectorT>::value>
 {
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // SHARED_MEMORY_VECTOR_WRAPPER_HPP
diff --git a/include/util/viewport.hpp b/include/util/viewport.hpp
index 211aa5745..acd0d03c9 100644
--- a/include/util/viewport.hpp
+++ b/include/util/viewport.hpp
@@ -25,8 +25,8 @@ static constexpr unsigned MIN_ZOOM = 1;
 // this is an upper bound to current display sizes
 static constexpr double VIEWPORT_WIDTH = 8 * web_mercator::TILE_SIZE;
 static constexpr double VIEWPORT_HEIGHT = 5 * web_mercator::TILE_SIZE;
-static double INV_LOG_2 = 1. / std::log(2);
-}
+static const double INV_LOG_2 = 1. / std::log(2);
+} // namespace detail
 
 inline unsigned getFittedZoom(util::Coordinate south_west, util::Coordinate north_east)
 {
@@ -44,8 +44,8 @@ inline unsigned getFittedZoom(util::Coordinate south_west, util::Coordinate nort
     else
         return detail::MIN_ZOOM;
 }
-}
-}
-}
+} // namespace viewport
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/web_mercator.hpp b/include/util/web_mercator.hpp
index 247e97e07..bb959a70d 100644
--- a/include/util/web_mercator.hpp
+++ b/include/util/web_mercator.hpp
@@ -22,7 +22,7 @@ const constexpr double MAXEXTENT = EARTH_RADIUS_WGS84 * boost::math::constants::
 // ^ math functions are not constexpr since they have side-effects (setting errno) :(
 const constexpr double EPSG3857_MAX_LATITUDE = 85.051128779806592378; // 90(4*atan(exp(pi))/pi-1)
 const constexpr double MAX_LONGITUDE = 180.0;
-}
+} // namespace detail
 
 // Converts projected mercator degrees to PX
 const constexpr double DEGREE_TO_PX = detail::MAXEXTENT / 180.0;
@@ -169,8 +169,8 @@ inline void xyzToMercator(
     maxx = static_cast<double>(clamp(util::FloatLongitude{maxx})) * DEGREE_TO_PX;
     maxy = latToY(util::FloatLatitude{maxy}) * DEGREE_TO_PX;
 }
-}
-}
-}
+} // namespace web_mercator
+} // namespace util
+} // namespace osrm
 
 #endif
diff --git a/include/util/xor_fast_hash.hpp b/include/util/xor_fast_hash.hpp
index 0f2f3ba78..97a83fcd4 100644
--- a/include/util/xor_fast_hash.hpp
+++ b/include/util/xor_fast_hash.hpp
@@ -65,7 +65,7 @@ template <std::size_t MaxNumElements = (1u << 16u)> class XORFastHash
         return table1[lsb] ^ table2[msb];
     }
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // XOR_FAST_HASH_HPP
diff --git a/include/util/xor_fast_hash_storage.hpp b/include/util/xor_fast_hash_storage.hpp
index 6d2d76baa..4746a5891 100644
--- a/include/util/xor_fast_hash_storage.hpp
+++ b/include/util/xor_fast_hash_storage.hpp
@@ -78,7 +78,7 @@ class XORFastHashStorage
     XORFastHash<MaxNumElements> fast_hasher;
     unsigned current_timestamp;
 };
-}
-}
+} // namespace util
+} // namespace osrm
 
 #endif // XOR_FAST_HASH_STORAGE_HPP
diff --git a/package-lock.json b/package-lock.json
index 461bc1231..58013b645 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,29 +1,144 @@
 {
   "name": "osrm",
-  "version": "5.24.0-unreleased",
+  "version": "5.27.0-unreleased",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
-    "@babel/code-frame": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.44.tgz",
-      "integrity": "sha512-cuAuTTIQ9RqcFRJ/Y8PvTh+paepNcaGxwQwjIDRWPXmzzyAeCO4KqS9ikMvq0MCbRk6GlYKwfzStrcP3/jSL8g==",
+    "@babel/cli": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/cli/-/cli-7.14.5.tgz",
+      "integrity": "sha512-poegjhRvXHWO0EAsnYajwYZuqcz7gyfxwfaecUESxDujrqOivf3zrjFbub8IJkrqEaz3fvJWh001EzxBub54fg==",
       "dev": true,
       "requires": {
-        "@babel/highlight": "7.0.0-beta.44"
+        "@nicolo-ribaudo/chokidar-2": "2.1.8-no-fsevents.2",
+        "chokidar": "^3.4.0",
+        "commander": "^4.0.1",
+        "convert-source-map": "^1.1.0",
+        "fs-readdir-recursive": "^1.1.0",
+        "glob": "^7.0.0",
+        "make-dir": "^2.1.0",
+        "slash": "^2.0.0",
+        "source-map": "^0.5.0"
+      },
+      "dependencies": {
+        "commander": {
+          "version": "4.1.1",
+          "resolved": "https://registry.npmjs.org/commander/-/commander-4.1.1.tgz",
+          "integrity": "sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==",
+          "dev": true
+        },
+        "make-dir": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-2.1.0.tgz",
+          "integrity": "sha512-LS9X+dc8KLxXCb8dni79fLIIUA5VyZoyjSMCwTluaXA0o27cCK0bhXkpgw+sTXVpPy/lSO57ilRixqk0vDmtRA==",
+          "dev": true,
+          "requires": {
+            "pify": "^4.0.1",
+            "semver": "^5.6.0"
+          }
+        },
+        "pify": {
+          "version": "4.0.1",
+          "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz",
+          "integrity": "sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==",
+          "dev": true
+        },
+        "semver": {
+          "version": "5.7.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/code-frame": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.14.5.tgz",
+      "integrity": "sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==",
+      "dev": true,
+      "requires": {
+        "@babel/highlight": "^7.14.5"
+      }
+    },
+    "@babel/compat-data": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.14.5.tgz",
+      "integrity": "sha512-kixrYn4JwfAVPa0f2yfzc2AWti6WRRyO3XjWW5PJAvtE11qhSayrrcrEnee05KAtNaPC+EwehE8Qt1UedEVB8w==",
+      "dev": true
+    },
+    "@babel/core": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.14.6.tgz",
+      "integrity": "sha512-gJnOEWSqTk96qG5BoIrl5bVtc23DCycmIePPYnamY9RboYdI4nFy5vAQMSl81O5K/W0sLDWfGysnOECC+KUUCA==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.14.5",
+        "@babel/generator": "^7.14.5",
+        "@babel/helper-compilation-targets": "^7.14.5",
+        "@babel/helper-module-transforms": "^7.14.5",
+        "@babel/helpers": "^7.14.6",
+        "@babel/parser": "^7.14.6",
+        "@babel/template": "^7.14.5",
+        "@babel/traverse": "^7.14.5",
+        "@babel/types": "^7.14.5",
+        "convert-source-map": "^1.7.0",
+        "debug": "^4.1.0",
+        "gensync": "^1.0.0-beta.2",
+        "json5": "^2.1.2",
+        "semver": "^6.3.0",
+        "source-map": "^0.5.0"
+      },
+      "dependencies": {
+        "convert-source-map": {
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz",
+          "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.1.1"
+          }
+        },
+        "debug": {
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "json5": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.0.tgz",
+          "integrity": "sha512-f+8cldu7X/y7RAJurMEJmdoKXGB/X550w2Nr3tTbezL6RwEE/iMcm+tZnXeoZtKuOq6ft8+CqzEkrIgx1fPoQA==",
+          "dev": true,
+          "requires": {
+            "minimist": "^1.2.5"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+          "dev": true
+        },
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+          "dev": true
+        }
       }
     },
     "@babel/generator": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/generator/-/generator-7.0.0-beta.44.tgz",
-      "integrity": "sha512-5xVb7hlhjGcdkKpMXgicAVgx8syK5VJz193k0i/0sLP6DzE6lRrU1K3B/rFefgdo9LPGMAOOOAWW4jycj07ShQ==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.14.5.tgz",
+      "integrity": "sha512-y3rlP+/G25OIX3mYKKIOlQRcqj7YgrvHxOLbVmyLJ9bPmi5ttvUmpydVjcFjZphOktWuA7ovbx91ECloWTfjIA==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.0.0-beta.44",
+        "@babel/types": "^7.14.5",
         "jsesc": "^2.5.1",
-        "lodash": "^4.2.0",
-        "source-map": "^0.5.0",
-        "trim-right": "^1.0.1"
+        "source-map": "^0.5.0"
       },
       "dependencies": {
         "jsesc": {
@@ -34,46 +149,342 @@
         }
       }
     },
-    "@babel/helper-function-name": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.0.0-beta.44.tgz",
-      "integrity": "sha512-MHRG2qZMKMFaBavX0LWpfZ2e+hLloT++N7rfM3DYOMUOGCD8cVjqZpwiL8a0bOX3IYcQev1ruciT0gdFFRTxzg==",
+    "@babel/helper-annotate-as-pure": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.14.5.tgz",
+      "integrity": "sha512-EivH9EgBIb+G8ij1B2jAwSH36WnGvkQSEC6CkX/6v6ZFlw5fVOHvsgGF4uiEHO2GzMvunZb6tDLQEQSdrdocrA==",
       "dev": true,
       "requires": {
-        "@babel/helper-get-function-arity": "7.0.0-beta.44",
-        "@babel/template": "7.0.0-beta.44",
-        "@babel/types": "7.0.0-beta.44"
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-builder-binary-assignment-operator-visitor": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.14.5.tgz",
+      "integrity": "sha512-YTA/Twn0vBXDVGJuAX6PwW7x5zQei1luDDo2Pl6q1qZ7hVNl0RZrhHCQG/ArGpR29Vl7ETiB8eJyrvpuRp300w==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-explode-assignable-expression": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-compilation-targets": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.5.tgz",
+      "integrity": "sha512-v+QtZqXEiOnpO6EYvlImB6zCD2Lel06RzOPzmkz/D/XgQiUu3C/Jb1LOqSt/AIA34TYi/Q+KlT8vTQrgdxkbLw==",
+      "dev": true,
+      "requires": {
+        "@babel/compat-data": "^7.14.5",
+        "@babel/helper-validator-option": "^7.14.5",
+        "browserslist": "^4.16.6",
+        "semver": "^6.3.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/helper-create-class-features-plugin": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.14.6.tgz",
+      "integrity": "sha512-Z6gsfGofTxH/+LQXqYEK45kxmcensbzmk/oi8DmaQytlQCgqNZt9XQF8iqlI/SeXWVjaMNxvYvzaYw+kh42mDg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-function-name": "^7.14.5",
+        "@babel/helper-member-expression-to-functions": "^7.14.5",
+        "@babel/helper-optimise-call-expression": "^7.14.5",
+        "@babel/helper-replace-supers": "^7.14.5",
+        "@babel/helper-split-export-declaration": "^7.14.5"
+      }
+    },
+    "@babel/helper-create-regexp-features-plugin": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.14.5.tgz",
+      "integrity": "sha512-TLawwqpOErY2HhWbGJ2nZT5wSkR192QpN+nBg1THfBfftrlvOh+WbhrxXCH4q4xJ9Gl16BGPR/48JA+Ryiho/A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "regexpu-core": "^4.7.1"
+      },
+      "dependencies": {
+        "jsesc": {
+          "version": "0.5.0",
+          "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-0.5.0.tgz",
+          "integrity": "sha1-597mbjXW/Bb3EP6R1c9p9w8IkR0=",
+          "dev": true
+        },
+        "regexpu-core": {
+          "version": "4.7.1",
+          "resolved": "https://registry.npmjs.org/regexpu-core/-/regexpu-core-4.7.1.tgz",
+          "integrity": "sha512-ywH2VUraA44DZQuRKzARmw6S66mr48pQVva4LBeRhcOltJ6hExvWly5ZjFLYo67xbIxb6W1q4bAGtgfEl20zfQ==",
+          "dev": true,
+          "requires": {
+            "regenerate": "^1.4.0",
+            "regenerate-unicode-properties": "^8.2.0",
+            "regjsgen": "^0.5.1",
+            "regjsparser": "^0.6.4",
+            "unicode-match-property-ecmascript": "^1.0.4",
+            "unicode-match-property-value-ecmascript": "^1.2.0"
+          }
+        },
+        "regjsgen": {
+          "version": "0.5.2",
+          "resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.2.tgz",
+          "integrity": "sha512-OFFT3MfrH90xIW8OOSyUrk6QHD5E9JOTeGodiJeBS3J6IwlgzJMNE/1bZklWz5oTg+9dCMyEetclvCVXOPoN3A==",
+          "dev": true
+        },
+        "regjsparser": {
+          "version": "0.6.9",
+          "resolved": "https://registry.npmjs.org/regjsparser/-/regjsparser-0.6.9.tgz",
+          "integrity": "sha512-ZqbNRz1SNjLAiYuwY0zoXW8Ne675IX5q+YHioAGbCw4X96Mjl2+dcX9B2ciaeyYjViDAfvIjFpQjJgLttTEERQ==",
+          "dev": true,
+          "requires": {
+            "jsesc": "~0.5.0"
+          }
+        }
+      }
+    },
+    "@babel/helper-define-polyfill-provider": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.2.3.tgz",
+      "integrity": "sha512-RH3QDAfRMzj7+0Nqu5oqgO5q9mFtQEVvCRsi8qCEfzLR9p2BHfn5FzhSB2oj1fF7I2+DcTORkYaQ6aTR9Cofew==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-compilation-targets": "^7.13.0",
+        "@babel/helper-module-imports": "^7.12.13",
+        "@babel/helper-plugin-utils": "^7.13.0",
+        "@babel/traverse": "^7.13.0",
+        "debug": "^4.1.1",
+        "lodash.debounce": "^4.0.8",
+        "resolve": "^1.14.2",
+        "semver": "^6.1.2"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+          "dev": true
+        },
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/helper-explode-assignable-expression": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.14.5.tgz",
+      "integrity": "sha512-Htb24gnGJdIGT4vnRKMdoXiOIlqOLmdiUYpAQ0mYfgVT/GDm8GOYhgi4GL+hMKrkiPRohO4ts34ELFsGAPQLDQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-function-name": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.14.5.tgz",
+      "integrity": "sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-get-function-arity": "^7.14.5",
+        "@babel/template": "^7.14.5",
+        "@babel/types": "^7.14.5"
       }
     },
     "@babel/helper-get-function-arity": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0-beta.44.tgz",
-      "integrity": "sha512-w0YjWVwrM2HwP6/H3sEgrSQdkCaxppqFeJtAnB23pRiJB5E/O9Yp7JAAeWBl+gGEgmBFinnTyOv2RN7rcSmMiw==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.14.5.tgz",
+      "integrity": "sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.0.0-beta.44"
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-hoist-variables": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.14.5.tgz",
+      "integrity": "sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-member-expression-to-functions": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.14.5.tgz",
+      "integrity": "sha512-UxUeEYPrqH1Q/k0yRku1JE7dyfyehNwT6SVkMHvYvPDv4+uu627VXBckVj891BO8ruKBkiDoGnZf4qPDD8abDQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-module-imports": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.14.5.tgz",
+      "integrity": "sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-module-transforms": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.14.5.tgz",
+      "integrity": "sha512-iXpX4KW8LVODuAieD7MzhNjmM6dzYY5tfRqT+R9HDXWl0jPn/djKmA+G9s/2C2T9zggw5tK1QNqZ70USfedOwA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-module-imports": "^7.14.5",
+        "@babel/helper-replace-supers": "^7.14.5",
+        "@babel/helper-simple-access": "^7.14.5",
+        "@babel/helper-split-export-declaration": "^7.14.5",
+        "@babel/helper-validator-identifier": "^7.14.5",
+        "@babel/template": "^7.14.5",
+        "@babel/traverse": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      },
+      "dependencies": {
+        "@babel/helper-validator-identifier": {
+          "version": "7.14.5",
+          "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz",
+          "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/helper-optimise-call-expression": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.14.5.tgz",
+      "integrity": "sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-plugin-utils": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.14.5.tgz",
+      "integrity": "sha512-/37qQCE3K0vvZKwoK4XU/irIJQdIfCJuhU5eKnNxpFDsOkgFaUAwbv+RYw6eYgsC0E4hS7r5KqGULUogqui0fQ==",
+      "dev": true
+    },
+    "@babel/helper-remap-async-to-generator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.14.5.tgz",
+      "integrity": "sha512-rLQKdQU+HYlxBwQIj8dk4/0ENOUEhA/Z0l4hN8BexpvmSMN9oA9EagjnhnDpNsRdWCfjwa4mn/HyBXO9yhQP6A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-wrap-function": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-replace-supers": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.14.5.tgz",
+      "integrity": "sha512-3i1Qe9/8x/hCHINujn+iuHy+mMRLoc77b2nI9TB0zjH1hvn9qGlXjWlggdwUcju36PkPCy/lpM7LLUdcTyH4Ow==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-member-expression-to-functions": "^7.14.5",
+        "@babel/helper-optimise-call-expression": "^7.14.5",
+        "@babel/traverse": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-simple-access": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.14.5.tgz",
+      "integrity": "sha512-nfBN9xvmCt6nrMZjfhkl7i0oTV3yxR4/FztsbOASyTvVcoYd0TRHh7eMLdlEcCqobydC0LAF3LtC92Iwxo0wyw==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-skip-transparent-expression-wrappers": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.14.5.tgz",
+      "integrity": "sha512-dmqZB7mrb94PZSAOYtr+ZN5qt5owZIAgqtoTuqiFbHFtxgEcmQlRJVI+bO++fciBunXtB6MK7HrzrfcAzIz2NQ==",
+      "dev": true,
+      "requires": {
+        "@babel/types": "^7.14.5"
       }
     },
     "@babel/helper-split-export-declaration": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0-beta.44.tgz",
-      "integrity": "sha512-aQ7QowtkgKKzPGf0j6u77kBMdUFVBKNHw2p/3HX/POt5/oz8ec5cs0GwlgM8Hz7ui5EwJnzyfRmkNF1Nx1N7aA==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.14.5.tgz",
+      "integrity": "sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA==",
       "dev": true,
       "requires": {
-        "@babel/types": "7.0.0-beta.44"
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helper-validator-identifier": {
+      "version": "7.12.11",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz",
+      "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==",
+      "dev": true
+    },
+    "@babel/helper-validator-option": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.14.5.tgz",
+      "integrity": "sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow==",
+      "dev": true
+    },
+    "@babel/helper-wrap-function": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.14.5.tgz",
+      "integrity": "sha512-YEdjTCq+LNuNS1WfxsDCNpgXkJaIyqco6DAelTUjT4f2KIWC1nBcaCaSdHTBqQVLnTBexBcVcFhLSU1KnYuePQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-function-name": "^7.14.5",
+        "@babel/template": "^7.14.5",
+        "@babel/traverse": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/helpers": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.14.6.tgz",
+      "integrity": "sha512-yesp1ENQBiLI+iYHSJdoZKUtRpfTlL1grDIX9NRlAVppljLw/4tTyYupIB7uIYmC3stW/imAv8EqaKaS/ibmeA==",
+      "dev": true,
+      "requires": {
+        "@babel/template": "^7.14.5",
+        "@babel/traverse": "^7.14.5",
+        "@babel/types": "^7.14.5"
       }
     },
     "@babel/highlight": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0-beta.44.tgz",
-      "integrity": "sha512-Il19yJvy7vMFm8AVAh6OZzaFoAd0hbkeMZiX3P5HGD+z7dyI7RzndHB0dg6Urh/VAFfHtpOIzDUSxmY6coyZWQ==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.5.tgz",
+      "integrity": "sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==",
       "dev": true,
       "requires": {
+        "@babel/helper-validator-identifier": "^7.14.5",
         "chalk": "^2.0.0",
-        "esutils": "^2.0.2",
-        "js-tokens": "^3.0.0"
+        "js-tokens": "^4.0.0"
       },
       "dependencies": {
+        "@babel/helper-validator-identifier": {
+          "version": "7.14.5",
+          "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz",
+          "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==",
+          "dev": true
+        },
         "ansi-styles": {
           "version": "3.2.1",
           "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
@@ -84,9 +495,9 @@
           }
         },
         "chalk": {
-          "version": "2.4.1",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-          "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.1",
@@ -94,10 +505,10 @@
             "supports-color": "^5.3.0"
           }
         },
-        "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+        "js-tokens": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+          "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
           "dev": true
         },
         "supports-color": {
@@ -111,84 +522,896 @@
         }
       }
     },
-    "@babel/template": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/template/-/template-7.0.0-beta.44.tgz",
-      "integrity": "sha512-w750Sloq0UNifLx1rUqwfbnC6uSUk0mfwwgGRfdLiaUzfAOiH0tHJE6ILQIUi3KYkjiCDTskoIsnfqZvWLBDng==",
+    "@babel/parser": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.14.6.tgz",
+      "integrity": "sha512-oG0ej7efjEXxb4UgE+klVx+3j4MVo+A2vCzm7OUN4CLo6WhQ+vSOD2yJ8m7B+DghObxtLxt3EfgMWpq+AsWehQ==",
+      "dev": true
+    },
+    "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.14.5.tgz",
+      "integrity": "sha512-ZoJS2XCKPBfTmL122iP6NM9dOg+d4lc9fFk3zxc8iDjvt8Pk4+TlsHSKhIPf6X+L5ORCdBzqMZDjL/WHj7WknQ==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "7.0.0-beta.44",
-        "@babel/types": "7.0.0-beta.44",
-        "babylon": "7.0.0-beta.44",
-        "lodash": "^4.2.0"
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5",
+        "@babel/plugin-proposal-optional-chaining": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-async-generator-functions": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.14.5.tgz",
+      "integrity": "sha512-tbD/CG3l43FIXxmu4a7RBe4zH7MLJ+S/lFowPFO7HetS2hyOZ/0nnnznegDuzFzfkyQYTxqdTH/hKmuBngaDAA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-remap-async-to-generator": "^7.14.5",
+        "@babel/plugin-syntax-async-generators": "^7.8.4"
+      }
+    },
+    "@babel/plugin-proposal-class-properties": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.14.5.tgz",
+      "integrity": "sha512-q/PLpv5Ko4dVc1LYMpCY7RVAAO4uk55qPwrIuJ5QJ8c6cVuAmhu7I/49JOppXL6gXf7ZHzpRVEUZdYoPLM04Gg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-class-static-block": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.14.5.tgz",
+      "integrity": "sha512-KBAH5ksEnYHCegqseI5N9skTdxgJdmDoAOc0uXa+4QMYKeZD0w5IARh4FMlTNtaHhbB8v+KzMdTgxMMzsIy6Yg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-class-static-block": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-dynamic-import": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.14.5.tgz",
+      "integrity": "sha512-ExjiNYc3HDN5PXJx+bwC50GIx/KKanX2HiggnIUAYedbARdImiCU4RhhHfdf0Kd7JNXGpsBBBCOm+bBVy3Gb0g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-export-namespace-from": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.14.5.tgz",
+      "integrity": "sha512-g5POA32bXPMmSBu5Dx/iZGLGnKmKPc5AiY7qfZgurzrCYgIztDlHFbznSNCoQuv57YQLnQfaDi7dxCtLDIdXdA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-export-namespace-from": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-json-strings": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.14.5.tgz",
+      "integrity": "sha512-NSq2fczJYKVRIsUJyNxrVUMhB27zb7N7pOFGQOhBKJrChbGcgEAqyZrmZswkPk18VMurEeJAaICbfm57vUeTbQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-json-strings": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-logical-assignment-operators": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.14.5.tgz",
+      "integrity": "sha512-YGn2AvZAo9TwyhlLvCCWxD90Xq8xJ4aSgaX3G5D/8DW94L8aaT+dS5cSP+Z06+rCJERGSr9GxMBZ601xoc2taw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4"
+      }
+    },
+    "@babel/plugin-proposal-nullish-coalescing-operator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.14.5.tgz",
+      "integrity": "sha512-gun/SOnMqjSb98Nkaq2rTKMwervfdAoz6NphdY0vTfuzMfryj+tDGb2n6UkDKwez+Y8PZDhE3D143v6Gepp4Hg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-numeric-separator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.14.5.tgz",
+      "integrity": "sha512-yiclALKe0vyZRZE0pS6RXgjUOt87GWv6FYa5zqj15PvhOGFO69R5DusPlgK/1K5dVnCtegTiWu9UaBSrLLJJBg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-numeric-separator": "^7.10.4"
+      }
+    },
+    "@babel/plugin-proposal-object-rest-spread": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.14.5.tgz",
+      "integrity": "sha512-VzMyY6PWNPPT3pxc5hi9LloKNr4SSrVCg7Yr6aZpW4Ym07r7KqSU/QXYwjXLVxqwSv0t/XSXkFoKBPUkZ8vb2A==",
+      "dev": true,
+      "requires": {
+        "@babel/compat-data": "^7.14.5",
+        "@babel/helper-compilation-targets": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+        "@babel/plugin-transform-parameters": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-optional-catch-binding": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.14.5.tgz",
+      "integrity": "sha512-3Oyiixm0ur7bzO5ybNcZFlmVsygSIQgdOa7cTfOYCMY+wEPAYhZAJxi3mixKFCTCKUhQXuCTtQ1MzrpL3WT8ZQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-optional-chaining": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.14.5.tgz",
+      "integrity": "sha512-ycz+VOzo2UbWNI1rQXxIuMOzrDdHGrI23fRiz/Si2R4kv2XZQ1BK8ccdHwehMKBlcH/joGW/tzrUmo67gbJHlQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5",
+        "@babel/plugin-syntax-optional-chaining": "^7.8.3"
+      }
+    },
+    "@babel/plugin-proposal-private-methods": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.14.5.tgz",
+      "integrity": "sha512-838DkdUA1u+QTCplatfq4B7+1lnDa/+QMI89x5WZHBcnNv+47N8QEj2k9I2MUU9xIv8XJ4XvPCviM/Dj7Uwt9g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-class-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-private-property-in-object": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.14.5.tgz",
+      "integrity": "sha512-62EyfyA3WA0mZiF2e2IV9mc9Ghwxcg8YTu8BS4Wss4Y3PY725OmS9M0qLORbJwLqFtGh+jiE4wAmocK2CTUK2Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-create-class-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-private-property-in-object": "^7.14.5"
+      }
+    },
+    "@babel/plugin-proposal-unicode-property-regex": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.14.5.tgz",
+      "integrity": "sha512-6axIeOU5LnY471KenAB9vI8I5j7NQ2d652hIYwVyRfgaZT5UpiqFKCuVXCDMSrU+3VFafnu2c5m3lrWIlr6A5Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-syntax-async-generators": {
+      "version": "7.8.4",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-async-generators/-/plugin-syntax-async-generators-7.8.4.tgz",
+      "integrity": "sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-class-properties": {
+      "version": "7.12.13",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-properties/-/plugin-syntax-class-properties-7.12.13.tgz",
+      "integrity": "sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.12.13"
+      }
+    },
+    "@babel/plugin-syntax-class-static-block": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz",
+      "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-syntax-dynamic-import": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz",
+      "integrity": "sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-export-namespace-from": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-export-namespace-from/-/plugin-syntax-export-namespace-from-7.8.3.tgz",
+      "integrity": "sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.3"
+      }
+    },
+    "@babel/plugin-syntax-json-strings": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-json-strings/-/plugin-syntax-json-strings-7.8.3.tgz",
+      "integrity": "sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-jsx": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-jsx/-/plugin-syntax-jsx-7.14.5.tgz",
+      "integrity": "sha512-ohuFIsOMXJnbOMRfX7/w7LocdR6R7whhuRD4ax8IipLcLPlZGJKkBxgHp++U4N/vKyU16/YDQr2f5seajD3jIw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-syntax-logical-assignment-operators": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-logical-assignment-operators/-/plugin-syntax-logical-assignment-operators-7.10.4.tgz",
+      "integrity": "sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      }
+    },
+    "@babel/plugin-syntax-nullish-coalescing-operator": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-nullish-coalescing-operator/-/plugin-syntax-nullish-coalescing-operator-7.8.3.tgz",
+      "integrity": "sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-numeric-separator": {
+      "version": "7.10.4",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-numeric-separator/-/plugin-syntax-numeric-separator-7.10.4.tgz",
+      "integrity": "sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.10.4"
+      }
+    },
+    "@babel/plugin-syntax-object-rest-spread": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-object-rest-spread/-/plugin-syntax-object-rest-spread-7.8.3.tgz",
+      "integrity": "sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-optional-catch-binding": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-catch-binding/-/plugin-syntax-optional-catch-binding-7.8.3.tgz",
+      "integrity": "sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-optional-chaining": {
+      "version": "7.8.3",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-optional-chaining/-/plugin-syntax-optional-chaining-7.8.3.tgz",
+      "integrity": "sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.8.0"
+      }
+    },
+    "@babel/plugin-syntax-private-property-in-object": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz",
+      "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-syntax-top-level-await": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz",
+      "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-arrow-functions": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.14.5.tgz",
+      "integrity": "sha512-KOnO0l4+tD5IfOdi4x8C1XmEIRWUjNRV8wc6K2vz/3e8yAOoZZvsRXRRIF/yo/MAOFb4QjtAw9xSxMXbSMRy8A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-async-to-generator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.14.5.tgz",
+      "integrity": "sha512-szkbzQ0mNk0rpu76fzDdqSyPu0MuvpXgC+6rz5rpMb5OIRxdmHfQxrktL8CYolL2d8luMCZTR0DpIMIdL27IjA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-module-imports": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-remap-async-to-generator": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-block-scoped-functions": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.14.5.tgz",
+      "integrity": "sha512-dtqWqdWZ5NqBX3KzsVCWfQI3A53Ft5pWFCT2eCVUftWZgjc5DpDponbIF1+c+7cSGk2wN0YK7HGL/ezfRbpKBQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-block-scoping": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.14.5.tgz",
+      "integrity": "sha512-LBYm4ZocNgoCqyxMLoOnwpsmQ18HWTQvql64t3GvMUzLQrNoV1BDG0lNftC8QKYERkZgCCT/7J5xWGObGAyHDw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-classes": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.14.5.tgz",
+      "integrity": "sha512-J4VxKAMykM06K/64z9rwiL6xnBHgB1+FVspqvlgCdwD1KUbQNfszeKVVOMh59w3sztHYIZDgnhOC4WbdEfHFDA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-function-name": "^7.14.5",
+        "@babel/helper-optimise-call-expression": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-replace-supers": "^7.14.5",
+        "@babel/helper-split-export-declaration": "^7.14.5",
+        "globals": "^11.1.0"
       },
       "dependencies": {
-        "babylon": {
-          "version": "7.0.0-beta.44",
-          "resolved": "http://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz",
-          "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==",
+        "globals": {
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
           "dev": true
         }
       }
     },
-    "@babel/traverse": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/traverse/-/traverse-7.0.0-beta.44.tgz",
-      "integrity": "sha512-UHuDz8ukQkJCDASKHf+oDt3FVUzFd+QYfuBIsiNu/4+/ix6pP/C+uQZJ6K1oEfbCMv/IKWbgDEh7fcsnIE5AtA==",
+    "@babel/plugin-transform-computed-properties": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.14.5.tgz",
+      "integrity": "sha512-pWM+E4283UxaVzLb8UBXv4EIxMovU4zxT1OPnpHJcmnvyY9QbPPTKZfEj31EUvG3/EQRbYAGaYEUZ4yWOBC2xg==",
       "dev": true,
       "requires": {
-        "@babel/code-frame": "7.0.0-beta.44",
-        "@babel/generator": "7.0.0-beta.44",
-        "@babel/helper-function-name": "7.0.0-beta.44",
-        "@babel/helper-split-export-declaration": "7.0.0-beta.44",
-        "@babel/types": "7.0.0-beta.44",
-        "babylon": "7.0.0-beta.44",
-        "debug": "^3.1.0",
-        "globals": "^11.1.0",
-        "invariant": "^2.2.0",
-        "lodash": "^4.2.0"
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-destructuring": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.14.5.tgz",
+      "integrity": "sha512-wU9tYisEbRMxqDezKUqC9GleLycCRoUsai9ddlsq54r8QRLaeEhc+d+9DqCG+kV9W2GgQjTZESPTpn5bAFMDww==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-dotall-regex": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.14.5.tgz",
+      "integrity": "sha512-loGlnBdj02MDsFaHhAIJzh7euK89lBrGIdM9EAtHFo6xKygCUGuuWe07o1oZVk287amtW1n0808sQM99aZt3gw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-duplicate-keys": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.14.5.tgz",
+      "integrity": "sha512-iJjbI53huKbPDAsJ8EmVmvCKeeq21bAze4fu9GBQtSLqfvzj2oRuHVx4ZkDwEhg1htQ+5OBZh/Ab0XDf5iBZ7A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-exponentiation-operator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.14.5.tgz",
+      "integrity": "sha512-jFazJhMBc9D27o9jDnIE5ZErI0R0m7PbKXVq77FFvqFbzvTMuv8jaAwLZ5PviOLSFttqKIW0/wxNSDbjLk0tYA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-builder-binary-assignment-operator-visitor": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-for-of": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.14.5.tgz",
+      "integrity": "sha512-CfmqxSUZzBl0rSjpoQSFoR9UEj3HzbGuGNL21/iFTmjb5gFggJp3ph0xR1YBhexmLoKRHzgxuFvty2xdSt6gTA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-function-name": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.14.5.tgz",
+      "integrity": "sha512-vbO6kv0fIzZ1GpmGQuvbwwm+O4Cbm2NrPzwlup9+/3fdkuzo1YqOZcXw26+YUJB84Ja7j9yURWposEHLYwxUfQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-function-name": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-literals": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.14.5.tgz",
+      "integrity": "sha512-ql33+epql2F49bi8aHXxvLURHkxJbSmMKl9J5yHqg4PLtdE6Uc48CH1GS6TQvZ86eoB/ApZXwm7jlA+B3kra7A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-member-expression-literals": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.14.5.tgz",
+      "integrity": "sha512-WkNXxH1VXVTKarWFqmso83xl+2V3Eo28YY5utIkbsmXoItO8Q3aZxN4BTS2k0hz9dGUloHK26mJMyQEYfkn/+Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-modules-amd": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.14.5.tgz",
+      "integrity": "sha512-3lpOU8Vxmp3roC4vzFpSdEpGUWSMsHFreTWOMMLzel2gNGfHE5UWIh/LN6ghHs2xurUp4jRFYMUIZhuFbody1g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-module-transforms": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "babel-plugin-dynamic-import-node": "^2.3.3"
+      }
+    },
+    "@babel/plugin-transform-modules-commonjs": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.14.5.tgz",
+      "integrity": "sha512-en8GfBtgnydoao2PS+87mKyw62k02k7kJ9ltbKe0fXTHrQmG6QZZflYuGI1VVG7sVpx4E1n7KBpNlPb8m78J+A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-module-transforms": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-simple-access": "^7.14.5",
+        "babel-plugin-dynamic-import-node": "^2.3.3"
+      }
+    },
+    "@babel/plugin-transform-modules-systemjs": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.14.5.tgz",
+      "integrity": "sha512-mNMQdvBEE5DcMQaL5LbzXFMANrQjd2W7FPzg34Y4yEz7dBgdaC+9B84dSO+/1Wba98zoDbInctCDo4JGxz1VYA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-hoist-variables": "^7.14.5",
+        "@babel/helper-module-transforms": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-validator-identifier": "^7.14.5",
+        "babel-plugin-dynamic-import-node": "^2.3.3"
       },
       "dependencies": {
-        "babylon": {
-          "version": "7.0.0-beta.44",
-          "resolved": "http://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz",
-          "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==",
+        "@babel/helper-validator-identifier": {
+          "version": "7.14.5",
+          "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz",
+          "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==",
           "dev": true
-        },
-        "debug": {
-          "version": "3.2.6",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
-          "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+        }
+      }
+    },
+    "@babel/plugin-transform-modules-umd": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.14.5.tgz",
+      "integrity": "sha512-RfPGoagSngC06LsGUYyM9QWSXZ8MysEjDJTAea1lqRjNECE3y0qIJF/qbvJxc4oA4s99HumIMdXOrd+TdKaAAA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-module-transforms": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-named-capturing-groups-regex": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.14.5.tgz",
+      "integrity": "sha512-+Xe5+6MWFo311U8SchgeX5c1+lJM+eZDBZgD+tvXu9VVQPXwwVzeManMMjYX6xw2HczngfOSZjoFYKwdeB/Jvw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-new-target": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.14.5.tgz",
+      "integrity": "sha512-Nx054zovz6IIRWEB49RDRuXGI4Gy0GMgqG0cII9L3MxqgXz/+rgII+RU58qpo4g7tNEx1jG7rRVH4ihZoP4esQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-object-super": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.14.5.tgz",
+      "integrity": "sha512-MKfOBWzK0pZIrav9z/hkRqIk/2bTv9qvxHzPQc12RcVkMOzpIKnFCNYJip00ssKWYkd8Sf5g0Wr7pqJ+cmtuFg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-replace-supers": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-parameters": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.14.5.tgz",
+      "integrity": "sha512-Tl7LWdr6HUxTmzQtzuU14SqbgrSKmaR77M0OKyq4njZLQTPfOvzblNKyNkGwOfEFCEx7KeYHQHDI0P3F02IVkA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-property-literals": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.14.5.tgz",
+      "integrity": "sha512-r1uilDthkgXW8Z1vJz2dKYLV1tuw2xsbrp3MrZmD99Wh9vsfKoob+JTgri5VUb/JqyKRXotlOtwgu4stIYCmnw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-react-display-name": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-display-name/-/plugin-transform-react-display-name-7.14.5.tgz",
+      "integrity": "sha512-07aqY1ChoPgIxsuDviptRpVkWCSbXWmzQqcgy65C6YSFOfPFvb/DX3bBRHh7pCd/PMEEYHYWUTSVkCbkVainYQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-react-jsx": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx/-/plugin-transform-react-jsx-7.14.5.tgz",
+      "integrity": "sha512-7RylxNeDnxc1OleDm0F5Q/BSL+whYRbOAR+bwgCxIr0L32v7UFh/pz1DLMZideAUxKT6eMoS2zQH6fyODLEi8Q==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-module-imports": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/plugin-syntax-jsx": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-react-jsx-development": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-development/-/plugin-transform-react-jsx-development-7.14.5.tgz",
+      "integrity": "sha512-rdwG/9jC6QybWxVe2UVOa7q6cnTpw8JRRHOxntG/h6g/guAOe6AhtQHJuJh5FwmnXIT1bdm5vC2/5huV8ZOorQ==",
+      "dev": true,
+      "requires": {
+        "@babel/plugin-transform-react-jsx": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-react-pure-annotations": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-pure-annotations/-/plugin-transform-react-pure-annotations-7.14.5.tgz",
+      "integrity": "sha512-3X4HpBJimNxW4rhUy/SONPyNQHp5YRr0HhJdT2OH1BRp0of7u3Dkirc7x9FRJMKMqTBI079VZ1hzv7Ouuz///g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-annotate-as-pure": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-regenerator": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.14.5.tgz",
+      "integrity": "sha512-NVIY1W3ITDP5xQl50NgTKlZ0GrotKtLna08/uGY6ErQt6VEQZXla86x/CTddm5gZdcr+5GSsvMeTmWA5Ii6pkg==",
+      "dev": true,
+      "requires": {
+        "regenerator-transform": "^0.14.2"
+      },
+      "dependencies": {
+        "regenerator-transform": {
+          "version": "0.14.5",
+          "resolved": "https://registry.npmjs.org/regenerator-transform/-/regenerator-transform-0.14.5.tgz",
+          "integrity": "sha512-eOf6vka5IO151Jfsw2NO9WpGX58W6wWmefK3I1zEGr0lOD0u8rwPaNqQL1aRxUaxLeKO3ArNh3VYg1KbaD+FFw==",
           "dev": true,
           "requires": {
-            "ms": "^2.1.1"
+            "@babel/runtime": "^7.8.4"
+          }
+        }
+      }
+    },
+    "@babel/plugin-transform-reserved-words": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.14.5.tgz",
+      "integrity": "sha512-cv4F2rv1nD4qdexOGsRQXJrOcyb5CrgjUH9PKrrtyhSDBNWGxd0UIitjyJiWagS+EbUGjG++22mGH1Pub8D6Vg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-shorthand-properties": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.14.5.tgz",
+      "integrity": "sha512-xLucks6T1VmGsTB+GWK5Pl9Jl5+nRXD1uoFdA5TSO6xtiNjtXTjKkmPdFXVLGlK5A2/or/wQMKfmQ2Y0XJfn5g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-spread": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.14.6.tgz",
+      "integrity": "sha512-Zr0x0YroFJku7n7+/HH3A2eIrGMjbmAIbJSVv0IZ+t3U2WUQUA64S/oeied2e+MaGSjmt4alzBCsK9E8gh+fag==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-sticky-regex": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.14.5.tgz",
+      "integrity": "sha512-Z7F7GyvEMzIIbwnziAZmnSNpdijdr4dWt+FJNBnBLz5mwDFkqIXU9wmBcWWad3QeJF5hMTkRe4dAq2sUZiG+8A==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-template-literals": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.14.5.tgz",
+      "integrity": "sha512-22btZeURqiepOfuy/VkFr+zStqlujWaarpMErvay7goJS6BWwdd6BY9zQyDLDa4x2S3VugxFb162IZ4m/S/+Gg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-typeof-symbol": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.14.5.tgz",
+      "integrity": "sha512-lXzLD30ffCWseTbMQzrvDWqljvZlHkXU+CnseMhkMNqU1sASnCsz3tSzAaH3vCUXb9PHeUb90ZT1BdFTm1xxJw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-unicode-escapes": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.14.5.tgz",
+      "integrity": "sha512-crTo4jATEOjxj7bt9lbYXcBAM3LZaUrbP2uUdxb6WIorLmjNKSpHfIybgY4B8SRpbf8tEVIWH3Vtm7ayCrKocA==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/plugin-transform-unicode-regex": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.14.5.tgz",
+      "integrity": "sha512-UygduJpC5kHeCiRw/xDVzC+wj8VaYSoKl5JNVmbP7MadpNinAm3SvZCxZ42H37KZBKztz46YC73i9yV34d0Tzw==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-create-regexp-features-plugin": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5"
+      }
+    },
+    "@babel/preset-env": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.14.5.tgz",
+      "integrity": "sha512-ci6TsS0bjrdPpWGnQ+m4f+JSSzDKlckqKIJJt9UZ/+g7Zz9k0N8lYU8IeLg/01o2h8LyNZDMLGgRLDTxpudLsA==",
+      "dev": true,
+      "requires": {
+        "@babel/compat-data": "^7.14.5",
+        "@babel/helper-compilation-targets": "^7.14.5",
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-validator-option": "^7.14.5",
+        "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.14.5",
+        "@babel/plugin-proposal-async-generator-functions": "^7.14.5",
+        "@babel/plugin-proposal-class-properties": "^7.14.5",
+        "@babel/plugin-proposal-class-static-block": "^7.14.5",
+        "@babel/plugin-proposal-dynamic-import": "^7.14.5",
+        "@babel/plugin-proposal-export-namespace-from": "^7.14.5",
+        "@babel/plugin-proposal-json-strings": "^7.14.5",
+        "@babel/plugin-proposal-logical-assignment-operators": "^7.14.5",
+        "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.5",
+        "@babel/plugin-proposal-numeric-separator": "^7.14.5",
+        "@babel/plugin-proposal-object-rest-spread": "^7.14.5",
+        "@babel/plugin-proposal-optional-catch-binding": "^7.14.5",
+        "@babel/plugin-proposal-optional-chaining": "^7.14.5",
+        "@babel/plugin-proposal-private-methods": "^7.14.5",
+        "@babel/plugin-proposal-private-property-in-object": "^7.14.5",
+        "@babel/plugin-proposal-unicode-property-regex": "^7.14.5",
+        "@babel/plugin-syntax-async-generators": "^7.8.4",
+        "@babel/plugin-syntax-class-properties": "^7.12.13",
+        "@babel/plugin-syntax-class-static-block": "^7.14.5",
+        "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+        "@babel/plugin-syntax-export-namespace-from": "^7.8.3",
+        "@babel/plugin-syntax-json-strings": "^7.8.3",
+        "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4",
+        "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3",
+        "@babel/plugin-syntax-numeric-separator": "^7.10.4",
+        "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+        "@babel/plugin-syntax-optional-catch-binding": "^7.8.3",
+        "@babel/plugin-syntax-optional-chaining": "^7.8.3",
+        "@babel/plugin-syntax-private-property-in-object": "^7.14.5",
+        "@babel/plugin-syntax-top-level-await": "^7.14.5",
+        "@babel/plugin-transform-arrow-functions": "^7.14.5",
+        "@babel/plugin-transform-async-to-generator": "^7.14.5",
+        "@babel/plugin-transform-block-scoped-functions": "^7.14.5",
+        "@babel/plugin-transform-block-scoping": "^7.14.5",
+        "@babel/plugin-transform-classes": "^7.14.5",
+        "@babel/plugin-transform-computed-properties": "^7.14.5",
+        "@babel/plugin-transform-destructuring": "^7.14.5",
+        "@babel/plugin-transform-dotall-regex": "^7.14.5",
+        "@babel/plugin-transform-duplicate-keys": "^7.14.5",
+        "@babel/plugin-transform-exponentiation-operator": "^7.14.5",
+        "@babel/plugin-transform-for-of": "^7.14.5",
+        "@babel/plugin-transform-function-name": "^7.14.5",
+        "@babel/plugin-transform-literals": "^7.14.5",
+        "@babel/plugin-transform-member-expression-literals": "^7.14.5",
+        "@babel/plugin-transform-modules-amd": "^7.14.5",
+        "@babel/plugin-transform-modules-commonjs": "^7.14.5",
+        "@babel/plugin-transform-modules-systemjs": "^7.14.5",
+        "@babel/plugin-transform-modules-umd": "^7.14.5",
+        "@babel/plugin-transform-named-capturing-groups-regex": "^7.14.5",
+        "@babel/plugin-transform-new-target": "^7.14.5",
+        "@babel/plugin-transform-object-super": "^7.14.5",
+        "@babel/plugin-transform-parameters": "^7.14.5",
+        "@babel/plugin-transform-property-literals": "^7.14.5",
+        "@babel/plugin-transform-regenerator": "^7.14.5",
+        "@babel/plugin-transform-reserved-words": "^7.14.5",
+        "@babel/plugin-transform-shorthand-properties": "^7.14.5",
+        "@babel/plugin-transform-spread": "^7.14.5",
+        "@babel/plugin-transform-sticky-regex": "^7.14.5",
+        "@babel/plugin-transform-template-literals": "^7.14.5",
+        "@babel/plugin-transform-typeof-symbol": "^7.14.5",
+        "@babel/plugin-transform-unicode-escapes": "^7.14.5",
+        "@babel/plugin-transform-unicode-regex": "^7.14.5",
+        "@babel/preset-modules": "^0.1.4",
+        "@babel/types": "^7.14.5",
+        "babel-plugin-polyfill-corejs2": "^0.2.2",
+        "babel-plugin-polyfill-corejs3": "^0.2.2",
+        "babel-plugin-polyfill-regenerator": "^0.2.2",
+        "core-js-compat": "^3.14.0",
+        "semver": "^6.3.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/preset-modules": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/@babel/preset-modules/-/preset-modules-0.1.4.tgz",
+      "integrity": "sha512-J36NhwnfdzpmH41M1DrnkkgAqhZaqr/NBdPfQ677mLzlaXo+oDiv1deyCDtgAhz8p328otdob0Du7+xgHGZbKg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.0.0",
+        "@babel/plugin-proposal-unicode-property-regex": "^7.4.4",
+        "@babel/plugin-transform-dotall-regex": "^7.4.4",
+        "@babel/types": "^7.4.4",
+        "esutils": "^2.0.2"
+      }
+    },
+    "@babel/preset-react": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/preset-react/-/preset-react-7.14.5.tgz",
+      "integrity": "sha512-XFxBkjyObLvBaAvkx1Ie95Iaq4S/GUEIrejyrntQ/VCMKUYvKLoyKxOBzJ2kjA3b6rC9/KL6KXfDC2GqvLiNqQ==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-plugin-utils": "^7.14.5",
+        "@babel/helper-validator-option": "^7.14.5",
+        "@babel/plugin-transform-react-display-name": "^7.14.5",
+        "@babel/plugin-transform-react-jsx": "^7.14.5",
+        "@babel/plugin-transform-react-jsx-development": "^7.14.5",
+        "@babel/plugin-transform-react-pure-annotations": "^7.14.5"
+      }
+    },
+    "@babel/runtime": {
+      "version": "7.14.6",
+      "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.14.6.tgz",
+      "integrity": "sha512-/PCB2uJ7oM44tz8YhC4Z/6PeOKXp4K588f+5M3clr1M4zbqztlo0XEfJ2LEzj/FgwfgGcIdl8n7YYjTCI0BYwg==",
+      "dev": true,
+      "requires": {
+        "regenerator-runtime": "^0.13.4"
+      },
+      "dependencies": {
+        "regenerator-runtime": {
+          "version": "0.13.7",
+          "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.7.tgz",
+          "integrity": "sha512-a54FxoJDIr27pgf7IgeQGxmqUNYrcV338lf/6gH456HZ/PhX+5BcwHXG9ajESmwe6WRO0tAzRUrRmNONWgkrew==",
+          "dev": true
+        }
+      }
+    },
+    "@babel/template": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.14.5.tgz",
+      "integrity": "sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.14.5",
+        "@babel/parser": "^7.14.5",
+        "@babel/types": "^7.14.5"
+      }
+    },
+    "@babel/traverse": {
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.14.5.tgz",
+      "integrity": "sha512-G3BiS15vevepdmFqmUc9X+64y0viZYygubAMO8SvBmKARuF6CPSZtH4Ng9vi/lrWlZFGe3FWdXNy835akH8Glg==",
+      "dev": true,
+      "requires": {
+        "@babel/code-frame": "^7.14.5",
+        "@babel/generator": "^7.14.5",
+        "@babel/helper-function-name": "^7.14.5",
+        "@babel/helper-hoist-variables": "^7.14.5",
+        "@babel/helper-split-export-declaration": "^7.14.5",
+        "@babel/parser": "^7.14.5",
+        "@babel/types": "^7.14.5",
+        "debug": "^4.1.0",
+        "globals": "^11.1.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+          "dev": true,
+          "requires": {
+            "ms": "2.1.2"
           }
         },
         "globals": {
-          "version": "11.9.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-11.9.0.tgz",
-          "integrity": "sha512-5cJVtyXWH8PiJPVLZzzoIizXx944O4OmRro5MWKx5fT4MgcN7OfaMutPeaTdJCCURwbWdhhcCWcKIffPnmTzBg==",
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
           "dev": true
         },
         "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
           "dev": true
         }
       }
     },
     "@babel/types": {
-      "version": "7.0.0-beta.44",
-      "resolved": "http://registry.npmjs.org/@babel/types/-/types-7.0.0-beta.44.tgz",
-      "integrity": "sha512-5eTV4WRmqbaFM3v9gHAIljEQJU4Ssc6fxL61JN+Oe2ga/BwyjzjamwkCVVAQjHGuAX8i0BWo42dshL8eO5KfLQ==",
+      "version": "7.14.5",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.14.5.tgz",
+      "integrity": "sha512-M/NzBpEL95I5Hh4dwhin5JlE7EzO5PHMAuzjxss3tiOBD46KfQvVedN/3jEPZvdRvtsK2222XfdHogNIttFgcg==",
       "dev": true,
       "requires": {
-        "esutils": "^2.0.2",
-        "lodash": "^4.2.0",
+        "@babel/helper-validator-identifier": "^7.14.5",
         "to-fast-properties": "^2.0.0"
       },
       "dependencies": {
+        "@babel/helper-validator-identifier": {
+          "version": "7.14.5",
+          "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz",
+          "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==",
+          "dev": true
+        },
         "to-fast-properties": {
           "version": "2.0.0",
           "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
@@ -197,16 +1420,152 @@
         }
       }
     },
-    "JSONSelect": {
-      "version": "0.4.0",
-      "resolved": "https://registry.npmjs.org/JSONSelect/-/JSONSelect-0.4.0.tgz",
-      "integrity": "sha1-oI7cxn6z/L6Z7WMIVTRKDPKCu40=",
-      "dev": true
+    "@mapbox/node-pre-gyp": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@mapbox/node-pre-gyp/-/node-pre-gyp-1.0.1.tgz",
+      "integrity": "sha512-CUBdThIZMoLEQQxACwhLsPg/puxBca0abTH3ixuvBQkhjJ80Hdp99jmVjxFCOa52/tZqN9d70IbGUf+OuKDHGA==",
+      "requires": {
+        "detect-libc": "^1.0.3",
+        "http-proxy-agent": "^4.0.1",
+        "make-dir": "^3.1.0",
+        "node-fetch": "^2.6.1",
+        "nopt": "^5.0.0",
+        "npmlog": "^4.1.2",
+        "rimraf": "^3.0.2",
+        "semver": "^7.3.4",
+        "tar": "^6.1.0"
+      },
+      "dependencies": {
+        "chownr": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/chownr/-/chownr-2.0.0.tgz",
+          "integrity": "sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ=="
+        },
+        "fs-minipass": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-2.1.0.tgz",
+          "integrity": "sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==",
+          "requires": {
+            "minipass": "^3.0.0"
+          }
+        },
+        "glob": {
+          "version": "7.1.6",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+          "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        },
+        "minipass": {
+          "version": "3.1.3",
+          "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.1.3.tgz",
+          "integrity": "sha512-Mgd2GdMVzY+x3IJ+oHnVM+KG3lA5c8tnabyJKmHSaG2kAGpudxuOf8ToDkhumF7UzME7DecbQE9uOZhNm7PuJg==",
+          "requires": {
+            "yallist": "^4.0.0"
+          }
+        },
+        "minizlib": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-2.1.2.tgz",
+          "integrity": "sha512-bAxsR8BVfj60DWXHE3u30oHzfl4G7khkSuPW+qvpd7jFRHm7dLxOjUk1EHACJ/hxLY8phGJ0YhYHZo7jil7Qdg==",
+          "requires": {
+            "minipass": "^3.0.0",
+            "yallist": "^4.0.0"
+          }
+        },
+        "mkdirp": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
+          "integrity": "sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw=="
+        },
+        "nopt": {
+          "version": "5.0.0",
+          "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
+          "integrity": "sha512-Tbj67rffqceeLpcRXrT7vKAN8CwfPeIBgM7E6iBkmKLV7bEMwpGgYLGv0jACUsECaa/vuxP0IjEont6umdMgtQ==",
+          "requires": {
+            "abbrev": "1"
+          }
+        },
+        "rimraf": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+          "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        },
+        "semver": {
+          "version": "7.3.5",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.5.tgz",
+          "integrity": "sha512-PoeGJYh8HK4BTO/a9Tf6ZG3veo/A7ZVsYrSA6J8ny9nb3B1VrpkuN+z9OE5wfE5p6H4LchYZsegiQgbJD94ZFQ==",
+          "requires": {
+            "lru-cache": "^6.0.0"
+          }
+        },
+        "tar": {
+          "version": "6.1.0",
+          "resolved": "https://registry.npmjs.org/tar/-/tar-6.1.0.tgz",
+          "integrity": "sha512-DUCttfhsnLCjwoDoFcI+B2iJgYa93vBnDUATYEeRx6sntCTdN01VnqsIuTlALXla/LWooNg0yEGeB+Y8WdFxGA==",
+          "requires": {
+            "chownr": "^2.0.0",
+            "fs-minipass": "^2.0.0",
+            "minipass": "^3.0.0",
+            "minizlib": "^2.1.1",
+            "mkdirp": "^1.0.3",
+            "yallist": "^4.0.0"
+          }
+        },
+        "yallist": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+          "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+        }
+      }
+    },
+    "@nicolo-ribaudo/chokidar-2": {
+      "version": "2.1.8-no-fsevents.2",
+      "resolved": "https://registry.npmjs.org/@nicolo-ribaudo/chokidar-2/-/chokidar-2-2.1.8-no-fsevents.2.tgz",
+      "integrity": "sha512-Fb8WxUFOBQVl+CX4MWet5o7eCc6Pj04rXIwVKZ6h1NnqTo45eOQW6aWyhG25NIODvWFwTDMwBsYxrQ3imxpetg==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "anymatch": "^2.0.0",
+        "async-each": "^1.0.1",
+        "braces": "^2.3.2",
+        "glob-parent": "^5.1.2",
+        "inherits": "^2.0.3",
+        "is-binary-path": "^1.0.0",
+        "is-glob": "^4.0.0",
+        "normalize-path": "^3.0.0",
+        "path-is-absolute": "^1.0.0",
+        "readdirp": "^2.2.1",
+        "upath": "^1.1.1"
+      },
+      "dependencies": {
+        "normalize-path": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+          "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+          "dev": true,
+          "optional": true
+        }
+      }
+    },
+    "@tootallnate/once": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@tootallnate/once/-/once-1.1.2.tgz",
+      "integrity": "sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw=="
     },
     "JSONStream": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.1.tgz",
-      "integrity": "sha1-cH92HgHa6eFvG8+TcDt4xwlmV5o=",
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz",
+      "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==",
       "dev": true,
       "requires": {
         "jsonparse": "^1.2.0",
@@ -219,15 +1578,9 @@
       "integrity": "sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q=="
     },
     "acorn": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.1.2.tgz",
-      "integrity": "sha512-o96FZLJBPY1lvTuJylGA9Bk3t/GKPPJG8H0ydQQl01crzwJgspa4AEIq/pVTXigmK0PHVQhiAtn8WMBLL9D2WA==",
-      "dev": true
-    },
-    "acorn-dynamic-import": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-4.0.0.tgz",
-      "integrity": "sha512-d3OEjQV4ROpoflsnUA8HozoIR504TFxNivYEUi6uwz0IYhBkTDXGuWlNdMtybRt3nqVx/L6XqMt0FxkXuWKZhw==",
+      "version": "8.4.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.4.0.tgz",
+      "integrity": "sha512-ULr0LDaEqQrMFGyQ3bhJkLsbtrQ8QibAseGZeaSUiT/6zb9IvIkomWHJIvgvwad+hinRAgsI51JcWk2yvwyL+w==",
       "dev": true
     },
     "acorn-jsx": {
@@ -248,29 +1601,28 @@
       }
     },
     "acorn-node": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.6.2.tgz",
-      "integrity": "sha512-rIhNEZuNI8ibQcL7ANm/mGyPukIaZsRNX9psFNQURyJW0nu6k8wjSDld20z6v2mDBWqX13pIEnk9gGZJHIlEXg==",
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.8.2.tgz",
+      "integrity": "sha512-8mt+fslDufLYntIoPAaIMUe/lrbrehIiwmR3t2k9LljIzoigEPF27eLk2hy8zSGzmR/ogr7zbRKINMo1u0yh5A==",
       "dev": true,
       "requires": {
-        "acorn": "^6.0.2",
-        "acorn-dynamic-import": "^4.0.0",
-        "acorn-walk": "^6.1.0",
-        "xtend": "^4.0.1"
+        "acorn": "^7.0.0",
+        "acorn-walk": "^7.0.0",
+        "xtend": "^4.0.2"
       },
       "dependencies": {
         "acorn": {
-          "version": "6.0.4",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.0.4.tgz",
-          "integrity": "sha512-VY4i5EKSKkofY2I+6QLTbTTN/UvEQPCo6eiwzzSaSWfpaDhOmStMCMod6wmuPciNq+XS0faCglFu2lHZpdHUtg==",
+          "version": "7.4.1",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
+          "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
           "dev": true
         }
       }
     },
     "acorn-walk": {
-      "version": "6.1.1",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-6.1.1.tgz",
-      "integrity": "sha512-OtUw6JUTgxA2QoqqmrmQ7F2NYqiBPi/L2jqHyFtllhOUvXYQXf0Z1CYUinIfyT4bTCGmrA7gX9FvHA81uzCoVw==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-7.2.0.tgz",
+      "integrity": "sha512-OPdCF6GsMIP+Az+aWfAAOEt2/+iVDKE7oy6lJ098aoe59oAmK76qV6Gw60SbZ8jHuG2wH058GF4pLFbYamYrVA==",
       "dev": true
     },
     "affine-hull": {
@@ -282,22 +1634,45 @@
         "robust-orientation": "^1.1.3"
       }
     },
+    "agent-base": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-6.0.2.tgz",
+      "integrity": "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==",
+      "requires": {
+        "debug": "4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+        }
+      }
+    },
     "ajv": {
-      "version": "6.6.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.6.1.tgz",
-      "integrity": "sha512-ZoJjft5B+EJBjUyu9C9Hc0OZyPZSSlOF+plzouTrg6UlA8f+e/n8NIgBFG/9tppJtpPWfthHakK7juJdNDODww==",
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
       "dev": true,
       "requires": {
-        "fast-deep-equal": "^2.0.1",
+        "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
         "json-schema-traverse": "^0.4.1",
         "uri-js": "^4.2.2"
       },
       "dependencies": {
         "fast-deep-equal": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
-          "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=",
+          "version": "3.1.3",
+          "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+          "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
           "dev": true
         },
         "json-schema-traverse": {
@@ -332,18 +1707,26 @@
       "dev": true
     },
     "ansi-escape-sequences": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-escape-sequences/-/ansi-escape-sequences-4.0.1.tgz",
-      "integrity": "sha512-G3Aona26cXv8nWIwID6MP11WSishqnyOPQjYaVJ7CfY2Xgu5sHOXM39nQg6XtyfF9++oLV6l2uFGojBb4zglGA==",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/ansi-escape-sequences/-/ansi-escape-sequences-5.1.2.tgz",
+      "integrity": "sha512-JcpoVp1W1bl1Qn4cVuiXEhD6+dyXKSOgCn2zlzE8inYgCJCBy1aPnUhlz6I4DFum8D4ovb9Qi/iAjUcGvG2lqw==",
       "dev": true,
       "requires": {
-        "array-back": "^2.0.0"
+        "array-back": "^4.0.0"
+      },
+      "dependencies": {
+        "array-back": {
+          "version": "4.0.1",
+          "resolved": "https://registry.npmjs.org/array-back/-/array-back-4.0.1.tgz",
+          "integrity": "sha512-Z/JnaVEXv+A9xabHzN43FiiiWEE7gPCRXMrVmRm00tWbjZRul1iHm7ECzlyNq1p4a4ATXz+G9FJ3GqGOkOV3fg==",
+          "dev": true
+        }
       }
     },
     "ansi-escapes": {
-      "version": "3.1.0",
-      "resolved": "http://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.1.0.tgz",
-      "integrity": "sha512-UgAb8H9D41AQnu/PbWlCofQVcnV4Gs2bBJi9eZPxfU/hgglFh3SMDMENRIqdr7H6XFnXdoknctFByVsCOotTVw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz",
+      "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==",
       "dev": true
     },
     "ansi-html": {
@@ -364,13 +1747,14 @@
       "dev": true
     },
     "anymatch": {
-      "version": "1.3.2",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz",
-      "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-2.0.0.tgz",
+      "integrity": "sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==",
       "dev": true,
+      "optional": true,
       "requires": {
-        "micromatch": "^2.1.5",
-        "normalize-path": "^2.0.0"
+        "micromatch": "^3.1.4",
+        "normalize-path": "^2.1.1"
       }
     },
     "aproba": {
@@ -396,24 +1780,11 @@
         "sprintf-js": "~1.0.2"
       }
     },
-    "argv-tools": {
-      "version": "0.1.1",
-      "resolved": "https://registry.npmjs.org/argv-tools/-/argv-tools-0.1.1.tgz",
-      "integrity": "sha512-Cc0dBvx4dvrjjKpyDA6w8RlNAw8Su30NvZbWl/Tv9ZALEVlLVkWQiHMi84Q0xNfpVuSaiQbYkdmWK8g1PLGhKw==",
-      "dev": true,
-      "requires": {
-        "array-back": "^2.0.0",
-        "find-replace": "^2.0.1"
-      }
-    },
     "arr-diff": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
-      "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
-      "dev": true,
-      "requires": {
-        "arr-flatten": "^1.0.1"
-      }
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
+      "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
+      "dev": true
     },
     "arr-flatten": {
       "version": "1.1.0",
@@ -442,40 +1813,32 @@
       "integrity": "sha1-7/UuN1gknTO+QCuLuOVkuytdQDE=",
       "dev": true
     },
-    "array-filter": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/array-filter/-/array-filter-0.0.1.tgz",
-      "integrity": "sha1-fajPLiZijtcygDWB/SH2fKzS7uw=",
-      "dev": true
-    },
     "array-includes": {
-      "version": "3.0.3",
-      "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.0.3.tgz",
-      "integrity": "sha1-GEtI9i2S10UrsxsyMWXH+L0CJm0=",
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/array-includes/-/array-includes-3.1.3.tgz",
+      "integrity": "sha512-gcem1KlBU7c9rB+Rq8/3PPKsK2kjqeEBa3bD5kkQo4nYlOHQCJqIJFqBXDEfwaRuYTT4E+FxA9xez7Gf/e3Q7A==",
       "dev": true,
       "requires": {
-        "define-properties": "^1.1.2",
-        "es-abstract": "^1.7.0"
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.0-next.2",
+        "get-intrinsic": "^1.1.1",
+        "is-string": "^1.0.5"
+      },
+      "dependencies": {
+        "get-intrinsic": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
+          "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+          "dev": true,
+          "requires": {
+            "function-bind": "^1.1.1",
+            "has": "^1.0.3",
+            "has-symbols": "^1.0.1"
+          }
+        }
       }
     },
-    "array-iterate": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/array-iterate/-/array-iterate-1.1.1.tgz",
-      "integrity": "sha1-hlv3+K851rCYLGCQKRSsdrwBCPY=",
-      "dev": true
-    },
-    "array-map": {
-      "version": "0.0.0",
-      "resolved": "https://registry.npmjs.org/array-map/-/array-map-0.0.0.tgz",
-      "integrity": "sha1-iKK6tz0c97zVwbEYoAP2b2ZfpmI=",
-      "dev": true
-    },
-    "array-reduce": {
-      "version": "0.0.0",
-      "resolved": "https://registry.npmjs.org/array-reduce/-/array-reduce-0.0.0.tgz",
-      "integrity": "sha1-FziZ0//Rx9k4PkR5Ul2+J4yrXys=",
-      "dev": true
-    },
     "array-union": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/array-union/-/array-union-1.0.2.tgz",
@@ -492,11 +1855,23 @@
       "dev": true
     },
     "array-unique": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
-      "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
+      "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
       "dev": true
     },
+    "array.prototype.flatmap": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/array.prototype.flatmap/-/array.prototype.flatmap-1.2.4.tgz",
+      "integrity": "sha512-r9Z0zYoxqHz60vvQbWEdXIEtCwHF0yxaWfno9qzXeNHvfyl3BZqygmGzb84dsubyaXLH4husF+NFgMSdpZhk2Q==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.0-next.1",
+        "function-bind": "^1.1.1"
+      }
+    },
     "arrify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz",
@@ -519,22 +1894,32 @@
       }
     },
     "asn1.js": {
-      "version": "4.10.1",
-      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz",
-      "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==",
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-5.4.1.tgz",
+      "integrity": "sha512-+I//4cYPccV8LdmBLiX8CYvf9Sp3vQsrqu2QNXRcrbiWvcx/UdlFiqUJJzxRQxgsZmvhXhn4cSKeSmoFjVdupA==",
       "dev": true,
       "requires": {
         "bn.js": "^4.0.0",
         "inherits": "^2.0.1",
-        "minimalistic-assert": "^1.0.0"
+        "minimalistic-assert": "^1.0.0",
+        "safer-buffer": "^2.1.0"
+      },
+      "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        }
       }
     },
     "assert": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz",
-      "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=",
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/assert/-/assert-1.5.0.tgz",
+      "integrity": "sha512-EDsgawzwoun2CZkCgtxJbv392v4nbk9XDD06zI+kQYoBM/3RBWLlEyJARDOmhAAosBjWACEkKL6S+lIZtcAubA==",
       "dev": true,
       "requires": {
+        "object-assign": "^4.1.1",
         "util": "0.10.3"
       },
       "dependencies": {
@@ -546,7 +1931,7 @@
         },
         "util": {
           "version": "0.10.3",
-          "resolved": "http://registry.npmjs.org/util/-/util-0.10.3.tgz",
+          "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz",
           "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=",
           "dev": true,
           "requires": {
@@ -574,9 +1959,9 @@
       "dev": true
     },
     "async-each": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz",
-      "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.3.tgz",
+      "integrity": "sha512-z/WhQ5FPySLdvREByI2vZiTWwCnF0moMJ1hK9YQwDTHKh6I7/uSckMetoRGb5UBZPC1z0jlw+n/XCgjeH7y1AQ==",
       "dev": true
     },
     "asynckit": {
@@ -603,8 +1988,26 @@
         "num2fraction": "^1.2.2",
         "postcss": "^5.2.16",
         "postcss-value-parser": "^3.2.3"
+      },
+      "dependencies": {
+        "browserslist": {
+          "version": "1.7.7",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz",
+          "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=",
+          "dev": true,
+          "requires": {
+            "caniuse-db": "^1.0.30000639",
+            "electron-to-chromium": "^1.2.7"
+          }
+        }
       }
     },
+    "available-typed-arrays": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.4.tgz",
+      "integrity": "sha512-SA5mXJWrId1TaQjfxUYghbqQ/hYioKmLJvPJyDuYRtXXenFNMjj4hSSt1Cf1xsuXSXrtxrVC5Ot4eU6cOtBDdA==",
+      "dev": true
+    },
     "aws-sdk": {
       "version": "2.0.31",
       "resolved": "https://registry.npmjs.org/aws-sdk/-/aws-sdk-2.0.31.tgz",
@@ -630,34 +2033,11 @@
       "dev": true
     },
     "aws4": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.8.0.tgz",
-      "integrity": "sha512-ReZxvNHIOv88FlT7rxcXIIC0fPt4KZqZbOlivyWtXLt8ESx84zd3kMC6iK5jVeS2qt+g7ftS7ye4fi06X5rtRQ==",
+      "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.11.0.tgz",
+      "integrity": "sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==",
       "dev": true
     },
-    "babel-cli": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-cli/-/babel-cli-6.26.0.tgz",
-      "integrity": "sha1-UCq1SHTX24itALiHoGODzgPQAvE=",
-      "dev": true,
-      "requires": {
-        "babel-core": "^6.26.0",
-        "babel-polyfill": "^6.26.0",
-        "babel-register": "^6.26.0",
-        "babel-runtime": "^6.26.0",
-        "chokidar": "^1.6.1",
-        "commander": "^2.11.0",
-        "convert-source-map": "^1.5.0",
-        "fs-readdir-recursive": "^1.0.0",
-        "glob": "^7.1.2",
-        "lodash": "^4.17.4",
-        "output-file-sync": "^1.1.2",
-        "path-is-absolute": "^1.0.1",
-        "slash": "^1.0.0",
-        "source-map": "^0.5.6",
-        "v8flags": "^2.1.1"
-      }
-    },
     "babel-code-frame": {
       "version": "6.26.0",
       "resolved": "https://registry.npmjs.org/babel-code-frame/-/babel-code-frame-6.26.0.tgz",
@@ -696,19 +2076,35 @@
         "source-map": "^0.5.7"
       },
       "dependencies": {
+        "babel-generator": {
+          "version": "6.26.1",
+          "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz",
+          "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==",
+          "dev": true,
+          "requires": {
+            "babel-messages": "^6.23.0",
+            "babel-runtime": "^6.26.0",
+            "babel-types": "^6.26.0",
+            "detect-indent": "^4.0.0",
+            "jsesc": "^1.3.0",
+            "lodash": "^4.17.4",
+            "source-map": "^0.5.7",
+            "trim-right": "^1.0.1"
+          }
+        },
         "convert-source-map": {
-          "version": "1.6.0",
-          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.6.0.tgz",
-          "integrity": "sha512-eFu7XigvxdZ1ETfbgPBohgyQ/Z++C0eEhTor0qRwBw9unw+L0/6V8wkSuGgzdThkiS5lSpdptOQPD8Ak40a+7A==",
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz",
+          "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
           "dev": true,
           "requires": {
             "safe-buffer": "~5.1.1"
           }
         },
-        "private": {
-          "version": "0.1.8",
-          "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
-          "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
+        "slash": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
+          "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
           "dev": true
         },
         "source-map": {
@@ -733,36 +2129,193 @@
         "eslint-visitor-keys": "^1.0.0"
       },
       "dependencies": {
+        "@babel/code-frame": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0-beta.44.tgz",
+          "integrity": "sha512-cuAuTTIQ9RqcFRJ/Y8PvTh+paepNcaGxwQwjIDRWPXmzzyAeCO4KqS9ikMvq0MCbRk6GlYKwfzStrcP3/jSL8g==",
+          "dev": true,
+          "requires": {
+            "@babel/highlight": "7.0.0-beta.44"
+          }
+        },
+        "@babel/generator": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.0.0-beta.44.tgz",
+          "integrity": "sha512-5xVb7hlhjGcdkKpMXgicAVgx8syK5VJz193k0i/0sLP6DzE6lRrU1K3B/rFefgdo9LPGMAOOOAWW4jycj07ShQ==",
+          "dev": true,
+          "requires": {
+            "@babel/types": "7.0.0-beta.44",
+            "jsesc": "^2.5.1",
+            "lodash": "^4.2.0",
+            "source-map": "^0.5.0",
+            "trim-right": "^1.0.1"
+          }
+        },
+        "@babel/helper-function-name": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.0.0-beta.44.tgz",
+          "integrity": "sha512-MHRG2qZMKMFaBavX0LWpfZ2e+hLloT++N7rfM3DYOMUOGCD8cVjqZpwiL8a0bOX3IYcQev1ruciT0gdFFRTxzg==",
+          "dev": true,
+          "requires": {
+            "@babel/helper-get-function-arity": "7.0.0-beta.44",
+            "@babel/template": "7.0.0-beta.44",
+            "@babel/types": "7.0.0-beta.44"
+          }
+        },
+        "@babel/helper-get-function-arity": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.0.0-beta.44.tgz",
+          "integrity": "sha512-w0YjWVwrM2HwP6/H3sEgrSQdkCaxppqFeJtAnB23pRiJB5E/O9Yp7JAAeWBl+gGEgmBFinnTyOv2RN7rcSmMiw==",
+          "dev": true,
+          "requires": {
+            "@babel/types": "7.0.0-beta.44"
+          }
+        },
+        "@babel/helper-split-export-declaration": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.0.0-beta.44.tgz",
+          "integrity": "sha512-aQ7QowtkgKKzPGf0j6u77kBMdUFVBKNHw2p/3HX/POt5/oz8ec5cs0GwlgM8Hz7ui5EwJnzyfRmkNF1Nx1N7aA==",
+          "dev": true,
+          "requires": {
+            "@babel/types": "7.0.0-beta.44"
+          }
+        },
+        "@babel/highlight": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0-beta.44.tgz",
+          "integrity": "sha512-Il19yJvy7vMFm8AVAh6OZzaFoAd0hbkeMZiX3P5HGD+z7dyI7RzndHB0dg6Urh/VAFfHtpOIzDUSxmY6coyZWQ==",
+          "dev": true,
+          "requires": {
+            "chalk": "^2.0.0",
+            "esutils": "^2.0.2",
+            "js-tokens": "^3.0.0"
+          }
+        },
+        "@babel/template": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.0.0-beta.44.tgz",
+          "integrity": "sha512-w750Sloq0UNifLx1rUqwfbnC6uSUk0mfwwgGRfdLiaUzfAOiH0tHJE6ILQIUi3KYkjiCDTskoIsnfqZvWLBDng==",
+          "dev": true,
+          "requires": {
+            "@babel/code-frame": "7.0.0-beta.44",
+            "@babel/types": "7.0.0-beta.44",
+            "babylon": "7.0.0-beta.44",
+            "lodash": "^4.2.0"
+          }
+        },
+        "@babel/traverse": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.0.0-beta.44.tgz",
+          "integrity": "sha512-UHuDz8ukQkJCDASKHf+oDt3FVUzFd+QYfuBIsiNu/4+/ix6pP/C+uQZJ6K1oEfbCMv/IKWbgDEh7fcsnIE5AtA==",
+          "dev": true,
+          "requires": {
+            "@babel/code-frame": "7.0.0-beta.44",
+            "@babel/generator": "7.0.0-beta.44",
+            "@babel/helper-function-name": "7.0.0-beta.44",
+            "@babel/helper-split-export-declaration": "7.0.0-beta.44",
+            "@babel/types": "7.0.0-beta.44",
+            "babylon": "7.0.0-beta.44",
+            "debug": "^3.1.0",
+            "globals": "^11.1.0",
+            "invariant": "^2.2.0",
+            "lodash": "^4.2.0"
+          }
+        },
+        "@babel/types": {
+          "version": "7.0.0-beta.44",
+          "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.0.0-beta.44.tgz",
+          "integrity": "sha512-5eTV4WRmqbaFM3v9gHAIljEQJU4Ssc6fxL61JN+Oe2ga/BwyjzjamwkCVVAQjHGuAX8i0BWo42dshL8eO5KfLQ==",
+          "dev": true,
+          "requires": {
+            "esutils": "^2.0.2",
+            "lodash": "^4.2.0",
+            "to-fast-properties": "^2.0.0"
+          }
+        },
+        "ansi-styles": {
+          "version": "3.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+          "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+          "dev": true,
+          "requires": {
+            "color-convert": "^1.9.0"
+          }
+        },
         "babylon": {
           "version": "7.0.0-beta.44",
-          "resolved": "http://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz",
+          "resolved": "https://registry.npmjs.org/babylon/-/babylon-7.0.0-beta.44.tgz",
           "integrity": "sha512-5Hlm13BJVAioCHpImtFqNOF2H3ieTOHd0fmFGMxOJ9jgeFqeAwsv3u5P5cR7CSeFrkgHsT19DgFJkHV0/Mcd8g==",
           "dev": true
+        },
+        "chalk": {
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+          "dev": true,
+          "requires": {
+            "ansi-styles": "^3.2.1",
+            "escape-string-regexp": "^1.0.5",
+            "supports-color": "^5.3.0"
+          }
+        },
+        "debug": {
+          "version": "3.2.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+          "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "globals": {
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
+          "dev": true
+        },
+        "jsesc": {
+          "version": "2.5.2",
+          "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-2.5.2.tgz",
+          "integrity": "sha512-OYu7XEzjkCQ3C5Ps3QIZsQfNpqoJyZZA99wd9aWd05NCtC5pWOkShK2mkL6HXQR6/Cy2lbNdPlZBpuQHXE63gA==",
+          "dev": true
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+          "dev": true
+        },
+        "supports-color": {
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+          "dev": true,
+          "requires": {
+            "has-flag": "^3.0.0"
+          }
+        },
+        "to-fast-properties": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-2.0.0.tgz",
+          "integrity": "sha1-3F5pjL0HkmW8c+A3doGk5Og/YW4=",
+          "dev": true
         }
       }
     },
     "babel-generator": {
-      "version": "6.26.1",
-      "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.26.1.tgz",
-      "integrity": "sha512-HyfwY6ApZj7BYTcJURpM5tznulaBvyio7/0d4zFOeMPUmfxkCjHocCuoLa2SAGzBI8AREcH3eP3758F672DppA==",
+      "version": "6.25.0",
+      "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.25.0.tgz",
+      "integrity": "sha1-M6GvcNXyiQrrRlpKd5PB32qeqfw=",
       "dev": true,
       "requires": {
         "babel-messages": "^6.23.0",
-        "babel-runtime": "^6.26.0",
-        "babel-types": "^6.26.0",
+        "babel-runtime": "^6.22.0",
+        "babel-types": "^6.25.0",
         "detect-indent": "^4.0.0",
         "jsesc": "^1.3.0",
-        "lodash": "^4.17.4",
-        "source-map": "^0.5.7",
+        "lodash": "^4.2.0",
+        "source-map": "^0.5.0",
         "trim-right": "^1.0.1"
-      },
-      "dependencies": {
-        "source-map": {
-          "version": "0.5.7",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
-          "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=",
-          "dev": true
-        }
       }
     },
     "babel-helper-bindify-decorators": {
@@ -954,6 +2507,53 @@
         "babel-runtime": "^6.22.0"
       }
     },
+    "babel-plugin-dynamic-import-node": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/babel-plugin-dynamic-import-node/-/babel-plugin-dynamic-import-node-2.3.3.tgz",
+      "integrity": "sha512-jZVI+s9Zg3IqA/kdi0i6UDCybUI3aSBLnglhYbSSjKlV7yF1F/5LWv8MakQmvYpnbJDS6fcBL2KzHSxNCMtWSQ==",
+      "dev": true,
+      "requires": {
+        "object.assign": "^4.1.0"
+      }
+    },
+    "babel-plugin-polyfill-corejs2": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.2.2.tgz",
+      "integrity": "sha512-kISrENsJ0z5dNPq5eRvcctITNHYXWOA4DUZRFYCz3jYCcvTb/A546LIddmoGNMVYg2U38OyFeNosQwI9ENTqIQ==",
+      "dev": true,
+      "requires": {
+        "@babel/compat-data": "^7.13.11",
+        "@babel/helper-define-polyfill-provider": "^0.2.2",
+        "semver": "^6.1.1"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==",
+          "dev": true
+        }
+      }
+    },
+    "babel-plugin-polyfill-corejs3": {
+      "version": "0.2.3",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.2.3.tgz",
+      "integrity": "sha512-rCOFzEIJpJEAU14XCcV/erIf/wZQMmMT5l5vXOpL5uoznyOGfDIjPj6FVytMvtzaKSTSVKouOCTPJ5OMUZH30g==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-define-polyfill-provider": "^0.2.2",
+        "core-js-compat": "^3.14.0"
+      }
+    },
+    "babel-plugin-polyfill-regenerator": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.2.2.tgz",
+      "integrity": "sha512-Goy5ghsc21HgPDFtzRkSirpZVW35meGoTmTOb2bxqdl60ghub4xOidgNTHaZfQ2FaxQsKmwvXtOAkcIS4SMBWg==",
+      "dev": true,
+      "requires": {
+        "@babel/helper-define-polyfill-provider": "^0.2.2"
+      }
+    },
     "babel-plugin-syntax-async-functions": {
       "version": "6.13.0",
       "resolved": "https://registry.npmjs.org/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz",
@@ -1106,9 +2706,9 @@
       }
     },
     "babel-plugin-transform-decorators-legacy": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-decorators-legacy/-/babel-plugin-transform-decorators-legacy-1.3.4.tgz",
-      "integrity": "sha1-dBtY9sW86eYCfgiC2cmU8E82aSU=",
+      "version": "1.3.5",
+      "resolved": "https://registry.npmjs.org/babel-plugin-transform-decorators-legacy/-/babel-plugin-transform-decorators-legacy-1.3.5.tgz",
+      "integrity": "sha512-jYHwjzRXRelYQ1uGm353zNzf3QmtdCfvJbuYTZ4gKveK7M9H1fs3a5AKdY1JUDl0z97E30ukORW1dzhWvsabtA==",
       "dev": true,
       "requires": {
         "babel-plugin-syntax-decorators": "^6.1.18",
@@ -1244,9 +2844,9 @@
       }
     },
     "babel-plugin-transform-es2015-modules-commonjs": {
-      "version": "6.26.0",
-      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.0.tgz",
-      "integrity": "sha1-DYOUApt9xqvhqX7xgeAHWN0uXYo=",
+      "version": "6.26.2",
+      "resolved": "https://registry.npmjs.org/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.26.2.tgz",
+      "integrity": "sha512-CV9ROOHEdrjcwhIaJNBGMBCodN+1cfkwtM1SbUHmvyy35KGT7fohbpOxkE2uLz1o6odKK2Ck/tz47z+VqQfi9Q==",
       "dev": true,
       "requires": {
         "babel-plugin-transform-strict-mode": "^6.24.1",
@@ -1659,14 +3259,10 @@
       }
     },
     "babelify": {
-      "version": "7.3.0",
-      "resolved": "https://registry.npmjs.org/babelify/-/babelify-7.3.0.tgz",
-      "integrity": "sha1-qlau3nBn/XvVSWZu4W3ChQh+iOU=",
-      "dev": true,
-      "requires": {
-        "babel-core": "^6.0.14",
-        "object-assign": "^4.0.0"
-      }
+      "version": "10.0.0",
+      "resolved": "https://registry.npmjs.org/babelify/-/babelify-10.0.0.tgz",
+      "integrity": "sha512-X40FaxyH7t3X+JFAKvb1H9wooWKLRCi8pg3m8poqtdZaIng+bjzp9RvKQCvRjF9isHiPkXspbbXT/zwXLtwgwg==",
+      "dev": true
     },
     "babylon": {
       "version": "6.18.0",
@@ -1675,9 +3271,9 @@
       "dev": true
     },
     "bail": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/bail/-/bail-1.0.2.tgz",
-      "integrity": "sha1-99bBcxYwqfnw1NNe0fli4gdKF2Q=",
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-1.0.5.tgz",
+      "integrity": "sha512-xFbRxM1tahm08yHBP16MMjVUAvDaBMD38zsM9EMAUN61omwLmKlOpB/Zku5QkjZ8TZ4vn53pj+t518cH0S03RQ==",
       "dev": true
     },
     "balanced-match": {
@@ -1700,18 +3296,62 @@
         "pascalcase": "^0.1.1"
       },
       "dependencies": {
+        "define-property": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+          "dev": true,
+          "requires": {
+            "is-descriptor": "^1.0.0"
+          }
+        },
+        "is-accessor-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-data-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-descriptor": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+          "dev": true,
+          "requires": {
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
+          }
+        },
         "isobject": {
           "version": "3.0.1",
           "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
           "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
           "dev": true
+        },
+        "kind-of": {
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+          "dev": true
         }
       }
     },
     "base64-js": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.3.0.tgz",
-      "integrity": "sha512-ccav/yGvoa80BQDljCxsmmQ3Xvx60/UpBIij5QN21W3wBi/hhIC9OoO+KLpu9IJTS9j4DRVJ3aDDF9cMSoa2lw==",
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
       "dev": true
     },
     "bcrypt-pbkdf": {
@@ -1724,31 +3364,31 @@
       }
     },
     "binary-extensions": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.10.0.tgz",
-      "integrity": "sha1-muuabF6IY4qtFx4Wf1kAq+JINdA=",
+      "version": "1.13.1",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.13.1.tgz",
+      "integrity": "sha512-Un7MIEDdUC5gNpcGDV97op1Ywk748MpHcFTHoYs6qnj1Z3j7I53VG3nwZhKzoBZmbdRNnb6WRdFlwl7tSDuZGw==",
       "dev": true
     },
+    "bindings": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.5.0.tgz",
+      "integrity": "sha512-p2q/t/mhvuOj/UeLlV6566GD/guowlr0hHxClI0W9m7MWYkL1F0hLo+0Aexs9HSPCtR1SXQ0TD3MMKrXZajbiQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "file-uri-to-path": "1.0.0"
+      }
+    },
     "bit-twiddle": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/bit-twiddle/-/bit-twiddle-1.0.2.tgz",
       "integrity": "sha1-DGwfq+KyPRcXPZpht7cJPrnhdp4=",
       "dev": true
     },
-    "block-stream": {
-      "version": "0.0.9",
-      "resolved": "https://registry.npmjs.org/block-stream/-/block-stream-0.0.9.tgz",
-      "integrity": "sha1-E+v+d4oDIFz+A3UUgeu0szAMEmo=",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "inherits": "~2.0.0"
-      }
-    },
     "bn.js": {
-      "version": "4.11.8",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz",
-      "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==",
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-5.2.0.tgz",
+      "integrity": "sha512-D7iWRBvnZE8ecXiLj/9wbxH7Tk79fAh8IHaTNq1RWRixsS02W+5qS+iE9yq6RYl0asXx5tw0bLhmT5pIfbSquw==",
       "dev": true
     },
     "body": {
@@ -1779,19 +3419,37 @@
       }
     },
     "braces": {
-      "version": "1.8.5",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
-      "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz",
+      "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
       "dev": true,
       "requires": {
-        "expand-range": "^1.8.1",
-        "preserve": "^0.2.0",
-        "repeat-element": "^1.1.2"
+        "arr-flatten": "^1.1.0",
+        "array-unique": "^0.3.2",
+        "extend-shallow": "^2.0.1",
+        "fill-range": "^4.0.0",
+        "isobject": "^3.0.1",
+        "repeat-element": "^1.1.2",
+        "snapdragon": "^0.8.1",
+        "snapdragon-node": "^2.0.1",
+        "split-string": "^3.0.2",
+        "to-regex": "^3.0.1"
+      },
+      "dependencies": {
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        }
       }
     },
     "brfs": {
       "version": "1.6.1",
-      "resolved": "http://registry.npmjs.org/brfs/-/brfs-1.6.1.tgz",
+      "resolved": "https://registry.npmjs.org/brfs/-/brfs-1.6.1.tgz",
       "integrity": "sha512-OfZpABRQQf+Xsmju8XE9bDjs+uU4vLREGolP7bDgcpsI17QREyZ4Bl+2KLxxx1kCgA0fAIhKQBaBYh+PEcCqYQ==",
       "dev": true,
       "requires": {
@@ -1809,7 +3467,7 @@
     },
     "browser-pack": {
       "version": "6.1.0",
-      "resolved": "http://registry.npmjs.org/browser-pack/-/browser-pack-6.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.1.0.tgz",
       "integrity": "sha512-erYug8XoqzU3IfcU8fUgyHqyOXqIE4tUTTQ+7mqUjQlvnXkOO6OlT9c/ZoJVHYoAaqGxr09CN53G7XIsO4KtWA==",
       "dev": true,
       "requires": {
@@ -1822,9 +3480,9 @@
       }
     },
     "browser-resolve": {
-      "version": "1.11.2",
-      "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.2.tgz",
-      "integrity": "sha1-j/CbCixCFxihBRwmCzLkj0QpOM4=",
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.3.tgz",
+      "integrity": "sha512-exDi1BYWB/6raKHmDTCicQfTkqwN5fioMFV4j8BsfMU4R2DK/QfZfK7kOVkmWCNANf0snkBzqGqAJBao9gZMdQ==",
       "dev": true,
       "requires": {
         "resolve": "1.1.7"
@@ -1839,49 +3497,49 @@
       }
     },
     "browserify": {
-      "version": "16.2.3",
-      "resolved": "https://registry.npmjs.org/browserify/-/browserify-16.2.3.tgz",
-      "integrity": "sha512-zQt/Gd1+W+IY+h/xX2NYMW4orQWhqSwyV+xsblycTtpOuB27h1fZhhNQuipJ4t79ohw4P4mMem0jp/ZkISQtjQ==",
+      "version": "17.0.0",
+      "resolved": "https://registry.npmjs.org/browserify/-/browserify-17.0.0.tgz",
+      "integrity": "sha512-SaHqzhku9v/j6XsQMRxPyBrSP3gnwmE27gLJYZgMT2GeK3J0+0toN+MnuNYDfHwVGQfLiMZ7KSNSIXHemy905w==",
       "dev": true,
       "requires": {
         "JSONStream": "^1.0.3",
         "assert": "^1.4.0",
         "browser-pack": "^6.0.1",
-        "browser-resolve": "^1.11.0",
+        "browser-resolve": "^2.0.0",
         "browserify-zlib": "~0.2.0",
-        "buffer": "^5.0.2",
+        "buffer": "~5.2.1",
         "cached-path-relative": "^1.0.0",
         "concat-stream": "^1.6.0",
         "console-browserify": "^1.1.0",
         "constants-browserify": "~1.0.0",
         "crypto-browserify": "^3.0.0",
         "defined": "^1.0.0",
-        "deps-sort": "^2.0.0",
+        "deps-sort": "^2.0.1",
         "domain-browser": "^1.2.0",
         "duplexer2": "~0.1.2",
-        "events": "^2.0.0",
+        "events": "^3.0.0",
         "glob": "^7.1.0",
         "has": "^1.0.0",
         "htmlescape": "^1.1.0",
         "https-browserify": "^1.0.0",
         "inherits": "~2.0.1",
-        "insert-module-globals": "^7.0.0",
+        "insert-module-globals": "^7.2.1",
         "labeled-stream-splicer": "^2.0.0",
-        "mkdirp": "^0.5.0",
-        "module-deps": "^6.0.0",
+        "mkdirp-classic": "^0.5.2",
+        "module-deps": "^6.2.3",
         "os-browserify": "~0.3.0",
         "parents": "^1.0.1",
-        "path-browserify": "~0.0.0",
+        "path-browserify": "^1.0.0",
         "process": "~0.11.0",
         "punycode": "^1.3.2",
         "querystring-es3": "~0.2.0",
         "read-only-stream": "^2.0.0",
         "readable-stream": "^2.0.2",
         "resolve": "^1.1.4",
-        "shasum": "^1.0.0",
+        "shasum-object": "^1.0.0",
         "shell-quote": "^1.6.1",
-        "stream-browserify": "^2.0.0",
-        "stream-http": "^2.0.0",
+        "stream-browserify": "^3.0.0",
+        "stream-http": "^3.0.0",
         "string_decoder": "^1.1.1",
         "subarg": "^1.0.0",
         "syntax-error": "^1.1.1",
@@ -1889,25 +3547,74 @@
         "timers-browserify": "^1.0.1",
         "tty-browserify": "0.0.1",
         "url": "~0.11.0",
-        "util": "~0.10.1",
+        "util": "~0.12.0",
         "vm-browserify": "^1.0.0",
         "xtend": "^4.0.0"
       },
       "dependencies": {
-        "string_decoder": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.2.0.tgz",
-          "integrity": "sha512-6YqyX6ZWEYguAxgZzHGL7SsCeGx3V2TtOTqZz1xSTSWnqsbWwbptafNyvf/ACquZUXV3DANr5BDIwNYe1mN42w==",
+        "browser-resolve": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-2.0.0.tgz",
+          "integrity": "sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==",
           "dev": true,
           "requires": {
-            "safe-buffer": "~5.1.0"
+            "resolve": "^1.17.0"
+          }
+        },
+        "detective": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.0.tgz",
+          "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==",
+          "dev": true,
+          "requires": {
+            "acorn-node": "^1.6.1",
+            "defined": "^1.0.0",
+            "minimist": "^1.1.1"
+          }
+        },
+        "module-deps": {
+          "version": "6.2.3",
+          "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.3.tgz",
+          "integrity": "sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==",
+          "dev": true,
+          "requires": {
+            "JSONStream": "^1.0.3",
+            "browser-resolve": "^2.0.0",
+            "cached-path-relative": "^1.0.2",
+            "concat-stream": "~1.6.0",
+            "defined": "^1.0.0",
+            "detective": "^5.2.0",
+            "duplexer2": "^0.1.2",
+            "inherits": "^2.0.1",
+            "parents": "^1.0.0",
+            "readable-stream": "^2.0.2",
+            "resolve": "^1.4.0",
+            "stream-combiner2": "^1.1.1",
+            "subarg": "^1.0.0",
+            "through2": "^2.0.0",
+            "xtend": "^4.0.0"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
+        "string_decoder": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.2.0"
           }
         }
       }
     },
     "browserify-aes": {
       "version": "1.2.0",
-      "resolved": "http://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.2.0.tgz",
       "integrity": "sha512-+7CHXqGuspUn/Sl5aO7Ea0xWGAtETPXNSAjHo48JfLdPWcMng33Xe4znFvQweqc/uzk5zSOI3H52CYnjCfb5hA==",
       "dev": true,
       "requires": {
@@ -1943,36 +3650,72 @@
       },
       "dependencies": {
         "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
           "dev": true
         }
       }
     },
     "browserify-rsa": {
-      "version": "4.0.1",
-      "resolved": "http://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz",
-      "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.1.0.tgz",
+      "integrity": "sha512-AdEER0Hkspgno2aR97SAf6vi0y0k8NuOpGnVH3O99rcA5Q6sh8QxcngtHuJ6uXwnfAXNM4Gn1Gb7/MV1+Ymbog==",
       "dev": true,
       "requires": {
-        "bn.js": "^4.1.0",
+        "bn.js": "^5.0.0",
         "randombytes": "^2.0.1"
       }
     },
     "browserify-sign": {
-      "version": "4.0.4",
-      "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz",
-      "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=",
+      "version": "4.2.1",
+      "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.2.1.tgz",
+      "integrity": "sha512-/vrA5fguVAKKAVTNJjgSm1tRQDHUU6DbwO9IROu/0WAzC8PKhucDSh18J0RMvVeHAn5puMd+QHC2erPRNf8lmg==",
       "dev": true,
       "requires": {
-        "bn.js": "^4.1.1",
-        "browserify-rsa": "^4.0.0",
-        "create-hash": "^1.1.0",
-        "create-hmac": "^1.1.2",
-        "elliptic": "^6.0.0",
-        "inherits": "^2.0.1",
-        "parse-asn1": "^5.0.0"
+        "bn.js": "^5.1.1",
+        "browserify-rsa": "^4.0.1",
+        "create-hash": "^1.2.0",
+        "create-hmac": "^1.1.7",
+        "elliptic": "^6.5.3",
+        "inherits": "^2.0.4",
+        "parse-asn1": "^5.1.5",
+        "readable-stream": "^3.6.0",
+        "safe-buffer": "^5.2.0"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+          "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+          "dev": true,
+          "requires": {
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
+        "string_decoder": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.2.0"
+          }
+        }
       }
     },
     "browserify-zlib": {
@@ -1985,13 +3728,16 @@
       }
     },
     "browserslist": {
-      "version": "1.7.7",
-      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz",
-      "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=",
+      "version": "4.16.6",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.6.tgz",
+      "integrity": "sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==",
       "dev": true,
       "requires": {
-        "caniuse-db": "^1.0.30000639",
-        "electron-to-chromium": "^1.2.7"
+        "caniuse-lite": "^1.0.30001219",
+        "colorette": "^1.2.2",
+        "electron-to-chromium": "^1.3.723",
+        "escalade": "^3.1.1",
+        "node-releases": "^1.1.71"
       }
     },
     "buffer": {
@@ -2076,6 +3822,15 @@
       "integrity": "sha512-5r2GqsoEb4qMTTN9J+WzXfjov+hjxT+j3u5K+kIVNIwAd99DLCJE9pBIMP1qVeybV6JiijL385Oz0DcYxfbOIg==",
       "dev": true
     },
+    "call-bind": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.2.tgz",
+      "integrity": "sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==",
+      "requires": {
+        "function-bind": "^1.1.1",
+        "get-intrinsic": "^1.0.2"
+      }
+    },
     "caller-path": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/caller-path/-/caller-path-0.1.0.tgz",
@@ -2118,6 +3873,16 @@
         "lodash.uniq": "^4.5.0"
       },
       "dependencies": {
+        "browserslist": {
+          "version": "1.7.7",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz",
+          "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=",
+          "dev": true,
+          "requires": {
+            "caniuse-db": "^1.0.30000639",
+            "electron-to-chromium": "^1.2.7"
+          }
+        },
         "lodash.memoize": {
           "version": "4.1.2",
           "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-4.1.2.tgz",
@@ -2127,9 +3892,15 @@
       }
     },
     "caniuse-db": {
-      "version": "1.0.30000918",
-      "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30000918.tgz",
-      "integrity": "sha512-ZaBZBV3FSuGf1/rOEMY+hfyb2GNgOY9vXQzBSVtXEeLTbYu5y/qcXeu8oFXG6WX9LhLf+v+JEH8lT7YWUHb6VA==",
+      "version": "1.0.30001237",
+      "resolved": "https://registry.npmjs.org/caniuse-db/-/caniuse-db-1.0.30001237.tgz",
+      "integrity": "sha512-tUooT0g3ft2icsFd4tOt6VDgc2ff/YmIuECVKSvAW+fPBLqMjU0KK2xDC1qgQ7B0zzqFXVGR96VaBDcAnceG6g==",
+      "dev": true
+    },
+    "caniuse-lite": {
+      "version": "1.0.30001237",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001237.tgz",
+      "integrity": "sha512-pDHgRndit6p1NR2GhzMbQ6CkRrp4VKuSsqbcLeOQppYPKOYkKT/6ZvZDvKJUqcmtyWIAHuZq3SVS2vc1egCZzw==",
       "dev": true
     },
     "caseless": {
@@ -2139,9 +3910,9 @@
       "dev": true
     },
     "ccount": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.0.2.tgz",
-      "integrity": "sha1-U7ai+BW7d7nChx97mnLDol8djok=",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-1.1.0.tgz",
+      "integrity": "sha512-vlNK021QdI7PNeiUh/lKkC/mNHHfV0m/Ad5JoI0TYtlBnJAslM/JIkm/tGC88bkLIwO6OQ5uV6ztS6kVAtCDlg==",
       "dev": true
     },
     "center-align": {
@@ -2168,27 +3939,27 @@
       }
     },
     "character-entities": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.1.tgz",
-      "integrity": "sha1-92hxvl72bdt/j440eOzDdMJ9bco=",
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-1.2.4.tgz",
+      "integrity": "sha512-iBMyeEHxfVnIakwOuDXpVkc54HijNgCyQB2w0VfGQThle6NXn50zU6V/u+LDhxHcDUPojn6Kpga3PTAD8W1bQw==",
       "dev": true
     },
     "character-entities-html4": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-1.1.1.tgz",
-      "integrity": "sha1-NZoqSg9+KdPcKsmb2+Ie45Q46lA=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-1.1.4.tgz",
+      "integrity": "sha512-HRcDxZuZqMx3/a+qrzxdBKBPUpxWEq9xw2OPZ3a/174ihfrQKVsFhqtthBInFy1zZ9GgZyFXOatNujm8M+El3g==",
       "dev": true
     },
     "character-entities-legacy": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.1.tgz",
-      "integrity": "sha1-9Ad53xoQGHK7UQo9KV4fzPFHIC8=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-1.1.4.tgz",
+      "integrity": "sha512-3Xnr+7ZFS1uxeiUDvV02wQ+QDbc55o97tIV5zHScSPJpcLm/r0DFPcoY3tYRp+VZukxuMeKgXYmsXQHO05zQeA==",
       "dev": true
     },
     "character-reference-invalid": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.1.tgz",
-      "integrity": "sha1-lCg191Dk7GGjCOYMLvjMEBEgLvw=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-1.1.4.tgz",
+      "integrity": "sha512-mKKUkUbhPpQlCOfIuZkvSEgktjPFIsZKRRbC6KWVEMvlzblj3i3asQv5ODsrwt0N3pHAEvjP8KTQPHkp0+6jOg==",
       "dev": true
     },
     "chardet": {
@@ -2197,27 +3968,94 @@
       "integrity": "sha1-tUc7M9yXxCTl2Y3IfVXU2KKci/I=",
       "dev": true
     },
-    "chokidar": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz",
-      "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=",
-      "dev": true,
-      "requires": {
-        "anymatch": "^1.3.0",
-        "async-each": "^1.0.0",
-        "fsevents": "^1.0.0",
-        "glob-parent": "^2.0.0",
-        "inherits": "^2.0.1",
-        "is-binary-path": "^1.0.0",
-        "is-glob": "^2.0.0",
-        "path-is-absolute": "^1.0.0",
-        "readdirp": "^2.0.0"
-      }
+    "cheap-ruler": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/cheap-ruler/-/cheap-ruler-3.0.2.tgz",
+      "integrity": "sha512-02T332h1/HTN6cDSufLP8x4JzDs2+VC+8qZ/N0kWIVPyc2xUkWwWh3B2fJxR7raXkL4Mq7k554mfuM9ofv/vGg=="
     },
-    "chownr": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/chownr/-/chownr-1.1.1.tgz",
-      "integrity": "sha512-j38EvO5+LHX84jlo6h4UzmOwi0UgW61WRyPtJz4qaadK5eY3BTS5TY/S1Stc3Uk2lIM6TPevAlULiEJwie860g=="
+    "chokidar": {
+      "version": "3.5.2",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.2.tgz",
+      "integrity": "sha512-ekGhOnNVPgT77r4K/U3GDhu+FQ2S8TnK/s2KbIGXi0SZWuwkZ2QNyfWdZW+TVfn84DpEP7rLeCt2UI6bJ8GwbQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "fsevents": "~2.3.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "dependencies": {
+        "anymatch": {
+          "version": "3.1.2",
+          "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.2.tgz",
+          "integrity": "sha512-P43ePfOAIupkguHUycrc4qJ9kz8ZiuOUijaETwX7THt0Y/GNK7v0aa8rY816xWjZ7rJdA5XdMcpVFTKMq+RvWg==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "normalize-path": "^3.0.0",
+            "picomatch": "^2.0.4"
+          }
+        },
+        "binary-extensions": {
+          "version": "2.2.0",
+          "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+          "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+          "dev": true,
+          "optional": true
+        },
+        "braces": {
+          "version": "3.0.2",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+          "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "fill-range": "^7.0.1"
+          }
+        },
+        "fill-range": {
+          "version": "7.0.1",
+          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
+          "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "to-regex-range": "^5.0.1"
+          }
+        },
+        "is-binary-path": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
+          "integrity": "sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "binary-extensions": "^2.0.0"
+          }
+        },
+        "normalize-path": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+          "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
+          "dev": true,
+          "optional": true
+        },
+        "readdirp": {
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-3.6.0.tgz",
+          "integrity": "sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "picomatch": "^2.2.1"
+          }
+        }
+      }
     },
     "cipher-base": {
       "version": "1.0.4",
@@ -2235,12 +4073,6 @@
       "integrity": "sha512-UZK3NBx2Mca+b5LsG7bY183pHWt5Y1xts4P3Pz7ENTwGVnJOUWbRb3ocjvX7hx9tq/yTAdclXm9sZ38gNuem4A==",
       "dev": true
     },
-    "cjson": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/cjson/-/cjson-0.2.1.tgz",
-      "integrity": "sha1-c82KrWXZ4VBfmvF0TTt5wVJ2gqU=",
-      "dev": true
-    },
     "clap": {
       "version": "1.2.3",
       "resolved": "https://registry.npmjs.org/clap/-/clap-1.2.3.tgz",
@@ -2322,9 +4154,9 @@
       }
     },
     "clone": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.2.tgz",
-      "integrity": "sha1-Jgt6meux7f4kdTgXX3gyQ8sZ0Uk=",
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.2.tgz",
+      "integrity": "sha1-G39Ln1kfHo+DZwQBYANFoCiHQ18=",
       "dev": true
     },
     "clone-buffer": {
@@ -2340,14 +4172,46 @@
       "dev": true
     },
     "cloneable-readable": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.0.0.tgz",
-      "integrity": "sha1-pikNQT8hemEjL5XkWP84QYz7ARc=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/cloneable-readable/-/cloneable-readable-1.1.3.tgz",
+      "integrity": "sha512-2EF8zTQOxYq70Y4XKtorQupqF0m49MBz2/yf5Bj+MHjvpG3Hy7sImifnqD6UA+TKYxeSV+u6qqQPawN5UvnpKQ==",
       "dev": true,
       "requires": {
         "inherits": "^2.0.1",
-        "process-nextick-args": "^1.0.6",
-        "through2": "^2.0.1"
+        "process-nextick-args": "^2.0.0",
+        "readable-stream": "^2.3.5"
+      },
+      "dependencies": {
+        "process-nextick-args": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+          "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "2.3.7",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
+          "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+          "dev": true,
+          "requires": {
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.3",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~2.0.0",
+            "safe-buffer": "~5.1.1",
+            "string_decoder": "~1.1.1",
+            "util-deprecate": "~1.0.1"
+          }
+        },
+        "string_decoder": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.1.0"
+          }
+        }
       }
     },
     "co": {
@@ -2371,9 +4235,9 @@
       "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c="
     },
     "collapse-white-space": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-1.0.3.tgz",
-      "integrity": "sha1-S5BvZw5aljqHt2sOFolkM0G2Ajw=",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/collapse-white-space/-/collapse-white-space-1.0.6.tgz",
+      "integrity": "sha512-jEovNnrhMuqyCcjfEJA56v0Xq8SkIoPKDyaHahwo3POf4qcSXqMYuwNcOTzp74vTsR9Tn08z4MxWqAhcekogkQ==",
       "dev": true
     },
     "collection-visit": {
@@ -2388,13 +4252,21 @@
     },
     "color": {
       "version": "0.11.4",
-      "resolved": "http://registry.npmjs.org/color/-/color-0.11.4.tgz",
+      "resolved": "https://registry.npmjs.org/color/-/color-0.11.4.tgz",
       "integrity": "sha1-bXtcdPtl6EHNSHkq0e1eB7kE12Q=",
       "dev": true,
       "requires": {
         "clone": "^1.0.2",
         "color-convert": "^1.3.0",
         "color-string": "^0.3.0"
+      },
+      "dependencies": {
+        "clone": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
+          "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=",
+          "dev": true
+        }
       }
     },
     "color-convert": {
@@ -2414,13 +4286,19 @@
     },
     "color-string": {
       "version": "0.3.0",
-      "resolved": "http://registry.npmjs.org/color-string/-/color-string-0.3.0.tgz",
+      "resolved": "https://registry.npmjs.org/color-string/-/color-string-0.3.0.tgz",
       "integrity": "sha1-J9RvtnAlxcL6JZk7+/V55HhBuZE=",
       "dev": true,
       "requires": {
         "color-name": "^1.0.0"
       }
     },
+    "colorette": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/colorette/-/colorette-1.2.2.tgz",
+      "integrity": "sha512-MKGMzyfeuutC/ZJ1cba9NqcNpfeqMUcYmyF1ZFY6/Cn7CNSAKx6a+s48sqLqyAiZuaP2TcqMhoo+dlwFnVxT9w==",
+      "dev": true
+    },
     "colormin": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/colormin/-/colormin-1.1.2.tgz",
@@ -2452,41 +4330,51 @@
       "dependencies": {
         "convert-source-map": {
           "version": "1.1.3",
-          "resolved": "http://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz",
+          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz",
           "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=",
           "dev": true
         }
       }
     },
     "combined-stream": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.7.tgz",
-      "integrity": "sha512-brWl9y6vOB1xYPZcpZde3N9zDByXTosAeMDo4p1wzo6UMOX4vumB+TP1RZ76sfE6Md68Q0NJSrE/gbezd4Ul+w==",
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
       "dev": true,
       "requires": {
         "delayed-stream": "~1.0.0"
       }
     },
     "comma-separated-tokens": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.4.tgz",
-      "integrity": "sha1-cgg+WNSkYvAYZvZhf02Yo807ikY=",
-      "dev": true,
-      "requires": {
-        "trim": "0.0.1"
-      }
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-1.0.8.tgz",
+      "integrity": "sha512-GHuDRO12Sypu2cV70d1dkA2EUmXHgntrzbpvOB+Qy+49ypNfGgFQIC2fhhXbnyrJRynDCAARsT7Ou0M6hirpfw==",
+      "dev": true
     },
     "command-line-args": {
-      "version": "5.0.2",
-      "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.0.2.tgz",
-      "integrity": "sha512-/qPcbL8zpqg53x4rAaqMFlRV4opN3pbla7I7k9x8kyOBMQoGT6WltjN6sXZuxOXw6DgdK7Ad+ijYS5gjcr7vlA==",
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/command-line-args/-/command-line-args-5.1.1.tgz",
+      "integrity": "sha512-hL/eG8lrll1Qy1ezvkant+trihbGnaKaeEjj6Scyr3DN+RC7iQ5Rz84IeLERfAWDGo0HBSNAakczwgCilDXnWg==",
       "dev": true,
       "requires": {
-        "argv-tools": "^0.1.1",
-        "array-back": "^2.0.0",
-        "find-replace": "^2.0.1",
+        "array-back": "^3.0.1",
+        "find-replace": "^3.0.0",
         "lodash.camelcase": "^4.3.0",
-        "typical": "^2.6.1"
+        "typical": "^4.0.0"
+      },
+      "dependencies": {
+        "array-back": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz",
+          "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==",
+          "dev": true
+        },
+        "typical": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/typical/-/typical-4.0.0.tgz",
+          "integrity": "sha512-VAH4IvQ7BDFYglMd7BPRDfLgxZZX4O4TFcRDA6EN5X7erNJJq+McIEp8np9aVtxrCJ6qx4GTYVfOWNjcqwZgRw==",
+          "dev": true
+        }
       }
     },
     "command-line-usage": {
@@ -2545,9 +4433,9 @@
       "dev": true
     },
     "component-emitter": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.2.1.tgz",
-      "integrity": "sha1-E3kY1teCg/ffemt8WmPhQOaUJeY=",
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.3.0.tgz",
+      "integrity": "sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==",
       "dev": true
     },
     "concat-map": {
@@ -2556,24 +4444,22 @@
       "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s="
     },
     "concat-stream": {
-      "version": "1.6.0",
-      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.0.tgz",
-      "integrity": "sha1-CqxmL9Ur54lk1VMvaUeE5wEQrPc=",
+      "version": "1.6.2",
+      "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
+      "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
       "dev": true,
       "requires": {
+        "buffer-from": "^1.0.0",
         "inherits": "^2.0.3",
         "readable-stream": "^2.2.2",
         "typedarray": "^0.0.6"
       }
     },
     "console-browserify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz",
-      "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=",
-      "dev": true,
-      "requires": {
-        "date-now": "^0.1.4"
-      }
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.2.0.tgz",
+      "integrity": "sha512-ZMkYO/LkF17QvCPqM0gxw8yUzigAOZOSWSHg91FH6orS7vcEj5dVZTidN2fQ14yBSdg97RqhSNwLUXInd52OTA==",
+      "dev": true
     },
     "console-control-strings": {
       "version": "1.1.0",
@@ -2621,24 +4507,50 @@
       "integrity": "sha1-rmh03GaTd4m4B1T/VCjfZoGcpQs=",
       "dev": true
     },
+    "core-js-compat": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.14.0.tgz",
+      "integrity": "sha512-R4NS2eupxtiJU+VwgkF9WTpnSfZW4pogwKHd8bclWU2sp93Pr5S1uYJI84cMOubJRou7bcfL0vmwtLslWN5p3A==",
+      "dev": true,
+      "requires": {
+        "browserslist": "^4.16.6",
+        "semver": "7.0.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-7.0.0.tgz",
+          "integrity": "sha512-+GB6zVA9LWh6zovYQLALHwv5rb2PHGlJi3lfiqIHxR0uuwCgefcOJc59v9fv1w8GbStwxuuqqAjI9NMAOOgq1A==",
+          "dev": true
+        }
+      }
+    },
     "core-util-is": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
       "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac="
     },
     "create-ecdh": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.3.tgz",
-      "integrity": "sha512-GbEHQPMOswGpKXM9kCWVrremUcBmjteUaQ01T9rkKCPDXfUHX0IoP9LpHYo2NPFampa4e+/pFDc3jQdxrxQLaw==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.4.tgz",
+      "integrity": "sha512-mf+TCx8wWc9VpuxfP2ht0iSISLZnt0JgWlrOKZiNqyUZWnjIaCIVNQArMHnCZKfEYRg6IM7A+NeJoN8gf/Ws0A==",
       "dev": true,
       "requires": {
         "bn.js": "^4.1.0",
-        "elliptic": "^6.0.0"
+        "elliptic": "^6.5.3"
+      },
+      "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        }
       }
     },
     "create-hash": {
       "version": "1.2.0",
-      "resolved": "http://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.2.0.tgz",
       "integrity": "sha512-z00bCGNHDG8mHAkP7CtT1qVu+bFQUPjYq/4Iv3C3kWjTFV10zIjfSoeqXo9Asws8gwSHDGj/hl2u4OGIjapeCg==",
       "dev": true,
       "requires": {
@@ -2651,7 +4563,7 @@
     },
     "create-hmac": {
       "version": "1.1.7",
-      "resolved": "http://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz",
+      "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.7.tgz",
       "integrity": "sha512-MJG9liiZ+ogc4TzUwuvbER1JRdgvUFSB5+VR/g5h82fGaIRWMWddtKBHi7/sVhfjQZ6SehlyhvQYrcYkaUIpLg==",
       "dev": true,
       "requires": {
@@ -2664,12 +4576,11 @@
       }
     },
     "create-react-class": {
-      "version": "15.6.3",
-      "resolved": "https://registry.npmjs.org/create-react-class/-/create-react-class-15.6.3.tgz",
-      "integrity": "sha512-M+/3Q6E6DLO6Yx3OwrWjwHBnvfXXYA7W+dFjt/ZDBemHO1DDZhsalX/NUtnTYclN6GfnBDRh4qRHjcDHmlJBJg==",
+      "version": "15.7.0",
+      "resolved": "https://registry.npmjs.org/create-react-class/-/create-react-class-15.7.0.tgz",
+      "integrity": "sha512-QZv4sFWG9S5RUvkTYWbflxeZX+JG7Cz0Tn33rQBJ+WFQTqTfUTjMjiv9tnfXazjsO5r0KhPs+AqCjyrQX6h2ng==",
       "dev": true,
       "requires": {
-        "fbjs": "^0.8.9",
         "loose-envify": "^1.3.1",
         "object-assign": "^4.1.1"
       }
@@ -2683,6 +4594,18 @@
         "lru-cache": "^4.0.1",
         "shebang-command": "^1.2.0",
         "which": "^1.2.9"
+      },
+      "dependencies": {
+        "lru-cache": {
+          "version": "4.1.5",
+          "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
+          "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",
+          "dev": true,
+          "requires": {
+            "pseudomap": "^1.0.2",
+            "yallist": "^2.1.2"
+          }
+        }
       }
     },
     "crypto-browserify": {
@@ -2706,19 +4629,19 @@
     },
     "css-color-names": {
       "version": "0.0.4",
-      "resolved": "http://registry.npmjs.org/css-color-names/-/css-color-names-0.0.4.tgz",
+      "resolved": "https://registry.npmjs.org/css-color-names/-/css-color-names-0.0.4.tgz",
       "integrity": "sha1-gIrcLnnPhHOAabZGyyDsJ762KeA=",
       "dev": true
     },
     "css-selector-parser": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-1.3.0.tgz",
-      "integrity": "sha1-XxrUPi2O77/cME/NOaUhZklD4+s=",
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/css-selector-parser/-/css-selector-parser-1.4.1.tgz",
+      "integrity": "sha512-HYPSb7y/Z7BNDCOrakL4raGO2zltZkbeXyAd6Tg9obzix6QhzxCotdBl6VT0Dv4vZfJGVz3WL/xaEI9Ly3ul0g==",
       "dev": true
     },
     "cssnano": {
       "version": "3.10.0",
-      "resolved": "http://registry.npmjs.org/cssnano/-/cssnano-3.10.0.tgz",
+      "resolved": "https://registry.npmjs.org/cssnano/-/cssnano-3.10.0.tgz",
       "integrity": "sha1-Tzj2zqK5sX+gFJDyPx3GjqZcHDg=",
       "dev": true,
       "requires": {
@@ -2811,6 +4734,12 @@
       "integrity": "sha1-B/vaOsrlNYqcUpmq+ICt8JU+0sI=",
       "dev": true
     },
+    "dash-ast": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/dash-ast/-/dash-ast-1.0.0.tgz",
+      "integrity": "sha512-Vy4dx7gquTeMcQR/hDkYLGUnwVil6vk4FOOct+djUnHOUWt+zJPJAaRIXaAFkPXtJjvlY7o3rfRu0/3hpnwoUA==",
+      "dev": true
+    },
     "dashdash": {
       "version": "1.14.1",
       "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz",
@@ -2820,16 +4749,11 @@
         "assert-plus": "^1.0.0"
       }
     },
-    "date-now": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz",
-      "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=",
-      "dev": true
-    },
     "debug": {
       "version": "2.6.9",
       "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
       "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "dev": true,
       "requires": {
         "ms": "2.0.0"
       }
@@ -2851,11 +4775,6 @@
       "integrity": "sha1-skbCuApXCkfBG+HZvRBw7IeLh84=",
       "dev": true
     },
-    "deep-extend": {
-      "version": "0.6.0",
-      "resolved": "https://registry.npmjs.org/deep-extend/-/deep-extend-0.6.0.tgz",
-      "integrity": "sha512-LOHxIOaPYdHlJRtCQfDIVZtfw/ufM8+rVj649RIHzcm/vGwQRXFt6OPqIFWsm2XEMrNIEtWR64sY1LEKD2vAOA=="
-    },
     "deep-is": {
       "version": "0.1.3",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz",
@@ -2863,22 +4782,22 @@
       "dev": true
     },
     "define-properties": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz",
-      "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+      "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
       "dev": true,
       "requires": {
-        "foreach": "^2.0.5",
-        "object-keys": "^1.0.8"
+        "object-keys": "^1.0.12"
       }
     },
     "define-property": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
-      "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
+      "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
       "dev": true,
       "requires": {
-        "is-descriptor": "^1.0.0"
+        "is-descriptor": "^1.0.2",
+        "isobject": "^3.0.1"
       },
       "dependencies": {
         "is-accessor-descriptor": {
@@ -2910,10 +4829,16 @@
             "kind-of": "^6.0.2"
           }
         },
+        "isobject": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+          "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
+          "dev": true
+        },
         "kind-of": {
-          "version": "6.0.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
-          "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
           "dev": true
         }
       }
@@ -2924,21 +4849,6 @@
       "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=",
       "dev": true
     },
-    "del": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/del/-/del-2.2.2.tgz",
-      "integrity": "sha1-wSyYHQZ4RshLyvhiz/kw2Qf/0ag=",
-      "dev": true,
-      "requires": {
-        "globby": "^5.0.0",
-        "is-path-cwd": "^1.0.0",
-        "is-path-in-cwd": "^1.0.0",
-        "object-assign": "^4.0.1",
-        "pify": "^2.0.0",
-        "pinkie-promise": "^2.0.0",
-        "rimraf": "^2.2.8"
-      }
-    },
     "delayed-stream": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
@@ -2951,21 +4861,21 @@
       "integrity": "sha1-hMbhWbgZBP3KWaDvRM2HDTElD5o="
     },
     "deps-sort": {
-      "version": "2.0.0",
-      "resolved": "http://registry.npmjs.org/deps-sort/-/deps-sort-2.0.0.tgz",
-      "integrity": "sha1-CRckkC6EZYJg65EHSMzNGvbiH7U=",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.1.tgz",
+      "integrity": "sha512-1orqXQr5po+3KI6kQb9A4jnXT1PBwggGl2d7Sq2xsnOeI9GPcE/tGcF9UiSZtZBM7MukY4cAh7MemS6tZYipfw==",
       "dev": true,
       "requires": {
         "JSONStream": "^1.0.3",
-        "shasum": "^1.0.0",
+        "shasum-object": "^1.0.0",
         "subarg": "^1.0.0",
         "through2": "^2.0.0"
       }
     },
     "des.js": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz",
-      "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.1.tgz",
+      "integrity": "sha512-Q0I4pfFrv2VPd34/vfLrFOoRmlYj3OV50i7fskps1jZWK1kApMWWT9G6RRUeYedLcBDIhnSDaUvJMb3AhUlaEA==",
       "dev": true,
       "requires": {
         "inherits": "^2.0.1",
@@ -2973,9 +4883,9 @@
       }
     },
     "detab": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/detab/-/detab-2.0.1.tgz",
-      "integrity": "sha512-/hhdqdQc5thGrqzjyO/pz76lDZ5GSuAs6goxOaKTsvPk7HNnzAyFN5lyHgqpX4/s1i66K8qMGj+VhA9504x7DQ==",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/detab/-/detab-2.0.4.tgz",
+      "integrity": "sha512-8zdsQA5bIkoRECvCrNKPla84lyoR7DSAyf7p0YgXzBO9PDJx8KntPUay7NS6yp+KdxdVtiE5SpHKtbp2ZQyA9g==",
       "dev": true,
       "requires": {
         "repeat-string": "^1.5.4"
@@ -2996,19 +4906,19 @@
       "integrity": "sha1-+hN8S9aY7fVc1c0CrFWfkaTEups="
     },
     "detective": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/detective/-/detective-4.5.0.tgz",
-      "integrity": "sha1-blqMaybmx6JUsca210kNmOyR7dE=",
+      "version": "4.7.1",
+      "resolved": "https://registry.npmjs.org/detective/-/detective-4.7.1.tgz",
+      "integrity": "sha512-H6PmeeUcZloWtdt4DAkFyzFL94arpHr3NOwwmVILFiy+9Qd4JTxxXrzfyGk/lmct2qVGBwTSwSXagqu2BxmWig==",
       "dev": true,
       "requires": {
-        "acorn": "^4.0.3",
+        "acorn": "^5.2.1",
         "defined": "^1.0.0"
       },
       "dependencies": {
         "acorn": {
-          "version": "4.0.13",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz",
-          "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=",
+          "version": "5.7.4",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz",
+          "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==",
           "dev": true
         }
       }
@@ -3021,13 +4931,21 @@
     },
     "diffie-hellman": {
       "version": "5.0.3",
-      "resolved": "http://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz",
+      "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.3.tgz",
       "integrity": "sha512-kqag/Nl+f3GwyK25fhUMYj81BUOrZ9IuJsjIcDE5icNM9FJHAVm3VcUDxdLPoQtTuUylWm6ZIknYJwwaPxsUzg==",
       "dev": true,
       "requires": {
         "bn.js": "^4.1.0",
         "miller-rabin": "^4.0.0",
         "randombytes": "^2.0.0"
+      },
+      "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        }
       }
     },
     "disparity": {
@@ -3077,9 +4995,9 @@
       },
       "dependencies": {
         "acorn": {
-          "version": "5.7.3",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.3.tgz",
-          "integrity": "sha512-T/zvzYRfbVojPWahDsE5evJdHb3oJoQfFbsrKM7w5Zcs++Tr257tia3BmMP8XYVjp1S9RZXQMh7gao96BlqZOw==",
+          "version": "5.7.4",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.7.4.tgz",
+          "integrity": "sha512-1D++VG7BhrtvQpNbBzovKNc1FLGGEE/oGe7b9xJm/RFHMBeUaUGpluV9RLjZa47YFdPcDAenEYuq9pQPcMdLJg==",
           "dev": true
         },
         "ajv": {
@@ -3109,16 +5027,144 @@
             "color-convert": "^1.9.0"
           }
         },
+        "anymatch": {
+          "version": "1.3.2",
+          "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz",
+          "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "micromatch": "^2.1.5",
+            "normalize-path": "^2.0.0"
+          }
+        },
+        "arr-diff": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
+          "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "arr-flatten": "^1.0.1"
+          }
+        },
+        "array-unique": {
+          "version": "0.2.1",
+          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
+          "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
+          "dev": true,
+          "optional": true
+        },
+        "babel-cli": {
+          "version": "6.26.0",
+          "resolved": "https://registry.npmjs.org/babel-cli/-/babel-cli-6.26.0.tgz",
+          "integrity": "sha1-UCq1SHTX24itALiHoGODzgPQAvE=",
+          "dev": true,
+          "requires": {
+            "babel-core": "^6.26.0",
+            "babel-polyfill": "^6.26.0",
+            "babel-register": "^6.26.0",
+            "babel-runtime": "^6.26.0",
+            "chokidar": "^1.6.1",
+            "commander": "^2.11.0",
+            "convert-source-map": "^1.5.0",
+            "fs-readdir-recursive": "^1.0.0",
+            "glob": "^7.1.2",
+            "lodash": "^4.17.4",
+            "output-file-sync": "^1.1.2",
+            "path-is-absolute": "^1.0.1",
+            "slash": "^1.0.0",
+            "source-map": "^0.5.6",
+            "v8flags": "^2.1.1"
+          }
+        },
         "babelify": {
           "version": "8.0.0",
           "resolved": "https://registry.npmjs.org/babelify/-/babelify-8.0.0.tgz",
           "integrity": "sha512-xVr63fKEvMWUrrIbqlHYsMcc5Zdw4FSVesAHgkgajyCE1W8gbm9rbMakqavhxKvikGYMhEcqxTwB/gQmQ6lBtw==",
           "dev": true
         },
+        "braces": {
+          "version": "1.8.5",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
+          "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "expand-range": "^1.8.1",
+            "preserve": "^0.2.0",
+            "repeat-element": "^1.1.2"
+          }
+        },
+        "browser-resolve": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-2.0.0.tgz",
+          "integrity": "sha512-7sWsQlYL2rGLy2IWm8WL8DCTJvYLc/qlOnsakDac87SOoCd16WLsaAMdCiAqsTNHIe+SXfaqyxyo6THoWqs8WQ==",
+          "dev": true,
+          "requires": {
+            "resolve": "^1.17.0"
+          }
+        },
+        "browserify": {
+          "version": "16.5.2",
+          "resolved": "https://registry.npmjs.org/browserify/-/browserify-16.5.2.tgz",
+          "integrity": "sha512-TkOR1cQGdmXU9zW4YukWzWVSJwrxmNdADFbqbE3HFgQWe5wqZmOawqZ7J/8MPCwk/W8yY7Y0h+7mOtcZxLP23g==",
+          "dev": true,
+          "requires": {
+            "JSONStream": "^1.0.3",
+            "assert": "^1.4.0",
+            "browser-pack": "^6.0.1",
+            "browser-resolve": "^2.0.0",
+            "browserify-zlib": "~0.2.0",
+            "buffer": "~5.2.1",
+            "cached-path-relative": "^1.0.0",
+            "concat-stream": "^1.6.0",
+            "console-browserify": "^1.1.0",
+            "constants-browserify": "~1.0.0",
+            "crypto-browserify": "^3.0.0",
+            "defined": "^1.0.0",
+            "deps-sort": "^2.0.0",
+            "domain-browser": "^1.2.0",
+            "duplexer2": "~0.1.2",
+            "events": "^2.0.0",
+            "glob": "^7.1.0",
+            "has": "^1.0.0",
+            "htmlescape": "^1.1.0",
+            "https-browserify": "^1.0.0",
+            "inherits": "~2.0.1",
+            "insert-module-globals": "^7.0.0",
+            "labeled-stream-splicer": "^2.0.0",
+            "mkdirp-classic": "^0.5.2",
+            "module-deps": "^6.2.3",
+            "os-browserify": "~0.3.0",
+            "parents": "^1.0.1",
+            "path-browserify": "~0.0.0",
+            "process": "~0.11.0",
+            "punycode": "^1.3.2",
+            "querystring-es3": "~0.2.0",
+            "read-only-stream": "^2.0.0",
+            "readable-stream": "^2.0.2",
+            "resolve": "^1.1.4",
+            "shasum": "^1.0.0",
+            "shell-quote": "^1.6.1",
+            "stream-browserify": "^2.0.0",
+            "stream-http": "^3.0.0",
+            "string_decoder": "^1.1.1",
+            "subarg": "^1.0.0",
+            "syntax-error": "^1.1.1",
+            "through2": "^2.0.0",
+            "timers-browserify": "^1.0.1",
+            "tty-browserify": "0.0.1",
+            "url": "~0.11.0",
+            "util": "~0.10.1",
+            "vm-browserify": "^1.0.0",
+            "xtend": "^4.0.0"
+          }
+        },
         "chalk": {
-          "version": "2.4.1",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-          "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.1",
@@ -3126,18 +5172,47 @@
             "supports-color": "^5.3.0"
           }
         },
+        "chokidar": {
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz",
+          "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "anymatch": "^1.3.0",
+            "async-each": "^1.0.0",
+            "fsevents": "^1.0.0",
+            "glob-parent": "^2.0.0",
+            "inherits": "^2.0.1",
+            "is-binary-path": "^1.0.0",
+            "is-glob": "^2.0.0",
+            "path-is-absolute": "^1.0.0",
+            "readdirp": "^2.0.0"
+          }
+        },
         "debug": {
-          "version": "3.2.6",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.6.tgz",
-          "integrity": "sha512-mel+jf7nrtEl5Pn1Qx46zARXKDpBbvzezse7p7LqINmdoIk8PYP5SySaxEmYv6TZ0JyEKA1hsCId6DIhgITtWQ==",
+          "version": "3.2.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+          "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
           "dev": true,
           "requires": {
             "ms": "^2.1.1"
           }
         },
+        "detective": {
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/detective/-/detective-5.2.0.tgz",
+          "integrity": "sha512-6SsIx+nUUbuK0EthKjv0zrdnajCCXVYGmbYYiYjFVpzcjwEs/JMDZ8tPRG29J/HhN56t3GJp2cGSWDRjjot8Pg==",
+          "dev": true,
+          "requires": {
+            "acorn-node": "^1.6.1",
+            "defined": "^1.0.0",
+            "minimist": "^1.1.1"
+          }
+        },
         "eslint": {
           "version": "4.19.1",
-          "resolved": "http://registry.npmjs.org/eslint/-/eslint-4.19.1.tgz",
+          "resolved": "https://registry.npmjs.org/eslint/-/eslint-4.19.1.tgz",
           "integrity": "sha512-bT3/1x1EbZB7phzYu7vCr1v3ONuzDtX8WjuM9c0iYxe+cq+pwcKEoQjl7zd3RpC6YOLgnSy3cTN58M2jcoPDIQ==",
           "dev": true,
           "requires": {
@@ -3183,7 +5258,7 @@
         },
         "espree": {
           "version": "3.5.4",
-          "resolved": "http://registry.npmjs.org/espree/-/espree-3.5.4.tgz",
+          "resolved": "https://registry.npmjs.org/espree/-/espree-3.5.4.tgz",
           "integrity": "sha512-yAcIQxtmMiB/jL32dzEp2enBeidsB7xWPLNiw3IIkpVds1P+h7qF9YwJq1yUNzp2OKXgAprs4F61ih66UsoD1A==",
           "dev": true,
           "requires": {
@@ -3191,32 +5266,74 @@
             "acorn-jsx": "^3.0.0"
           }
         },
-        "esprima": {
-          "version": "4.0.1",
-          "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
-          "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+        "events": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/events/-/events-2.1.0.tgz",
+          "integrity": "sha512-3Zmiobend8P9DjmKAty0Era4jV8oJ0yGYe2nJJAxgymF9+N8F2m0hhZiMoWtcfepExzNKZumFU3ksdQbInGWCg==",
           "dev": true
         },
+        "expand-brackets": {
+          "version": "0.1.5",
+          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
+          "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "is-posix-bracket": "^0.1.0"
+          }
+        },
+        "extglob": {
+          "version": "0.3.2",
+          "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
+          "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "is-extglob": "^1.0.0"
+          }
+        },
+        "fsevents": {
+          "version": "1.2.13",
+          "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz",
+          "integrity": "sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "bindings": "^1.5.0",
+            "nan": "^2.12.1"
+          }
+        },
+        "glob-parent": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
+          "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "is-glob": "^2.0.0"
+          }
+        },
         "globals": {
-          "version": "11.9.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-11.9.0.tgz",
-          "integrity": "sha512-5cJVtyXWH8PiJPVLZzzoIizXx944O4OmRro5MWKx5fT4MgcN7OfaMutPeaTdJCCURwbWdhhcCWcKIffPnmTzBg==",
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
           "dev": true
         },
-        "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-          "dev": true
-        },
-        "js-yaml": {
-          "version": "3.12.0",
-          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz",
-          "integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==",
+        "is-extglob": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
           "dev": true,
+          "optional": true
+        },
+        "is-glob": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+          "dev": true,
+          "optional": true,
           "requires": {
-            "argparse": "^1.0.7",
-            "esprima": "^4.0.0"
+            "is-extglob": "^1.0.0"
           }
         },
         "mdast-util-to-hast": {
@@ -3238,10 +5355,61 @@
             "xtend": "^4.0.1"
           }
         },
+        "micromatch": {
+          "version": "2.3.11",
+          "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
+          "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
+          "dev": true,
+          "optional": true,
+          "requires": {
+            "arr-diff": "^2.0.0",
+            "array-unique": "^0.2.1",
+            "braces": "^1.8.2",
+            "expand-brackets": "^0.1.4",
+            "extglob": "^0.3.1",
+            "filename-regex": "^2.0.0",
+            "is-extglob": "^1.0.0",
+            "is-glob": "^2.0.1",
+            "kind-of": "^3.0.2",
+            "normalize-path": "^2.0.1",
+            "object.omit": "^2.0.0",
+            "parse-glob": "^3.0.4",
+            "regex-cache": "^0.4.2"
+          }
+        },
+        "module-deps": {
+          "version": "6.2.3",
+          "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.3.tgz",
+          "integrity": "sha512-fg7OZaQBcL4/L+AK5f4iVqf9OMbCclXfy/znXRxTVhJSeW5AIlS9AwheYwDaXM3lVW7OBeaeUEY3gbaC6cLlSA==",
+          "dev": true,
+          "requires": {
+            "JSONStream": "^1.0.3",
+            "browser-resolve": "^2.0.0",
+            "cached-path-relative": "^1.0.2",
+            "concat-stream": "~1.6.0",
+            "defined": "^1.0.0",
+            "detective": "^5.2.0",
+            "duplexer2": "^0.1.2",
+            "inherits": "^2.0.1",
+            "parents": "^1.0.0",
+            "readable-stream": "^2.0.2",
+            "resolve": "^1.4.0",
+            "stream-combiner2": "^1.1.1",
+            "subarg": "^1.0.0",
+            "through2": "^2.0.0",
+            "xtend": "^4.0.0"
+          }
+        },
         "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+          "dev": true
+        },
+        "path-browserify": {
+          "version": "0.0.1",
+          "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.1.tgz",
+          "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==",
           "dev": true
         },
         "remark-html": {
@@ -3257,9 +5425,9 @@
           }
         },
         "remark-slug": {
-          "version": "5.1.1",
-          "resolved": "https://registry.npmjs.org/remark-slug/-/remark-slug-5.1.1.tgz",
-          "integrity": "sha512-r591rdoDPJkSSAVvEaTVUkqbMp7c7AyZfif14V0Dp66GQkOHzaPAS6wyhawSbqpS0ZdTnfJS+TltFoxzi6bdIA==",
+          "version": "5.1.2",
+          "resolved": "https://registry.npmjs.org/remark-slug/-/remark-slug-5.1.2.tgz",
+          "integrity": "sha512-DWX+Kd9iKycqyD+/B+gEFO3jjnt7Yg1O05lygYSNTe5i5PIxxxPjp5qPBDxPIzp5wreF7+1ROCwRgjEcqmzr3A==",
           "dev": true,
           "requires": {
             "github-slugger": "^1.0.0",
@@ -3267,6 +5435,37 @@
             "unist-util-visit": "^1.0.0"
           }
         },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
+        "slash": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
+          "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
+          "dev": true
+        },
+        "stream-browserify": {
+          "version": "2.0.2",
+          "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.2.tgz",
+          "integrity": "sha512-nX6hmklHs/gr2FuxYDltq8fJA1GDlxKQCz8O/IM4atRqBH8OORmBNgfvW5gG10GT/qQ9u0CzIvr2X5Pkt6ntqg==",
+          "dev": true,
+          "requires": {
+            "inherits": "~2.0.1",
+            "readable-stream": "^2.0.2"
+          }
+        },
+        "string_decoder": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.2.0"
+          }
+        },
         "strip-ansi": {
           "version": "4.0.0",
           "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz",
@@ -3284,6 +5483,15 @@
           "requires": {
             "has-flag": "^3.0.0"
           }
+        },
+        "util": {
+          "version": "0.10.4",
+          "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
+          "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==",
+          "dev": true,
+          "requires": {
+            "inherits": "2.0.3"
+          }
         }
       }
     },
@@ -3364,546 +5572,127 @@
       },
       "dependencies": {
         "ansi-styles": {
-          "version": "3.2.0",
-          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.0.tgz",
-          "integrity": "sha512-NnSOmMEYtVR2JVMIGTzynRkkaxtiq1xnFBcdQD/DnNCYPoEPsVJhM98BDyaoNOQIi7p4okdi3E27eN7GQbsUug==",
+          "version": "3.2.1",
+          "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+          "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
           "dev": true,
           "requires": {
             "color-convert": "^1.9.0"
           }
         },
-        "arr-diff": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
-          "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
-          "dev": true
-        },
-        "array-unique": {
-          "version": "0.3.2",
-          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
-          "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
-          "dev": true
-        },
-        "babel-generator": {
-          "version": "6.25.0",
-          "resolved": "https://registry.npmjs.org/babel-generator/-/babel-generator-6.25.0.tgz",
-          "integrity": "sha1-M6GvcNXyiQrrRlpKd5PB32qeqfw=",
+        "anymatch": {
+          "version": "1.3.2",
+          "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz",
+          "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==",
           "dev": true,
           "requires": {
-            "babel-messages": "^6.23.0",
-            "babel-runtime": "^6.22.0",
-            "babel-types": "^6.25.0",
-            "detect-indent": "^4.0.0",
-            "jsesc": "^1.3.0",
-            "lodash": "^4.2.0",
-            "source-map": "^0.5.0",
-            "trim-right": "^1.0.1"
+            "micromatch": "^2.1.5",
+            "normalize-path": "^2.0.0"
+          },
+          "dependencies": {
+            "micromatch": {
+              "version": "2.3.11",
+              "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
+              "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
+              "dev": true,
+              "requires": {
+                "arr-diff": "^2.0.0",
+                "array-unique": "^0.2.1",
+                "braces": "^1.8.2",
+                "expand-brackets": "^0.1.4",
+                "extglob": "^0.3.1",
+                "filename-regex": "^2.0.0",
+                "is-extglob": "^1.0.0",
+                "is-glob": "^2.0.1",
+                "kind-of": "^3.0.2",
+                "normalize-path": "^2.0.1",
+                "object.omit": "^2.0.0",
+                "parse-glob": "^3.0.4",
+                "regex-cache": "^0.4.2"
+              }
+            }
+          }
+        },
+        "arr-diff": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
+          "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
+          "dev": true,
+          "requires": {
+            "arr-flatten": "^1.0.1"
+          }
+        },
+        "array-unique": {
+          "version": "0.2.1",
+          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
+          "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
+          "dev": true
+        },
+        "babelify": {
+          "version": "7.3.0",
+          "resolved": "https://registry.npmjs.org/babelify/-/babelify-7.3.0.tgz",
+          "integrity": "sha1-qlau3nBn/XvVSWZu4W3ChQh+iOU=",
+          "dev": true,
+          "requires": {
+            "babel-core": "^6.0.14",
+            "object-assign": "^4.0.0"
           }
         },
         "braces": {
-          "version": "2.3.2",
-          "resolved": "https://registry.npmjs.org/braces/-/braces-2.3.2.tgz",
-          "integrity": "sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==",
+          "version": "1.8.5",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
+          "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
           "dev": true,
           "requires": {
-            "arr-flatten": "^1.1.0",
-            "array-unique": "^0.3.2",
-            "extend-shallow": "^2.0.1",
-            "fill-range": "^4.0.0",
-            "isobject": "^3.0.1",
-            "repeat-element": "^1.1.2",
-            "snapdragon": "^0.8.1",
-            "snapdragon-node": "^2.0.1",
-            "split-string": "^3.0.2",
-            "to-regex": "^3.0.1"
-          },
-          "dependencies": {
-            "define-property": {
-              "version": "0.2.5",
-              "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-              "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-              "dev": true,
-              "requires": {
-                "is-descriptor": "^0.1.0"
-              }
-            },
-            "is-accessor-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-              "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "is-data-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-              "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "regex-not": {
-              "version": "1.0.2",
-              "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
-              "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
-              "dev": true,
-              "requires": {
-                "extend-shallow": "^3.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                }
-              }
-            },
-            "snapdragon": {
-              "version": "0.8.2",
-              "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
-              "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
-              "dev": true,
-              "requires": {
-                "base": "^0.11.1",
-                "debug": "^2.2.0",
-                "define-property": "^0.2.5",
-                "extend-shallow": "^2.0.1",
-                "map-cache": "^0.2.2",
-                "source-map": "^0.5.6",
-                "source-map-resolve": "^0.5.0",
-                "use": "^3.1.0"
-              }
-            },
-            "snapdragon-node": {
-              "version": "2.1.1",
-              "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz",
-              "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
-              "dev": true,
-              "requires": {
-                "define-property": "^1.0.0",
-                "isobject": "^3.0.0",
-                "snapdragon-util": "^3.0.1"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "1.0.0",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
-                  "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^1.0.0"
-                  }
-                },
-                "is-descriptor": {
-                  "version": "1.0.2",
-                  "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-                  "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-                  "dev": true,
-                  "requires": {
-                    "is-accessor-descriptor": "^1.0.0",
-                    "is-data-descriptor": "^1.0.0",
-                    "kind-of": "^6.0.2"
-                  }
-                }
-              }
-            },
-            "split-string": {
-              "version": "3.1.0",
-              "resolved": "https://registry.npmjs.org/split-string/-/split-string-3.1.0.tgz",
-              "integrity": "sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==",
-              "dev": true,
-              "requires": {
-                "extend-shallow": "^3.0.0"
-              },
-              "dependencies": {
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                }
-              }
-            },
-            "to-regex": {
-              "version": "3.0.2",
-              "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
-              "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
-              "dev": true,
-              "requires": {
-                "define-property": "^2.0.2",
-                "extend-shallow": "^3.0.2",
-                "regex-not": "^1.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "2.0.2",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
-                  "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^1.0.2",
-                    "isobject": "^3.0.1"
-                  }
-                },
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                },
-                "is-descriptor": {
-                  "version": "1.0.2",
-                  "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-                  "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-                  "dev": true,
-                  "requires": {
-                    "is-accessor-descriptor": "^1.0.0",
-                    "is-data-descriptor": "^1.0.0",
-                    "kind-of": "^6.0.2"
-                  }
-                }
-              }
-            }
+            "expand-range": "^1.8.1",
+            "preserve": "^0.2.0",
+            "repeat-element": "^1.1.2"
           }
         },
         "chalk": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.1.0.tgz",
-          "integrity": "sha512-LUHGS/dge4ujbXMJrnihYMcL4AoOweGnw9Tp3kQuqy1Kx5c1qKjqvMJZ6nVJPMWJtKCTN72ZogH3oeSO9g9rXQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
-            "ansi-styles": "^3.1.0",
+            "ansi-styles": "^3.2.1",
             "escape-string-regexp": "^1.0.5",
-            "supports-color": "^4.0.0"
+            "supports-color": "^5.3.0"
           }
         },
-        "duplexer2": {
-          "version": "0.1.4",
-          "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz",
-          "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=",
+        "chokidar": {
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz",
+          "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=",
           "dev": true,
           "requires": {
-            "readable-stream": "^2.0.2"
+            "anymatch": "^1.3.0",
+            "async-each": "^1.0.0",
+            "fsevents": "^1.0.0",
+            "glob-parent": "^2.0.0",
+            "inherits": "^2.0.1",
+            "is-binary-path": "^1.0.0",
+            "is-glob": "^2.0.0",
+            "path-is-absolute": "^1.0.0",
+            "readdirp": "^2.0.0"
           }
         },
-        "esprima": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz",
-          "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==",
-          "dev": true
-        },
         "expand-brackets": {
-          "version": "2.1.4",
-          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz",
-          "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
+          "version": "0.1.5",
+          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
+          "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
           "dev": true,
           "requires": {
-            "debug": "^2.3.3",
-            "define-property": "^0.2.5",
-            "extend-shallow": "^2.0.1",
-            "posix-character-classes": "^0.1.0",
-            "regex-not": "^1.0.0",
-            "snapdragon": "^0.8.1",
-            "to-regex": "^3.0.1"
-          },
-          "dependencies": {
-            "define-property": {
-              "version": "0.2.5",
-              "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-              "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-              "dev": true,
-              "requires": {
-                "is-descriptor": "^0.1.0"
-              }
-            },
-            "is-accessor-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-              "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "is-data-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-              "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "posix-character-classes": {
-              "version": "0.1.1",
-              "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
-              "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
-              "dev": true
-            },
-            "regex-not": {
-              "version": "1.0.2",
-              "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
-              "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
-              "dev": true,
-              "requires": {
-                "extend-shallow": "^3.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                }
-              }
-            },
-            "snapdragon": {
-              "version": "0.8.2",
-              "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
-              "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
-              "dev": true,
-              "requires": {
-                "base": "^0.11.1",
-                "debug": "^2.2.0",
-                "define-property": "^0.2.5",
-                "extend-shallow": "^2.0.1",
-                "map-cache": "^0.2.2",
-                "source-map": "^0.5.6",
-                "source-map-resolve": "^0.5.0",
-                "use": "^3.1.0"
-              }
-            },
-            "to-regex": {
-              "version": "3.0.2",
-              "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
-              "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
-              "dev": true,
-              "requires": {
-                "define-property": "^2.0.2",
-                "extend-shallow": "^3.0.2",
-                "regex-not": "^1.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "2.0.2",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
-                  "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^1.0.2",
-                    "isobject": "^3.0.1"
-                  }
-                },
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                },
-                "is-descriptor": {
-                  "version": "1.0.2",
-                  "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-                  "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-                  "dev": true,
-                  "requires": {
-                    "is-accessor-descriptor": "^1.0.0",
-                    "is-data-descriptor": "^1.0.0",
-                    "kind-of": "^6.0.2"
-                  }
-                }
-              }
-            }
+            "is-posix-bracket": "^0.1.0"
           }
         },
         "extglob": {
-          "version": "2.0.4",
-          "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz",
-          "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
+          "version": "0.3.2",
+          "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
+          "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
           "dev": true,
           "requires": {
-            "array-unique": "^0.3.2",
-            "define-property": "^1.0.0",
-            "expand-brackets": "^2.1.4",
-            "extend-shallow": "^2.0.1",
-            "fragment-cache": "^0.2.1",
-            "regex-not": "^1.0.0",
-            "snapdragon": "^0.8.1",
-            "to-regex": "^3.0.1"
-          },
-          "dependencies": {
-            "fragment-cache": {
-              "version": "0.2.1",
-              "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
-              "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
-              "dev": true,
-              "requires": {
-                "map-cache": "^0.2.2"
-              }
-            },
-            "is-accessor-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-              "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "is-data-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-              "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "regex-not": {
-              "version": "1.0.2",
-              "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
-              "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
-              "dev": true,
-              "requires": {
-                "extend-shallow": "^3.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                }
-              }
-            },
-            "snapdragon": {
-              "version": "0.8.2",
-              "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
-              "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
-              "dev": true,
-              "requires": {
-                "base": "^0.11.1",
-                "debug": "^2.2.0",
-                "define-property": "^0.2.5",
-                "extend-shallow": "^2.0.1",
-                "map-cache": "^0.2.2",
-                "source-map": "^0.5.6",
-                "source-map-resolve": "^0.5.0",
-                "use": "^3.1.0"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "0.2.5",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-                  "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^0.1.0"
-                  }
-                }
-              }
-            },
-            "to-regex": {
-              "version": "3.0.2",
-              "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
-              "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
-              "dev": true,
-              "requires": {
-                "define-property": "^2.0.2",
-                "extend-shallow": "^3.0.2",
-                "regex-not": "^1.0.2",
-                "safe-regex": "^1.1.0"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "2.0.2",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
-                  "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^1.0.2",
-                    "isobject": "^3.0.1"
-                  }
-                },
-                "extend-shallow": {
-                  "version": "3.0.2",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-                  "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-                  "dev": true,
-                  "requires": {
-                    "assign-symbols": "^1.0.0",
-                    "is-extendable": "^1.0.1"
-                  }
-                },
-                "is-descriptor": {
-                  "version": "1.0.2",
-                  "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-                  "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-                  "dev": true,
-                  "requires": {
-                    "is-accessor-descriptor": "^1.0.0",
-                    "is-data-descriptor": "^1.0.0",
-                    "kind-of": "^6.0.2"
-                  }
-                }
-              }
-            }
-          }
-        },
-        "fill-range": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz",
-          "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
-          "dev": true,
-          "requires": {
-            "extend-shallow": "^2.0.1",
-            "is-number": "^3.0.0",
-            "repeat-string": "^1.6.1",
-            "to-regex-range": "^2.1.0"
-          },
-          "dependencies": {
-            "to-regex-range": {
-              "version": "2.1.1",
-              "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz",
-              "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
-              "dev": true,
-              "requires": {
-                "is-number": "^3.0.0",
-                "repeat-string": "^1.6.1"
-              }
-            }
+            "is-extglob": "^1.0.0"
           }
         },
         "find-up": {
@@ -3915,72 +5704,41 @@
             "locate-path": "^2.0.0"
           }
         },
-        "github-slugger": {
-          "version": "1.1.3",
-          "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.1.3.tgz",
-          "integrity": "sha1-MUpudZoYwrDMV2DVEsy6tUnFSac=",
+        "fsevents": {
+          "version": "1.2.13",
+          "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.2.13.tgz",
+          "integrity": "sha512-oWb1Z6mkHIskLzEJ/XWX0srkpkTQ7vaopMQkyaEIoq0fmtFVxOthb8cCxeT+p3ynTdkk/RZwbgG4brR5BeWECw==",
           "dev": true,
+          "optional": true,
           "requires": {
-            "emoji-regex": ">=6.0.0 <=6.1.1"
+            "bindings": "^1.5.0",
+            "nan": "^2.12.1"
           }
         },
-        "is-extendable": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-          "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
+        "glob-parent": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
+          "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
           "dev": true,
           "requires": {
-            "is-plain-object": "^2.0.4"
+            "is-glob": "^2.0.0"
           }
         },
-        "is-number": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
-          "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
-          "dev": true,
-          "requires": {
-            "kind-of": "^3.0.2"
-          },
-          "dependencies": {
-            "kind-of": {
-              "version": "3.2.2",
-              "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-              "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-              "dev": true,
-              "requires": {
-                "is-buffer": "^1.1.5"
-              }
-            }
-          }
-        },
-        "is-windows": {
-          "version": "1.0.2",
-          "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
-          "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
+        "is-extglob": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
           "dev": true
         },
-        "isobject": {
-          "version": "3.0.1",
-          "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
-          "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
-          "dev": true
-        },
-        "js-yaml": {
-          "version": "3.10.0",
-          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.10.0.tgz",
-          "integrity": "sha512-O2v52ffjLa9VeM43J4XocZE//WT9N0IiwDa3KSHH7Tu8CtH+1qM8SIZvnsTh6v+4yFy5KUY3BHUVwjpfAWsjIA==",
+        "is-glob": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
           "dev": true,
           "requires": {
-            "argparse": "^1.0.7",
-            "esprima": "^4.0.0"
+            "is-extglob": "^1.0.0"
           }
         },
-        "kind-of": {
-          "version": "6.0.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
-          "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
-          "dev": true
-        },
         "load-json-file": {
           "version": "2.0.0",
           "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz",
@@ -4001,287 +5759,6 @@
             }
           }
         },
-        "micromatch": {
-          "version": "3.1.10",
-          "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz",
-          "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
-          "dev": true,
-          "requires": {
-            "arr-diff": "^4.0.0",
-            "array-unique": "^0.3.2",
-            "braces": "^2.3.1",
-            "define-property": "^2.0.2",
-            "extend-shallow": "^3.0.2",
-            "extglob": "^2.0.4",
-            "fragment-cache": "^0.2.1",
-            "kind-of": "^6.0.2",
-            "nanomatch": "^1.2.9",
-            "object.pick": "^1.3.0",
-            "regex-not": "^1.0.0",
-            "snapdragon": "^0.8.1",
-            "to-regex": "^3.0.2"
-          },
-          "dependencies": {
-            "define-property": {
-              "version": "2.0.2",
-              "resolved": "https://registry.npmjs.org/define-property/-/define-property-2.0.2.tgz",
-              "integrity": "sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==",
-              "dev": true,
-              "requires": {
-                "is-descriptor": "^1.0.2",
-                "isobject": "^3.0.1"
-              }
-            },
-            "extend-shallow": {
-              "version": "3.0.2",
-              "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-              "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-              "dev": true,
-              "requires": {
-                "assign-symbols": "^1.0.0",
-                "is-extendable": "^1.0.1"
-              }
-            },
-            "fragment-cache": {
-              "version": "0.2.1",
-              "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
-              "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
-              "dev": true,
-              "requires": {
-                "map-cache": "^0.2.2"
-              }
-            },
-            "is-accessor-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
-              "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "is-data-descriptor": {
-              "version": "1.0.0",
-              "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
-              "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
-              "dev": true,
-              "requires": {
-                "kind-of": "^6.0.0"
-              }
-            },
-            "is-descriptor": {
-              "version": "1.0.2",
-              "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
-              "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
-              "dev": true,
-              "requires": {
-                "is-accessor-descriptor": "^1.0.0",
-                "is-data-descriptor": "^1.0.0",
-                "kind-of": "^6.0.2"
-              }
-            },
-            "nanomatch": {
-              "version": "1.2.13",
-              "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz",
-              "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
-              "dev": true,
-              "requires": {
-                "arr-diff": "^4.0.0",
-                "array-unique": "^0.3.2",
-                "define-property": "^2.0.2",
-                "extend-shallow": "^3.0.2",
-                "fragment-cache": "^0.2.1",
-                "is-windows": "^1.0.2",
-                "kind-of": "^6.0.2",
-                "object.pick": "^1.3.0",
-                "regex-not": "^1.0.0",
-                "snapdragon": "^0.8.1",
-                "to-regex": "^3.0.1"
-              }
-            },
-            "object.pick": {
-              "version": "1.3.0",
-              "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
-              "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
-              "dev": true,
-              "requires": {
-                "isobject": "^3.0.1"
-              }
-            },
-            "regex-not": {
-              "version": "1.0.2",
-              "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
-              "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
-              "dev": true,
-              "requires": {
-                "extend-shallow": "^3.0.2",
-                "safe-regex": "^1.1.0"
-              }
-            },
-            "snapdragon": {
-              "version": "0.8.2",
-              "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
-              "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
-              "dev": true,
-              "requires": {
-                "base": "^0.11.1",
-                "debug": "^2.2.0",
-                "define-property": "^0.2.5",
-                "extend-shallow": "^2.0.1",
-                "map-cache": "^0.2.2",
-                "source-map": "^0.5.6",
-                "source-map-resolve": "^0.5.0",
-                "use": "^3.1.0"
-              },
-              "dependencies": {
-                "define-property": {
-                  "version": "0.2.5",
-                  "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
-                  "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
-                  "dev": true,
-                  "requires": {
-                    "is-descriptor": "^0.1.0"
-                  }
-                },
-                "extend-shallow": {
-                  "version": "2.0.1",
-                  "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-                  "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
-                  "dev": true,
-                  "requires": {
-                    "is-extendable": "^0.1.0"
-                  }
-                },
-                "is-accessor-descriptor": {
-                  "version": "0.1.6",
-                  "resolved": "http://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-0.1.6.tgz",
-                  "integrity": "sha1-qeEss66Nh2cn7u84Q/igiXtcmNY=",
-                  "dev": true,
-                  "requires": {
-                    "kind-of": "^3.0.2"
-                  },
-                  "dependencies": {
-                    "kind-of": {
-                      "version": "3.2.2",
-                      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-                      "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-                      "dev": true,
-                      "requires": {
-                        "is-buffer": "^1.1.5"
-                      }
-                    }
-                  }
-                },
-                "is-data-descriptor": {
-                  "version": "0.1.4",
-                  "resolved": "http://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
-                  "integrity": "sha1-C17mSDiOLIYCgueT8YVv7D8wG1Y=",
-                  "dev": true,
-                  "requires": {
-                    "kind-of": "^3.0.2"
-                  },
-                  "dependencies": {
-                    "kind-of": {
-                      "version": "3.2.2",
-                      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz",
-                      "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=",
-                      "dev": true,
-                      "requires": {
-                        "is-buffer": "^1.1.5"
-                      }
-                    }
-                  }
-                },
-                "is-descriptor": {
-                  "version": "0.1.6",
-                  "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-0.1.6.tgz",
-                  "integrity": "sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==",
-                  "dev": true,
-                  "requires": {
-                    "is-accessor-descriptor": "^0.1.6",
-                    "is-data-descriptor": "^0.1.4",
-                    "kind-of": "^5.0.0"
-                  }
-                },
-                "is-extendable": {
-                  "version": "0.1.1",
-                  "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz",
-                  "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=",
-                  "dev": true
-                },
-                "kind-of": {
-                  "version": "5.1.0",
-                  "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz",
-                  "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==",
-                  "dev": true
-                }
-              }
-            },
-            "to-regex": {
-              "version": "3.0.2",
-              "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
-              "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
-              "dev": true,
-              "requires": {
-                "define-property": "^2.0.2",
-                "extend-shallow": "^3.0.2",
-                "regex-not": "^1.0.2",
-                "safe-regex": "^1.1.0"
-              }
-            }
-          }
-        },
-        "module-deps-sortable": {
-          "version": "4.0.6",
-          "resolved": "https://registry.npmjs.org/module-deps-sortable/-/module-deps-sortable-4.0.6.tgz",
-          "integrity": "sha1-ElGkuixEqS32mJvQKdoSGk8hCbA=",
-          "dev": true,
-          "requires": {
-            "JSONStream": "^1.0.3",
-            "browser-resolve": "^1.7.0",
-            "concat-stream": "~1.5.0",
-            "defined": "^1.0.0",
-            "detective": "^4.0.0",
-            "duplexer2": "^0.1.2",
-            "inherits": "^2.0.1",
-            "parents": "^1.0.0",
-            "readable-stream": "^2.0.2",
-            "resolve": "^1.1.3",
-            "stream-combiner2": "^1.1.1",
-            "subarg": "^1.0.0",
-            "through2": "^2.0.0",
-            "xtend": "^4.0.0"
-          },
-          "dependencies": {
-            "concat-stream": {
-              "version": "1.5.2",
-              "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.5.2.tgz",
-              "integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=",
-              "dev": true,
-              "requires": {
-                "inherits": "~2.0.1",
-                "readable-stream": "~2.0.0",
-                "typedarray": "~0.0.5"
-              },
-              "dependencies": {
-                "readable-stream": {
-                  "version": "2.0.6",
-                  "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz",
-                  "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=",
-                  "dev": true,
-                  "requires": {
-                    "core-util-is": "~1.0.0",
-                    "inherits": "~2.0.1",
-                    "isarray": "~1.0.0",
-                    "process-nextick-args": "~1.0.6",
-                    "string_decoder": "~0.10.x",
-                    "util-deprecate": "~1.0.1"
-                  }
-                }
-              }
-            }
-          }
-        },
         "path-type": {
           "version": "2.0.0",
           "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz",
@@ -4326,12 +5803,6 @@
             "read-pkg": "^2.0.0"
           }
         },
-        "string_decoder": {
-          "version": "0.10.31",
-          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
-          "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
-          "dev": true
-        },
         "strip-bom": {
           "version": "3.0.0",
           "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz",
@@ -4339,12 +5810,12 @@
           "dev": true
         },
         "supports-color": {
-          "version": "4.4.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.4.0.tgz",
-          "integrity": "sha512-rKC3+DyXWgK0ZLKwmRsrkyHVZAjNkfzeehuFWdGGcqGDTZFH73+RH6S/RDAAxl9GusSjZSUWYLmT9N5pzXFOXQ==",
+          "version": "5.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+          "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
           "dev": true,
           "requires": {
-            "has-flag": "^2.0.0"
+            "has-flag": "^3.0.0"
           }
         },
         "yargs": {
@@ -4457,6 +5928,15 @@
       "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==",
       "dev": true
     },
+    "dotignore": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/dotignore/-/dotignore-0.1.2.tgz",
+      "integrity": "sha512-UGGGWfSauusaVJC+8fgV+NVvBXkCTmVv7sk6nojDZZvuOUNGUy0Zk4UpHQD6EDjS0jpBwcACvH4eofvyzBcRDw==",
+      "dev": true,
+      "requires": {
+        "minimatch": "^3.0.4"
+      }
+    },
     "duplexer": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/duplexer/-/duplexer-0.1.1.tgz",
@@ -4473,9 +5953,9 @@
       }
     },
     "duplexify": {
-      "version": "3.5.1",
-      "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.5.1.tgz",
-      "integrity": "sha512-j5goxHTwVED1Fpe5hh3q9R93Kip0Bg2KVAt4f8CEYM3UEwYcPSvWbXaUQOzdX/HtiNomipv+gU7ASQPDbV7pGQ==",
+      "version": "3.7.1",
+      "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.7.1.tgz",
+      "integrity": "sha512-07z8uv2wMyS51kKhD1KsdXJg5WQ6t93RneqRxUHnskXVtlYYkLqM0gqStQZ3pj073g687jPCHrqNfCzawLYh5g==",
       "dev": true,
       "requires": {
         "end-of-stream": "^1.0.0",
@@ -4500,12 +5980,6 @@
       "integrity": "sha512-ttRjmPD5oaTtXOoxhFp9aZvMB14kBjapYaiBuzBB1elOgSLU9P2Ev86G2OClBg+uspUXERsIzXKpUWweH2K4Xg==",
       "dev": true
     },
-    "ebnf-parser": {
-      "version": "0.1.10",
-      "resolved": "https://registry.npmjs.org/ebnf-parser/-/ebnf-parser-0.1.10.tgz",
-      "integrity": "sha1-zR9rpHfFY4xAyX7ZtXLbW6tdgzE=",
-      "dev": true
-    },
     "ecc-jsbn": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.2.tgz",
@@ -4517,24 +5991,38 @@
       }
     },
     "electron-to-chromium": {
-      "version": "1.3.88",
-      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.88.tgz",
-      "integrity": "sha512-UPV4NuQMKeUh1S0OWRvwg0PI8ASHN9kBC8yDTk1ROXLC85W5GnhTRu/MZu3Teqx3JjlQYuckuHYXSUSgtb3J+A==",
+      "version": "1.3.752",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.752.tgz",
+      "integrity": "sha512-2Tg+7jSl3oPxgsBsWKh5H83QazTkmWG/cnNwJplmyZc7KcN61+I10oUgaXSVk/NwfvN3BdkKDR4FYuRBQQ2v0A==",
       "dev": true
     },
     "elliptic": {
-      "version": "6.4.1",
-      "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.1.tgz",
-      "integrity": "sha512-BsXLz5sqX8OHcsh7CqBMztyXARmGQ3LWPtGjJi6DiJHq5C/qvi9P3OqgswKSDftbu8+IoI/QDTAm2fFnQ9SZSQ==",
+      "version": "6.5.4",
+      "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz",
+      "integrity": "sha512-iLhC6ULemrljPZb+QutR5TQGB+pdW6KGD5RSegS+8sorOZT+rdQFbsQFJgvN3eRqNALqJer4oQ16YvJHlU8hzQ==",
       "dev": true,
       "requires": {
-        "bn.js": "^4.4.0",
-        "brorand": "^1.0.1",
+        "bn.js": "^4.11.9",
+        "brorand": "^1.1.0",
         "hash.js": "^1.0.0",
-        "hmac-drbg": "^1.0.0",
-        "inherits": "^2.0.1",
-        "minimalistic-assert": "^1.0.0",
-        "minimalistic-crypto-utils": "^1.0.0"
+        "hmac-drbg": "^1.0.1",
+        "inherits": "^2.0.4",
+        "minimalistic-assert": "^1.0.1",
+        "minimalistic-crypto-utils": "^1.0.1"
+      },
+      "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        },
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+          "dev": true
+        }
       }
     },
     "emoji-regex": {
@@ -4544,31 +6032,41 @@
       "dev": true
     },
     "encoding": {
-      "version": "0.1.12",
-      "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz",
-      "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=",
+      "version": "0.1.13",
+      "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz",
+      "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==",
       "dev": true,
       "requires": {
-        "iconv-lite": "~0.4.13"
+        "iconv-lite": "^0.6.2"
+      },
+      "dependencies": {
+        "iconv-lite": {
+          "version": "0.6.3",
+          "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+          "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+          "dev": true,
+          "requires": {
+            "safer-buffer": ">= 2.1.2 < 3.0.0"
+          }
+        }
       }
     },
     "end-of-stream": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.0.tgz",
-      "integrity": "sha1-epDYM+/abPpurA9JSduw+tOmMgY=",
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.4.tgz",
+      "integrity": "sha512-+uw1inIHVPQoaVuHzRyXd21icM+cnt4CzD5rW+NC1wjOUSTOs+Te7FOv7AhN7vS9x/oIyhLP5PR1H+phQAHu5Q==",
       "dev": true,
       "requires": {
         "once": "^1.4.0"
       }
     },
     "error": {
-      "version": "7.0.2",
-      "resolved": "https://registry.npmjs.org/error/-/error-7.0.2.tgz",
-      "integrity": "sha1-pfdf/02ZJhJt2sDqXcOOaJFTywI=",
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/error/-/error-7.2.1.tgz",
+      "integrity": "sha512-fo9HBvWnx3NGUKMvMwB/CBCMMrfEJgbDTVDEkPygA3Bdd3lM1OyCd+rbQ8BwnpF6GdVeOLDNmyL4N5Bg80ZvdA==",
       "dev": true,
       "requires": {
-        "string-template": "~0.2.1",
-        "xtend": "~4.0.0"
+        "string-template": "~0.2.1"
       }
     },
     "error-ex": {
@@ -4589,27 +6087,91 @@
       }
     },
     "es-abstract": {
-      "version": "1.9.0",
-      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.9.0.tgz",
-      "integrity": "sha512-kk3IJoKo7A3pWJc0OV8yZ/VEX2oSUytfekrJiqoxBlKJMFAJVJVpGdHClCCTdv+Fn2zHfpDHHIelMFhZVfef3Q==",
+      "version": "1.18.3",
+      "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.18.3.tgz",
+      "integrity": "sha512-nQIr12dxV7SSxE6r6f1l3DtAeEYdsGpps13dR0TwJg1S8gyp4ZPgy3FZcHBgbiQqnoqSTb+oC+kO4UQ0C/J8vw==",
       "dev": true,
       "requires": {
-        "es-to-primitive": "^1.1.1",
+        "call-bind": "^1.0.2",
+        "es-to-primitive": "^1.2.1",
         "function-bind": "^1.1.1",
-        "has": "^1.0.1",
-        "is-callable": "^1.1.3",
-        "is-regex": "^1.0.4"
+        "get-intrinsic": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.2",
+        "is-callable": "^1.2.3",
+        "is-negative-zero": "^2.0.1",
+        "is-regex": "^1.1.3",
+        "is-string": "^1.0.6",
+        "object-inspect": "^1.10.3",
+        "object-keys": "^1.1.1",
+        "object.assign": "^4.1.2",
+        "string.prototype.trimend": "^1.0.4",
+        "string.prototype.trimstart": "^1.0.4",
+        "unbox-primitive": "^1.0.1"
+      },
+      "dependencies": {
+        "get-intrinsic": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
+          "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+          "dev": true,
+          "requires": {
+            "function-bind": "^1.1.1",
+            "has": "^1.0.3",
+            "has-symbols": "^1.0.1"
+          }
+        },
+        "has-symbols": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
+          "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+          "dev": true
+        },
+        "is-callable": {
+          "version": "1.2.3",
+          "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.3.tgz",
+          "integrity": "sha512-J1DcMe8UYTBSrKezuIUTUwjXsho29693unXM2YhJUTR2txK/eG47bvNa/wipPFmZFgr/N6f1GA66dv0mEyTIyQ==",
+          "dev": true
+        },
+        "string.prototype.trimend": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.4.tgz",
+          "integrity": "sha512-y9xCjw1P23Awk8EvTpcyL2NIr1j7wJ39f+k6lvRnSMz+mz9CGz9NYPelDk42kOz6+ql8xjfK8oYzy3jAP5QU5A==",
+          "dev": true,
+          "requires": {
+            "call-bind": "^1.0.2",
+            "define-properties": "^1.1.3"
+          }
+        },
+        "string.prototype.trimstart": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.4.tgz",
+          "integrity": "sha512-jh6e984OBfvxS50tdY2nRZnoC5/mLFKOREQfw8t5yytkoUsJRNxvI/E39qu1sD0OtWI3OC0XgKSmcWwziwYuZw==",
+          "dev": true,
+          "requires": {
+            "call-bind": "^1.0.2",
+            "define-properties": "^1.1.3"
+          }
+        }
       }
     },
     "es-to-primitive": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz",
-      "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
+      "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
       "dev": true,
       "requires": {
-        "is-callable": "^1.1.1",
+        "is-callable": "^1.1.4",
         "is-date-object": "^1.0.1",
-        "is-symbol": "^1.0.1"
+        "is-symbol": "^1.0.2"
+      },
+      "dependencies": {
+        "is-callable": {
+          "version": "1.2.3",
+          "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.3.tgz",
+          "integrity": "sha512-J1DcMe8UYTBSrKezuIUTUwjXsho29693unXM2YhJUTR2txK/eG47bvNa/wipPFmZFgr/N6f1GA66dv0mEyTIyQ==",
+          "dev": true
+        }
       }
     },
     "es5-ext": {
@@ -4645,9 +6207,9 @@
       }
     },
     "es6-promise": {
-      "version": "4.2.5",
-      "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.5.tgz",
-      "integrity": "sha512-n6wvpdE43VFtJq+lUDYDBFUwV8TZbuGXLV4D6wKafg13ldznKsyEvatubnmUe31zcvelSzOHF+XbaT+Bl9ObDg==",
+      "version": "4.2.8",
+      "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz",
+      "integrity": "sha512-HJDGx5daxeIvxdBxvG2cb9g4tEvwIk3i8+nhX0yGrYmZUzbkdg8QbDevheDB8gd0//uPj4c1EQua8Q+MViT0/w==",
       "dev": true
     },
     "es6-symbol": {
@@ -4671,6 +6233,12 @@
         }
       }
     },
+    "escalade": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
+      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "dev": true
+    },
     "escape-string-regexp": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
@@ -4700,70 +6268,75 @@
       }
     },
     "eslint": {
-      "version": "5.10.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-5.10.0.tgz",
-      "integrity": "sha512-HpqzC+BHULKlnPwWae9MaVZ5AXJKpkxCVXQHrFaRw3hbDj26V/9ArYM4Rr/SQ8pi6qUPLXSSXC4RBJlyq2Z2OQ==",
+      "version": "5.16.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-5.16.0.tgz",
+      "integrity": "sha512-S3Rz11i7c8AA5JPv7xAH+dOyq/Cu/VXHiHXBPOU1k/JAM5dXqQPt3qcrhpHSorXmrpu2g0gkIBVXAqCpzfoZIg==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.0.0",
-        "ajv": "^6.5.3",
+        "ajv": "^6.9.1",
         "chalk": "^2.1.0",
         "cross-spawn": "^6.0.5",
         "debug": "^4.0.1",
-        "doctrine": "^2.1.0",
-        "eslint-scope": "^4.0.0",
+        "doctrine": "^3.0.0",
+        "eslint-scope": "^4.0.3",
         "eslint-utils": "^1.3.1",
         "eslint-visitor-keys": "^1.0.0",
-        "espree": "^5.0.0",
+        "espree": "^5.0.1",
         "esquery": "^1.0.1",
         "esutils": "^2.0.2",
-        "file-entry-cache": "^2.0.0",
+        "file-entry-cache": "^5.0.1",
         "functional-red-black-tree": "^1.0.1",
         "glob": "^7.1.2",
         "globals": "^11.7.0",
         "ignore": "^4.0.6",
+        "import-fresh": "^3.0.0",
         "imurmurhash": "^0.1.4",
-        "inquirer": "^6.1.0",
-        "js-yaml": "^3.12.0",
+        "inquirer": "^6.2.2",
+        "js-yaml": "^3.13.0",
         "json-stable-stringify-without-jsonify": "^1.0.1",
         "levn": "^0.3.0",
-        "lodash": "^4.17.5",
+        "lodash": "^4.17.11",
         "minimatch": "^3.0.4",
         "mkdirp": "^0.5.1",
         "natural-compare": "^1.4.0",
         "optionator": "^0.8.2",
         "path-is-inside": "^1.0.2",
-        "pluralize": "^7.0.0",
         "progress": "^2.0.0",
         "regexpp": "^2.0.1",
-        "require-uncached": "^1.0.3",
         "semver": "^5.5.1",
         "strip-ansi": "^4.0.0",
         "strip-json-comments": "^2.0.1",
-        "table": "^5.0.2",
+        "table": "^5.2.3",
         "text-table": "^0.2.0"
       },
       "dependencies": {
         "@babel/code-frame": {
-          "version": "7.0.0",
-          "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.0.0.tgz",
-          "integrity": "sha512-OfC2uemaknXr87bdLUkWog7nYuliM9Ij5HUcajsVcMCpQrcLmtxRbVFTIqmcSkSeYRBFBRxs2FiUqFJDLdiebA==",
+          "version": "7.12.11",
+          "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.11.tgz",
+          "integrity": "sha512-Zt1yodBx1UcyiePMSkWnU4hPqhwq7hGi2nFL1LeA3EUl+q2LQx16MISgJ0+z7dnmgvP9QtIleuETGOiOH1RcIw==",
           "dev": true,
           "requires": {
-            "@babel/highlight": "^7.0.0"
+            "@babel/highlight": "^7.10.4"
           }
         },
         "@babel/highlight": {
-          "version": "7.0.0",
-          "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.0.0.tgz",
-          "integrity": "sha512-UFMC4ZeFC48Tpvj7C8UgLvtkaUuovQX+5xNWrsIoMG8o2z+XFKjKaN9iVmS84dPwVN00W4wPmqvYoZF3EGAsfw==",
+          "version": "7.10.4",
+          "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.10.4.tgz",
+          "integrity": "sha512-i6rgnR/YgPEQzZZnbTHHuZdlE8qyoBNalD6F+q4vAFlcMEcqmkoG+mPqJYJCo63qPf74+Y1UZsl3l6f7/RIkmA==",
           "dev": true,
           "requires": {
+            "@babel/helper-validator-identifier": "^7.10.4",
             "chalk": "^2.0.0",
-            "esutils": "^2.0.2",
             "js-tokens": "^4.0.0"
           }
         },
+        "ansi-escapes": {
+          "version": "3.2.0",
+          "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-3.2.0.tgz",
+          "integrity": "sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==",
+          "dev": true
+        },
         "ansi-regex": {
           "version": "3.0.0",
           "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz",
@@ -4780,9 +6353,9 @@
           }
         },
         "chalk": {
-          "version": "2.4.1",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-          "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.1",
@@ -4810,18 +6383,33 @@
           }
         },
         "debug": {
-          "version": "4.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-4.1.0.tgz",
-          "integrity": "sha512-heNPJUJIqC+xB6ayLAMHaIrmN9HKa7aQO8MGqKpvCA+uJYVcvR6l5kgdrhRuwPFHU7P5/A1w0BjByPHwpfTDKg==",
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
           "dev": true,
           "requires": {
-            "ms": "^2.1.1"
+            "ms": "2.1.2"
           }
         },
+        "doctrine": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+          "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+          "dev": true,
+          "requires": {
+            "esutils": "^2.0.2"
+          }
+        },
+        "emoji-regex": {
+          "version": "7.0.3",
+          "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+          "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA==",
+          "dev": true
+        },
         "eslint-scope": {
-          "version": "4.0.0",
-          "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.0.tgz",
-          "integrity": "sha512-1G6UTDi7Jc1ELFwnR58HV4fK9OQK4S6N985f166xqXxpjU6plxFISJa2Ba9KCQuFa8RCnj/lSFJbHo7UFDBnUA==",
+          "version": "4.0.3",
+          "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-4.0.3.tgz",
+          "integrity": "sha512-p7VutNr1O/QrxysMo3E45FjYDTeXBy0iTltPFNSqKAIfjDSXC+4dj+qfyuD8bfAXrW/y6lW3O76VaYNPKfpKrg==",
           "dev": true,
           "requires": {
             "esrecurse": "^4.1.0",
@@ -4835,9 +6423,9 @@
           "dev": true
         },
         "external-editor": {
-          "version": "3.0.3",
-          "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.0.3.tgz",
-          "integrity": "sha512-bn71H9+qWoOQKyZDo25mOMVpSmXROAsTJVVVYzrrtol3d4y+AsKjf4Iwl2Q+IuT0kFSQ1qo166UuIwqYq7mGnA==",
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
+          "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==",
           "dev": true,
           "requires": {
             "chardet": "^0.7.0",
@@ -4854,10 +6442,30 @@
             "escape-string-regexp": "^1.0.5"
           }
         },
+        "file-entry-cache": {
+          "version": "5.0.1",
+          "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-5.0.1.tgz",
+          "integrity": "sha512-bCg29ictuBaKUwwArK4ouCaqDgLZcysCFLmM/Yn/FDoqndh/9vNuQfXRDvTuXKLxfD/JtZQGKFT8MGcJBK644g==",
+          "dev": true,
+          "requires": {
+            "flat-cache": "^2.0.1"
+          }
+        },
+        "flat-cache": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-2.0.1.tgz",
+          "integrity": "sha512-LoQe6yDuUMDzQAEH8sgmh4Md6oZnc/7PjtwjNFSzveXqSHt6ka9fPBuso7IGf9Rz4uqnSnWiFH2B/zj24a5ReA==",
+          "dev": true,
+          "requires": {
+            "flatted": "^2.0.0",
+            "rimraf": "2.6.3",
+            "write": "1.0.3"
+          }
+        },
         "globals": {
-          "version": "11.9.0",
-          "resolved": "https://registry.npmjs.org/globals/-/globals-11.9.0.tgz",
-          "integrity": "sha512-5cJVtyXWH8PiJPVLZzzoIizXx944O4OmRro5MWKx5fT4MgcN7OfaMutPeaTdJCCURwbWdhhcCWcKIffPnmTzBg==",
+          "version": "11.12.0",
+          "resolved": "https://registry.npmjs.org/globals/-/globals-11.12.0.tgz",
+          "integrity": "sha512-WOBp/EEGUiIsJSp7wcv/y6MO+lV9UoncWqxuFfm8eBwzWNgyfBd6Gz+IeKQ9jCmyhoH99g15M3T+QaVHFjizVA==",
           "dev": true
         },
         "has-flag": {
@@ -4873,39 +6481,45 @@
           "dev": true
         },
         "inquirer": {
-          "version": "6.2.1",
-          "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.2.1.tgz",
-          "integrity": "sha512-088kl3DRT2dLU5riVMKKr1DlImd6X7smDhpXUCkJDCKvTEJeRiXh0G132HG9u5a+6Ylw9plFRY7RuTnwohYSpg==",
+          "version": "6.5.2",
+          "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-6.5.2.tgz",
+          "integrity": "sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==",
           "dev": true,
           "requires": {
-            "ansi-escapes": "^3.0.0",
-            "chalk": "^2.0.0",
+            "ansi-escapes": "^3.2.0",
+            "chalk": "^2.4.2",
             "cli-cursor": "^2.1.0",
             "cli-width": "^2.0.0",
-            "external-editor": "^3.0.0",
+            "external-editor": "^3.0.3",
             "figures": "^2.0.0",
-            "lodash": "^4.17.10",
+            "lodash": "^4.17.12",
             "mute-stream": "0.0.7",
             "run-async": "^2.2.0",
-            "rxjs": "^6.1.0",
+            "rxjs": "^6.4.0",
             "string-width": "^2.1.0",
-            "strip-ansi": "^5.0.0",
+            "strip-ansi": "^5.1.0",
             "through": "^2.3.6"
           },
           "dependencies": {
             "ansi-regex": {
-              "version": "4.0.0",
-              "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.0.0.tgz",
-              "integrity": "sha512-iB5Dda8t/UqpPI/IjsejXu5jOGDrzn41wJyljwPH65VCIbk6+1BzFIMJGFwTNrYXT1CrD+B4l19U7awiQ8rk7w==",
+              "version": "4.1.0",
+              "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+              "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+              "dev": true
+            },
+            "lodash": {
+              "version": "4.17.20",
+              "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
+              "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==",
               "dev": true
             },
             "strip-ansi": {
-              "version": "5.0.0",
-              "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.0.0.tgz",
-              "integrity": "sha512-Uu7gQyZI7J7gn5qLn1Np3G9vcYGTVqB+lFTytnDJv83dd8T22aGH451P3jueT2/QemInJDfxHB5Tde5OzgG1Ow==",
+              "version": "5.2.0",
+              "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+              "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
               "dev": true,
               "requires": {
-                "ansi-regex": "^4.0.0"
+                "ansi-regex": "^4.1.0"
               }
             }
           }
@@ -4923,9 +6537,9 @@
           "dev": true
         },
         "js-yaml": {
-          "version": "3.12.0",
-          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz",
-          "integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==",
+          "version": "3.14.1",
+          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+          "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
           "dev": true,
           "requires": {
             "argparse": "^1.0.7",
@@ -4933,9 +6547,9 @@
           }
         },
         "ms": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.1.tgz",
-          "integrity": "sha512-tgp+dl5cGk28utYktBsrFqA7HKgrhgPsg6Z/EfhWI4gl1Hwq8B/GmY/0oXZ6nF8hDVesS/FpnYaD/kOWhYQvyg==",
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
           "dev": true
         },
         "regexpp": {
@@ -4944,16 +6558,41 @@
           "integrity": "sha512-lv0M6+TkDVniA3aD1Eg0DVpfU/booSu7Eev3TDO/mZKHBfVjgCGTV4t4buppESEYDtkArYFOxTJWv6S5C+iaNw==",
           "dev": true
         },
+        "rimraf": {
+          "version": "2.6.3",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          },
+          "dependencies": {
+            "glob": {
+              "version": "7.1.6",
+              "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+              "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+              "dev": true,
+              "requires": {
+                "fs.realpath": "^1.0.0",
+                "inflight": "^1.0.4",
+                "inherits": "2",
+                "minimatch": "^3.0.4",
+                "once": "^1.3.0",
+                "path-is-absolute": "^1.0.0"
+              }
+            }
+          }
+        },
         "semver": {
-          "version": "5.6.0",
-          "resolved": "https://registry.npmjs.org/semver/-/semver-5.6.0.tgz",
-          "integrity": "sha512-RS9R6R35NYgQn++fkDWaOmqGoj4Ek9gGs+DPxNUZKuwE183xjJroKvyo1IzVFeXvUrvmALy6FWD5xrdJT25gMg==",
+          "version": "5.7.1",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.1.tgz",
+          "integrity": "sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==",
           "dev": true
         },
         "slice-ansi": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.0.0.tgz",
-          "integrity": "sha512-4j2WTWjp3GsZ+AOagyzVbzp4vWGtZ0hEZ/gDY/uTvm6MTxUfTUIsnMIFb1bn8o0RuXiqUw15H1bue8f22Vw2oQ==",
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-2.1.0.tgz",
+          "integrity": "sha512-Qu+VC3EwYLldKa1fCxuuvULvSJOKEgk9pi8dZeCVK7TqBfUNTH4sFkk4joj8afVSfAYgJoSOetjx9QWOJ5mYoQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.0",
@@ -4990,48 +6629,99 @@
           }
         },
         "table": {
-          "version": "5.1.1",
-          "resolved": "https://registry.npmjs.org/table/-/table-5.1.1.tgz",
-          "integrity": "sha512-NUjapYb/qd4PeFW03HnAuOJ7OMcBkJlqeClWxeNlQ0lXGSb52oZXGzkO0/I0ARegQ2eUT1g2VDJH0eUxDRcHmw==",
+          "version": "5.4.6",
+          "resolved": "https://registry.npmjs.org/table/-/table-5.4.6.tgz",
+          "integrity": "sha512-wmEc8m4fjnob4gt5riFRtTu/6+4rSe12TpAELNSqHMfF3IqnA+CH37USM6/YR3qRZv7e56kAEAtd6nKZaxe0Ug==",
           "dev": true,
           "requires": {
-            "ajv": "^6.6.1",
-            "lodash": "^4.17.11",
-            "slice-ansi": "2.0.0",
-            "string-width": "^2.1.1"
+            "ajv": "^6.10.2",
+            "lodash": "^4.17.14",
+            "slice-ansi": "^2.1.0",
+            "string-width": "^3.0.0"
+          },
+          "dependencies": {
+            "ansi-regex": {
+              "version": "4.1.0",
+              "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.0.tgz",
+              "integrity": "sha512-1apePfXM1UOSqw0o9IiFAovVz9M5S1Dg+4TrDwfMewQ6p/rmMueb7tWZjQ1rx4Loy1ArBggoqGpfqqdI4rondg==",
+              "dev": true
+            },
+            "lodash": {
+              "version": "4.17.20",
+              "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
+              "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==",
+              "dev": true
+            },
+            "string-width": {
+              "version": "3.1.0",
+              "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+              "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+              "dev": true,
+              "requires": {
+                "emoji-regex": "^7.0.1",
+                "is-fullwidth-code-point": "^2.0.0",
+                "strip-ansi": "^5.1.0"
+              }
+            },
+            "strip-ansi": {
+              "version": "5.2.0",
+              "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+              "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+              "dev": true,
+              "requires": {
+                "ansi-regex": "^4.1.0"
+              }
+            }
+          }
+        },
+        "write": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/write/-/write-1.0.3.tgz",
+          "integrity": "sha512-/lg70HAjtkUgWPVZhZcm+T4hkL8Zbtp1nFNOn3lRrxnlv50SRBv7cR7RqR+GMsd3hUXy9hWBo4CHTbFTcOYwig==",
+          "dev": true,
+          "requires": {
+            "mkdirp": "^0.5.1"
           }
         }
       }
     },
     "eslint-plugin-babel": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-babel/-/eslint-plugin-babel-5.3.0.tgz",
-      "integrity": "sha512-HPuNzSPE75O+SnxHIafbW5QB45r2w78fxqwK3HmjqIUoPfPzVrq6rD+CINU3yzoDSzEhUkX07VUphbF73Lth/w==",
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-babel/-/eslint-plugin-babel-5.3.1.tgz",
+      "integrity": "sha512-VsQEr6NH3dj664+EyxJwO4FCYm/00JhYb3Sk3ft8o+fpKuIfQ9TaW6uVUfvwMXHcf/lsnRIoyFPsLMyiWCSL/g==",
       "dev": true,
       "requires": {
         "eslint-rule-composer": "^0.3.0"
       }
     },
     "eslint-plugin-react": {
-      "version": "7.11.1",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.11.1.tgz",
-      "integrity": "sha512-cVVyMadRyW7qsIUh3FHp3u6QHNhOgVrLQYdQEB1bPWBsgbNCHdFAeNMquBMCcZJu59eNthX053L70l7gRt4SCw==",
+      "version": "7.24.0",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-react/-/eslint-plugin-react-7.24.0.tgz",
+      "integrity": "sha512-KJJIx2SYx7PBx3ONe/mEeMz4YE0Lcr7feJTCMyyKb/341NcjuAgim3Acgan89GfPv7nxXK2+0slu0CWXYM4x+Q==",
       "dev": true,
       "requires": {
-        "array-includes": "^3.0.3",
+        "array-includes": "^3.1.3",
+        "array.prototype.flatmap": "^1.2.4",
         "doctrine": "^2.1.0",
         "has": "^1.0.3",
-        "jsx-ast-utils": "^2.0.1",
-        "prop-types": "^15.6.2"
+        "jsx-ast-utils": "^2.4.1 || ^3.0.0",
+        "minimatch": "^3.0.4",
+        "object.entries": "^1.1.4",
+        "object.fromentries": "^2.0.4",
+        "object.values": "^1.1.4",
+        "prop-types": "^15.7.2",
+        "resolve": "^2.0.0-next.3",
+        "string.prototype.matchall": "^4.0.5"
       },
       "dependencies": {
-        "has": {
-          "version": "1.0.3",
-          "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
-          "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+        "resolve": {
+          "version": "2.0.0-next.3",
+          "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.3.tgz",
+          "integrity": "sha512-W8LucSynKUIDu9ylraa7ueVZ7hc0uAgJBxVsQSKOXOyle8a93qXhcz+XAXZ8bIq2d6i4Ehddn6Evt+0/UwKk6Q==",
           "dev": true,
           "requires": {
-            "function-bind": "^1.1.1"
+            "is-core-module": "^2.2.0",
+            "path-parse": "^1.0.6"
           }
         }
       }
@@ -5053,10 +6743,21 @@
       }
     },
     "eslint-utils": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.3.1.tgz",
-      "integrity": "sha512-Z7YjnIldX+2XMcjr7ZkgEsOj/bREONV60qYeB/bjMAqqqZ4zxKyWX+BOUkdmRmA9riiIPVvo5x86m5elviOk0Q==",
-      "dev": true
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-utils/-/eslint-utils-1.4.3.tgz",
+      "integrity": "sha512-fbBN5W2xdY45KulGXmLHZ3c3FHfVYmKg0IrAKGOkT/464PQsx2UeIzfz1RmEci+KLm1bBaAzZAh8+/E+XAeZ8Q==",
+      "dev": true,
+      "requires": {
+        "eslint-visitor-keys": "^1.1.0"
+      },
+      "dependencies": {
+        "eslint-visitor-keys": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-1.3.0.tgz",
+          "integrity": "sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==",
+          "dev": true
+        }
+      }
     },
     "eslint-visitor-keys": {
       "version": "1.0.0",
@@ -5065,26 +6766,26 @@
       "dev": true
     },
     "espree": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-5.0.0.tgz",
-      "integrity": "sha512-1MpUfwsdS9MMoN7ZXqAr9e9UKdVHDcvrJpyx7mm1WuQlx/ygErEQBzgi5Nh5qBHIoYweprhtMkTCb9GhcAIcsA==",
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-5.0.1.tgz",
+      "integrity": "sha512-qWAZcWh4XE/RwzLJejfcofscgMc9CamR6Tn1+XRXNzrvUSSbiAjGOI/fggztjIi7y9VLPqnICMIPiGyr8JaZ0A==",
       "dev": true,
       "requires": {
-        "acorn": "^6.0.2",
+        "acorn": "^6.0.7",
         "acorn-jsx": "^5.0.0",
         "eslint-visitor-keys": "^1.0.0"
       },
       "dependencies": {
         "acorn": {
-          "version": "6.0.4",
-          "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.0.4.tgz",
-          "integrity": "sha512-VY4i5EKSKkofY2I+6QLTbTTN/UvEQPCo6eiwzzSaSWfpaDhOmStMCMod6wmuPciNq+XS0faCglFu2lHZpdHUtg==",
+          "version": "6.4.2",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-6.4.2.tgz",
+          "integrity": "sha512-XtGIhXwF8YM8bJhGxG5kXgjkEuNGLTkoYqVE+KMR+aspr4KGYmKYg7yUe3KghyQ9yheNwLnjmzh/7+gfDBmHCQ==",
           "dev": true
         },
         "acorn-jsx": {
-          "version": "5.0.1",
-          "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.0.1.tgz",
-          "integrity": "sha512-HJ7CfNHrfJLlNTzIEUTj43LNWGkqpRLxm3YjAlcD0ACydk9XynzYsCBHxut+iqt+1aBXkx9UP/w/ZqMr13XIzg==",
+          "version": "5.3.1",
+          "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.1.tgz",
+          "integrity": "sha512-K0Ptm/47OKfQRpNQ2J/oIN/3QYiK6FwW+eJbILhsdxh2WTLdl+30o8aGdTbm5JbffpFFAg/g+zi1E+jvJha5ng==",
           "dev": true
         }
       }
@@ -5135,9 +6836,9 @@
       "dev": true
     },
     "events": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/events/-/events-2.1.0.tgz",
-      "integrity": "sha512-3Zmiobend8P9DjmKAty0Era4jV8oJ0yGYe2nJJAxgymF9+N8F2m0hhZiMoWtcfepExzNKZumFU3ksdQbInGWCg==",
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
       "dev": true
     },
     "evp_bytestokey": {
@@ -5151,12 +6852,38 @@
       }
     },
     "expand-brackets": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
-      "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-2.1.4.tgz",
+      "integrity": "sha1-t3c14xXOMPa27/D4OwQVGiJEliI=",
       "dev": true,
       "requires": {
-        "is-posix-bracket": "^0.1.0"
+        "debug": "^2.3.3",
+        "define-property": "^0.2.5",
+        "extend-shallow": "^2.0.1",
+        "posix-character-classes": "^0.1.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
+      },
+      "dependencies": {
+        "define-property": {
+          "version": "0.2.5",
+          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+          "dev": true,
+          "requires": {
+            "is-descriptor": "^0.1.0"
+          }
+        },
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        }
       }
     },
     "expand-range": {
@@ -5166,26 +6893,71 @@
       "dev": true,
       "requires": {
         "fill-range": "^2.1.0"
+      },
+      "dependencies": {
+        "fill-range": {
+          "version": "2.2.4",
+          "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz",
+          "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==",
+          "dev": true,
+          "requires": {
+            "is-number": "^2.1.0",
+            "isobject": "^2.0.0",
+            "randomatic": "^3.0.0",
+            "repeat-element": "^1.1.2",
+            "repeat-string": "^1.5.2"
+          }
+        },
+        "is-number": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz",
+          "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
+          "dev": true,
+          "requires": {
+            "kind-of": "^3.0.2"
+          }
+        },
+        "isobject": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
+          "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
+          "dev": true,
+          "requires": {
+            "isarray": "1.0.0"
+          }
+        }
       }
     },
     "extend": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz",
-      "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
       "dev": true
     },
     "extend-shallow": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
-      "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
+      "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
       "dev": true,
       "requires": {
-        "is-extendable": "^0.1.0"
+        "assign-symbols": "^1.0.0",
+        "is-extendable": "^1.0.1"
+      },
+      "dependencies": {
+        "is-extendable": {
+          "version": "1.0.1",
+          "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
+          "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
+          "dev": true,
+          "requires": {
+            "is-plain-object": "^2.0.4"
+          }
+        }
       }
     },
     "external-editor": {
       "version": "2.2.0",
-      "resolved": "http://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-2.2.0.tgz",
       "integrity": "sha512-bSn6gvGxKt+b7+6TKEv1ZycHleA7aHhRHyAqJyp5pbUFuYYNIzpZnQDk7AsYckyWdEnTeAnay0aCy2aV6iTk9A==",
       "dev": true,
       "requires": {
@@ -5195,12 +6967,74 @@
       }
     },
     "extglob": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
-      "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/extglob/-/extglob-2.0.4.tgz",
+      "integrity": "sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==",
       "dev": true,
       "requires": {
-        "is-extglob": "^1.0.0"
+        "array-unique": "^0.3.2",
+        "define-property": "^1.0.0",
+        "expand-brackets": "^2.1.4",
+        "extend-shallow": "^2.0.1",
+        "fragment-cache": "^0.2.1",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
+      },
+      "dependencies": {
+        "define-property": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+          "dev": true,
+          "requires": {
+            "is-descriptor": "^1.0.0"
+          }
+        },
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        },
+        "is-accessor-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-data-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-descriptor": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+          "dev": true,
+          "requires": {
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
+          }
+        },
+        "kind-of": {
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+          "dev": true
+        }
       }
     },
     "extsprintf": {
@@ -5210,28 +7044,34 @@
       "dev": true
     },
     "falafel": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.1.0.tgz",
-      "integrity": "sha1-lrsXdh2rqU9G0AFzizzt86Z/4Gw=",
+      "version": "2.2.4",
+      "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.2.4.tgz",
+      "integrity": "sha512-0HXjo8XASWRmsS0X1EkhwEMZaD3Qvp7FfURwjLKjG1ghfRm/MGZl2r4cWUTv41KdNghTw4OUMmVtdGQp3+H+uQ==",
       "dev": true,
       "requires": {
-        "acorn": "^5.0.0",
+        "acorn": "^7.1.1",
         "foreach": "^2.0.5",
-        "isarray": "0.0.1",
+        "isarray": "^2.0.1",
         "object-keys": "^1.0.6"
       },
       "dependencies": {
+        "acorn": {
+          "version": "7.4.1",
+          "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.1.tgz",
+          "integrity": "sha512-nQyp0o1/mNdbTO1PO6kHkwSrmgZ0MT/jCCpNiwbUjGoRN4dlBhqJtoQuCnEOKzgTVwg0ZWiCoQy6SxMebQVh8A==",
+          "dev": true
+        },
         "isarray": {
-          "version": "0.0.1",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz",
-          "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
+          "version": "2.0.5",
+          "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.5.tgz",
+          "integrity": "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==",
           "dev": true
         }
       }
     },
     "fast-deep-equal": {
       "version": "1.1.0",
-      "resolved": "http://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz",
       "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=",
       "dev": true
     },
@@ -5247,6 +7087,12 @@
       "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=",
       "dev": true
     },
+    "fast-safe-stringify": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/fast-safe-stringify/-/fast-safe-stringify-2.0.7.tgz",
+      "integrity": "sha512-Utm6CdzT+6xsDk2m8S6uL8VHxNwI6Jub+e9NYTcAms28T84pTa25GJQV9j0CY0N1rM8hK4x6grpF2BQf+2qwVA==",
+      "dev": true
+    },
     "faucet": {
       "version": "0.0.1",
       "resolved": "https://registry.npmjs.org/faucet/-/faucet-0.0.1.tgz",
@@ -5365,7 +7211,7 @@
       "dependencies": {
         "core-js": {
           "version": "1.2.7",
-          "resolved": "http://registry.npmjs.org/core-js/-/core-js-1.2.7.tgz",
+          "resolved": "https://registry.npmjs.org/core-js/-/core-js-1.2.7.tgz",
           "integrity": "sha1-ZSKUwUZR2yj6k70tX/KYOk8IxjY=",
           "dev": true
         }
@@ -5391,6 +7237,13 @@
         "object-assign": "^4.0.1"
       }
     },
+    "file-uri-to-path": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/file-uri-to-path/-/file-uri-to-path-1.0.0.tgz",
+      "integrity": "sha512-0Zt+s3L7Vf1biwWZ29aARiVYLx7iMGnEUl9x33fbB/j3jR81u/O2LbqK+Bm1CDSNDKVtJ/YjwY7TUd5SkeLQLw==",
+      "dev": true,
+      "optional": true
+    },
     "filename-regex": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz",
@@ -5398,26 +7251,53 @@
       "dev": true
     },
     "fill-range": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.4.tgz",
-      "integrity": "sha512-cnrcCbj01+j2gTG921VZPnHbjmdAf8oQV/iGeV2kZxGSyfYjjTyY79ErsK1WJWMpw6DaApEX72binqJE+/d+5Q==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-4.0.0.tgz",
+      "integrity": "sha1-1USBHUKPmOsGpj3EAtJAPDKMOPc=",
       "dev": true,
       "requires": {
-        "is-number": "^2.1.0",
-        "isobject": "^2.0.0",
-        "randomatic": "^3.0.0",
-        "repeat-element": "^1.1.2",
-        "repeat-string": "^1.5.2"
+        "extend-shallow": "^2.0.1",
+        "is-number": "^3.0.0",
+        "repeat-string": "^1.6.1",
+        "to-regex-range": "^2.1.0"
+      },
+      "dependencies": {
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        },
+        "to-regex-range": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-2.1.1.tgz",
+          "integrity": "sha1-fIDBe53+vlmeJzZ+DU3VWQFB2zg=",
+          "dev": true,
+          "requires": {
+            "is-number": "^3.0.0",
+            "repeat-string": "^1.6.1"
+          }
+        }
       }
     },
     "find-replace": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-2.0.1.tgz",
-      "integrity": "sha512-LzDo3Fpa30FLIBsh6DCDnMN1KW2g4QKkqKmejlImgWY67dDFPX/x9Kh/op/GK522DchQXEvDi/wD48HKW49XOQ==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-replace/-/find-replace-3.0.0.tgz",
+      "integrity": "sha512-6Tb2myMioCAgv5kfvP5/PkZZ/ntTpVK39fHY7WkWBgvbeE+VHd/tZuZ4mrC+bxh4cfOZeYKVPaJIZtZXV7GNCQ==",
       "dev": true,
       "requires": {
-        "array-back": "^2.0.0",
-        "test-value": "^3.0.0"
+        "array-back": "^3.0.1"
+      },
+      "dependencies": {
+        "array-back": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/array-back/-/array-back-3.1.0.tgz",
+          "integrity": "sha512-TkuxA4UCOvxuDK6NZYXCalszEzj+TLszyASooky+i742l9TqsOdYCMJJupxRic61hwquNtppB3hgcuq9SVSH1Q==",
+          "dev": true
+        }
       }
     },
     "find-up": {
@@ -5436,30 +7316,61 @@
       "dev": true
     },
     "flat-cache": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.0.tgz",
-      "integrity": "sha1-0wMLMrOBVPTjt+nHCfSQ9++XxIE=",
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-1.3.4.tgz",
+      "integrity": "sha512-VwyB3Lkgacfik2vhqR4uv2rvebqmDvFu4jlN/C1RzWoJEo8I7z4Q404oiqYCkq41mni8EzQnm95emU9seckwtg==",
       "dev": true,
       "requires": {
         "circular-json": "^0.3.1",
-        "del": "^2.0.2",
         "graceful-fs": "^4.1.2",
+        "rimraf": "~2.6.2",
         "write": "^0.2.1"
+      },
+      "dependencies": {
+        "glob": {
+          "version": "7.1.7",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.7.tgz",
+          "integrity": "sha512-OvD9ENzPLbegENnYP5UUfJIirTg4+XwMWGaQfQTY0JenxNvvIKP3U3/tAQSPIu/lHxXYSZmpXlUHeqAIdKzBLQ==",
+          "dev": true,
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        },
+        "rimraf": {
+          "version": "2.6.3",
+          "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+          "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+          "dev": true,
+          "requires": {
+            "glob": "^7.1.3"
+          }
+        }
       }
     },
+    "flatted": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-2.0.2.tgz",
+      "integrity": "sha512-r5wGx7YeOwNWNlCA0wQ86zKyDLMQr+/RB8xy74M4hTphfmjlijTSSXGuH8rnvKZnfT9i+75zmd8jcKdMR4O6jA==",
+      "dev": true
+    },
     "flatten": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/flatten/-/flatten-1.0.2.tgz",
-      "integrity": "sha1-2uRqnXj74lKSJYzB54CkHZXAN4I=",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/flatten/-/flatten-1.0.3.tgz",
+      "integrity": "sha512-dVsPA/UwQ8+2uoFe5GHtiBMu48dWLTdsuEd7CKGlZlD78r1TTWBvDuFaFGKCo/ZfEr95Uk56vZoX86OsHkUeIg==",
       "dev": true
     },
     "for-each": {
-      "version": "0.3.2",
-      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.2.tgz",
-      "integrity": "sha1-LEBFC5NI6X8oEyJZO6lnBLmr1NQ=",
+      "version": "0.3.3",
+      "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz",
+      "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==",
       "dev": true,
       "requires": {
-        "is-function": "~1.0.0"
+        "is-callable": "^1.1.3"
       }
     },
     "for-in": {
@@ -5500,12 +7411,13 @@
         "mime-types": "^2.1.12"
       }
     },
-    "fs-minipass": {
-      "version": "1.2.5",
-      "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-1.2.5.tgz",
-      "integrity": "sha512-JhBl0skXjUPCFH7x6x61gQxrKyXsxB5gcgePLZCwfyCGGsTISMoIeObbrvVeP6Xmyaudw4TT43qV2Gz+iyd2oQ==",
+    "fragment-cache": {
+      "version": "0.2.1",
+      "resolved": "https://registry.npmjs.org/fragment-cache/-/fragment-cache-0.2.1.tgz",
+      "integrity": "sha1-QpD60n8T6Jvn8zeZxrxaCr//DRk=",
+      "dev": true,
       "requires": {
-        "minipass": "^2.2.1"
+        "map-cache": "^0.2.2"
       }
     },
     "fs-readdir-recursive": {
@@ -5520,79 +7432,16 @@
       "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8="
     },
     "fsevents": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.1.2.tgz",
-      "integrity": "sha512-Sn44E5wQW4bTHXvQmvSHwqbuiXtduD6Rrjm2ZtUEGbyrig+nUH3t/QD4M4/ZXViY556TBpRgZkHLDx3JxPwxiw==",
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+      "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
       "dev": true,
-      "optional": true,
-      "requires": {
-        "nan": "^2.3.0",
-        "node-pre-gyp": "^0.6.36"
-      },
-      "dependencies": {
-        "node-pre-gyp": {
-          "version": "0.6.37",
-          "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.6.37.tgz",
-          "integrity": "sha1-PIcrI2suJm5BQFeP4e6I9pMyOgU=",
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "mkdirp": "^0.5.1",
-            "nopt": "^4.0.1",
-            "npmlog": "^4.0.2",
-            "rc": "^1.1.7",
-            "request": "^2.81.0",
-            "rimraf": "^2.6.1",
-            "semver": "^5.3.0",
-            "tape": "^4.6.3",
-            "tar": "^2.2.1",
-            "tar-pack": "^3.4.0"
-          }
-        },
-        "tar": {
-          "version": "2.2.1",
-          "resolved": false,
-          "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=",
-          "dev": true,
-          "optional": true,
-          "requires": {
-            "block-stream": "*",
-            "fstream": "^1.0.2",
-            "inherits": "2"
-          }
-        }
-      }
-    },
-    "fstream": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/fstream/-/fstream-1.0.11.tgz",
-      "integrity": "sha1-XB+x8RdHcRTwYyoOtLcbPLD9MXE=",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "graceful-fs": "^4.1.2",
-        "inherits": "~2.0.0",
-        "mkdirp": ">=0.5 0",
-        "rimraf": "2"
-      }
-    },
-    "fstream-ignore": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/fstream-ignore/-/fstream-ignore-1.0.5.tgz",
-      "integrity": "sha1-nDHa40dnAY/h0kmyTa2mfQktoQU=",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "fstream": "^1.0.0",
-        "inherits": "2",
-        "minimatch": "^3.0.0"
-      }
+      "optional": true
     },
     "function-bind": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz",
-      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==",
-      "dev": true
+      "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A=="
     },
     "functional-red-black-tree": {
       "version": "1.0.1",
@@ -5615,6 +7464,12 @@
         "wide-align": "^1.1.0"
       }
     },
+    "gensync": {
+      "version": "1.0.0-beta.2",
+      "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+      "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+      "dev": true
+    },
     "geojson-area": {
       "version": "0.2.1",
       "resolved": "https://registry.npmjs.org/geojson-area/-/geojson-area-0.2.1.tgz",
@@ -5653,6 +7508,26 @@
       "integrity": "sha1-GWdZEBu7xPrPEwYMqu3Uhw3uVb4=",
       "dev": true
     },
+    "get-intrinsic": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.0.tgz",
+      "integrity": "sha512-M11rgtQp5GZMZzDL7jLTNxbDfurpzuau5uqRWDPvlHjfvg3TdScAZo96GLvhMjImrmR8uAt0FS2RLoMrfWGKlg==",
+      "requires": {
+        "function-bind": "^1.1.1",
+        "has": "^1.0.3",
+        "has-symbols": "^1.0.1"
+      },
+      "dependencies": {
+        "has": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+          "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+          "requires": {
+            "function-bind": "^1.1.1"
+          }
+        }
+      }
+    },
     "get-port": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/get-port/-/get-port-3.2.0.tgz",
@@ -5681,13 +7556,13 @@
       "dev": true
     },
     "git-up": {
-      "version": "2.0.9",
-      "resolved": "https://registry.npmjs.org/git-up/-/git-up-2.0.9.tgz",
-      "integrity": "sha1-IZv9J8gtrurYSVvrOG3Bjq5jY20=",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/git-up/-/git-up-2.1.0.tgz",
+      "integrity": "sha512-MJgwfcSd9qxgDyEYpRU/CDxNpUadrK80JHuEQDG4Urn0m7tpSOgCBrtiSIa9S9KH8Tbuo/TN8SSQmJBvsw1HkA==",
       "dev": true,
       "requires": {
         "is-ssh": "^1.3.0",
-        "parse-url": "^1.3.0"
+        "parse-url": "^3.0.2"
       }
     },
     "git-url-parse": {
@@ -5700,9 +7575,9 @@
       }
     },
     "github-slugger": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.2.0.tgz",
-      "integrity": "sha512-wIaa75k1vZhyPm9yWrD08A5Xnx/V+RmzGrpjQuLemGKSb77Qukiaei58Bogrl/LZSADDfPzKJX8jhLs4CRTl7Q==",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/github-slugger/-/github-slugger-1.1.3.tgz",
+      "integrity": "sha1-MUpudZoYwrDMV2DVEsy6tUnFSac=",
       "dev": true,
       "requires": {
         "emoji-regex": ">=6.0.0 <=6.1.1"
@@ -5712,6 +7587,7 @@
       "version": "7.1.2",
       "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz",
       "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==",
+      "dev": true,
       "requires": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
@@ -5729,15 +7605,42 @@
       "requires": {
         "glob-parent": "^2.0.0",
         "is-glob": "^2.0.0"
+      },
+      "dependencies": {
+        "glob-parent": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
+          "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
+          "dev": true,
+          "requires": {
+            "is-glob": "^2.0.0"
+          }
+        },
+        "is-extglob": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+          "dev": true
+        },
+        "is-glob": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+          "dev": true,
+          "requires": {
+            "is-extglob": "^1.0.0"
+          }
+        }
       }
     },
     "glob-parent": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz",
-      "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=",
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
+      "integrity": "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==",
       "dev": true,
+      "optional": true,
       "requires": {
-        "is-glob": "^2.0.0"
+        "is-glob": "^4.0.1"
       }
     },
     "glob-stream": {
@@ -5756,6 +7659,58 @@
         "unique-stream": "^2.0.2"
       },
       "dependencies": {
+        "arr-diff": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz",
+          "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=",
+          "dev": true,
+          "requires": {
+            "arr-flatten": "^1.0.1"
+          }
+        },
+        "array-unique": {
+          "version": "0.2.1",
+          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz",
+          "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=",
+          "dev": true
+        },
+        "braces": {
+          "version": "1.8.5",
+          "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz",
+          "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=",
+          "dev": true,
+          "requires": {
+            "expand-range": "^1.8.1",
+            "preserve": "^0.2.0",
+            "repeat-element": "^1.1.2"
+          }
+        },
+        "expand-brackets": {
+          "version": "0.1.5",
+          "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz",
+          "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=",
+          "dev": true,
+          "requires": {
+            "is-posix-bracket": "^0.1.0"
+          }
+        },
+        "extglob": {
+          "version": "0.3.2",
+          "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz",
+          "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=",
+          "dev": true,
+          "requires": {
+            "is-extglob": "^1.0.0"
+          },
+          "dependencies": {
+            "is-extglob": {
+              "version": "1.0.0",
+              "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+              "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+              "dev": true
+            }
+          }
+        },
         "glob": {
           "version": "5.0.15",
           "resolved": "https://registry.npmjs.org/glob/-/glob-5.0.15.tgz",
@@ -5779,12 +7734,6 @@
             "path-dirname": "^1.0.0"
           }
         },
-        "is-extglob": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
-          "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
-          "dev": true
-        },
         "is-glob": {
           "version": "3.1.0",
           "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-3.1.0.tgz",
@@ -5800,6 +7749,44 @@
           "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=",
           "dev": true
         },
+        "micromatch": {
+          "version": "2.3.11",
+          "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
+          "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
+          "dev": true,
+          "requires": {
+            "arr-diff": "^2.0.0",
+            "array-unique": "^0.2.1",
+            "braces": "^1.8.2",
+            "expand-brackets": "^0.1.4",
+            "extglob": "^0.3.1",
+            "filename-regex": "^2.0.0",
+            "is-extglob": "^1.0.0",
+            "is-glob": "^2.0.1",
+            "kind-of": "^3.0.2",
+            "normalize-path": "^2.0.1",
+            "object.omit": "^2.0.0",
+            "parse-glob": "^3.0.4",
+            "regex-cache": "^0.4.2"
+          },
+          "dependencies": {
+            "is-extglob": {
+              "version": "1.0.0",
+              "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+              "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+              "dev": true
+            },
+            "is-glob": {
+              "version": "2.0.1",
+              "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+              "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+              "dev": true,
+              "requires": {
+                "is-extglob": "^1.0.0"
+              }
+            }
+          }
+        },
         "readable-stream": {
           "version": "1.0.34",
           "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz",
@@ -5837,25 +7824,11 @@
       "dev": true
     },
     "globals-docs": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/globals-docs/-/globals-docs-2.3.0.tgz",
-      "integrity": "sha1-3KQIivGW94APTrp4Pq7/M1y2dZw=",
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/globals-docs/-/globals-docs-2.4.1.tgz",
+      "integrity": "sha512-qpPnUKkWnz8NESjrCvnlGklsgiQzlq+rcCxoG5uNQ+dNA7cFMCmn231slLAwS2N/PlkzZ3COL8CcS10jXmLHqg==",
       "dev": true
     },
-    "globby": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/globby/-/globby-5.0.0.tgz",
-      "integrity": "sha1-69hGZ8oNuzMLmbz8aOrCvFQ3Dg0=",
-      "dev": true,
-      "requires": {
-        "array-union": "^1.0.1",
-        "arrify": "^1.0.0",
-        "glob": "^7.0.3",
-        "object-assign": "^4.0.1",
-        "pify": "^2.0.0",
-        "pinkie-promise": "^2.0.0"
-      }
-    },
     "graceful-fs": {
       "version": "4.1.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz",
@@ -5874,6 +7847,12 @@
         "vinyl": "^1.0.0"
       },
       "dependencies": {
+        "clone": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
+          "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=",
+          "dev": true
+        },
         "clone-stats": {
           "version": "0.0.1",
           "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-0.0.1.tgz",
@@ -5906,48 +7885,22 @@
       "dev": true
     },
     "har-validator": {
-      "version": "5.1.3",
-      "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.3.tgz",
-      "integrity": "sha512-sNvOCzEQNr/qrvJgc3UG/kD4QtlHycrzwS+6mfTrrSq97BvaYcPZZI1ZSqGSPR73Cxn4LKTD4PttRwfU7jWq5g==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.1.5.tgz",
+      "integrity": "sha512-nmT2T0lljbxdQZfspsno9hgrG3Uir6Ks5afism62poxqBM6sDnMEuPmzTq8XN0OEwqKLLdh1jQI3qyE66Nzb3w==",
       "dev": true,
       "requires": {
-        "ajv": "^6.5.5",
+        "ajv": "^6.12.3",
         "har-schema": "^2.0.0"
-      },
-      "dependencies": {
-        "ajv": {
-          "version": "6.6.1",
-          "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.6.1.tgz",
-          "integrity": "sha512-ZoJjft5B+EJBjUyu9C9Hc0OZyPZSSlOF+plzouTrg6UlA8f+e/n8NIgBFG/9tppJtpPWfthHakK7juJdNDODww==",
-          "dev": true,
-          "requires": {
-            "fast-deep-equal": "^2.0.1",
-            "fast-json-stable-stringify": "^2.0.0",
-            "json-schema-traverse": "^0.4.1",
-            "uri-js": "^4.2.2"
-          }
-        },
-        "fast-deep-equal": {
-          "version": "2.0.1",
-          "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-2.0.1.tgz",
-          "integrity": "sha1-ewUhjd+WZ79/Nwv3/bLLFf3Qqkk=",
-          "dev": true
-        },
-        "json-schema-traverse": {
-          "version": "0.4.1",
-          "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-          "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
-          "dev": true
-        }
       }
     },
     "has": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/has/-/has-1.0.1.tgz",
-      "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+      "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
       "dev": true,
       "requires": {
-        "function-bind": "^1.0.2"
+        "function-bind": "^1.1.1"
       }
     },
     "has-ansi": {
@@ -5959,12 +7912,23 @@
         "ansi-regex": "^2.0.0"
       }
     },
-    "has-flag": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz",
-      "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=",
+    "has-bigints": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-bigints/-/has-bigints-1.0.1.tgz",
+      "integrity": "sha512-LSBS2LjbNBTf6287JEbEzvJgftkF5qFkmCo9hDRpAzKhUOlJ+hx8dd4USs00SgsUNwc4617J9ki5YtEClM2ffA==",
       "dev": true
     },
+    "has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
+      "dev": true
+    },
+    "has-symbols": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.1.tgz",
+      "integrity": "sha512-PLcsoqu++dmEIZB+6totNFKq/7Do+Z0u4oT0zKOJNl3lYK6vGwwu2hjHs+68OEZbTjiUE9bgOABXbP/GvrS0Kg=="
+    },
     "has-unicode": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/has-unicode/-/has-unicode-2.0.1.tgz",
@@ -6031,13 +7995,48 @@
       }
     },
     "hash-base": {
-      "version": "3.0.4",
-      "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz",
-      "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.1.0.tgz",
+      "integrity": "sha512-1nmYp/rhMDiE7AYkDw+lLwlAzz0AntGIe51F3RfFfEqyQ3feY2eI/NcwC6umIQVOASPMsWJLJScWKSSvzL9IVA==",
       "dev": true,
       "requires": {
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.6.0",
+        "safe-buffer": "^5.2.0"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+          "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+          "dev": true,
+          "requires": {
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
+        "string_decoder": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.2.0"
+          }
+        }
       }
     },
     "hash.js": {
@@ -6051,15 +8050,15 @@
       }
     },
     "hast-util-is-element": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-1.0.0.tgz",
-      "integrity": "sha1-P3IWl4sq4U2YdJh4eCZ18zvjzgA=",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/hast-util-is-element/-/hast-util-is-element-1.1.0.tgz",
+      "integrity": "sha512-oUmNua0bFbdrD/ELDSSEadRVtWZOf3iF6Lbv81naqsIV99RnSCieTbWuWCY8BAeEfKJTKl0gRdokv+dELutHGQ==",
       "dev": true
     },
     "hast-util-sanitize": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-1.1.2.tgz",
-      "integrity": "sha1-0QvWdXoh5ZwTq8iuNTDdO219Z54=",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/hast-util-sanitize/-/hast-util-sanitize-1.3.1.tgz",
+      "integrity": "sha512-AIeKHuHx0Wk45nSkGVa2/ujQYTksnDl8gmmKo/mwQi7ag7IBZ8cM3nJ2G86SajbjGP/HRpud6kMkPtcM2i0Tlw==",
       "dev": true,
       "requires": {
         "xtend": "^4.0.1"
@@ -6082,18 +8081,26 @@
         "stringify-entities": "^1.0.1",
         "unist-util-is": "^2.0.0",
         "xtend": "^4.0.1"
+      },
+      "dependencies": {
+        "unist-util-is": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-2.1.3.tgz",
+          "integrity": "sha512-4WbQX2iwfr/+PfM4U3zd2VNXY+dWtZsN1fLnWEi2QQXA4qyDYAZcDMfXUX0Cu6XZUHHAO9q4nyxxLT4Awk1qUA==",
+          "dev": true
+        }
       }
     },
     "hast-util-whitespace": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-1.0.0.tgz",
-      "integrity": "sha1-vQlpGWJdKTbh/xe8Tff9cn8X7Ok=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-1.0.4.tgz",
+      "integrity": "sha512-I5GTdSfhYfAPNztx2xJRQpG8cuDSNt599/7YUn7Gx/WxNMsG+a835k97TDkFgk123cwjfwINaZknkKkphx/f2A==",
       "dev": true
     },
     "highlight.js": {
-      "version": "9.12.0",
-      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-9.12.0.tgz",
-      "integrity": "sha1-5tnb5Xy+/mB1HwKvM2GVhwyQwB4=",
+      "version": "9.18.5",
+      "resolved": "https://registry.npmjs.org/highlight.js/-/highlight.js-9.18.5.tgz",
+      "integrity": "sha512-a5bFyofd/BHCX52/8i8uJkjr9DYwXIPnM/plwI6W7ezItLGqzt7X2G2nXuYSfsIJdkwwj/g9DG1LkcGJI/dDoA==",
       "dev": true
     },
     "hmac-drbg": {
@@ -6129,23 +8136,48 @@
       "dev": true
     },
     "html-void-elements": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-1.0.2.tgz",
-      "integrity": "sha1-nSLgyjKsyVs/RbjVtPb73AWv/VU=",
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-1.0.5.tgz",
+      "integrity": "sha512-uE/TxKuyNIcx44cIWnjr/rfIATDH7ZaOMmstu0CwhFG1Dunhlp4OC6/NMbhiwoq5BpW0ubi303qnEk/PZj614w==",
       "dev": true
     },
     "htmlescape": {
       "version": "1.1.1",
-      "resolved": "http://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz",
+      "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz",
       "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=",
       "dev": true
     },
     "http-parser-js": {
-      "version": "0.4.9",
-      "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.4.9.tgz",
-      "integrity": "sha1-6hoE+2St/wJC6ZdPKX3Uw8rSceE=",
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/http-parser-js/-/http-parser-js-0.5.3.tgz",
+      "integrity": "sha512-t7hjvef/5HEK7RWTdUzVUhl8zkEu+LlaE0IYzdMuvbSDipxBRpOn4Uhw8ZyECEa808iVT8XCjzo6xmYt4CiLZg==",
       "dev": true
     },
+    "http-proxy-agent": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-4.0.1.tgz",
+      "integrity": "sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==",
+      "requires": {
+        "@tootallnate/once": "1",
+        "agent-base": "6",
+        "debug": "4"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "4.3.1",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.1.tgz",
+          "integrity": "sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==",
+          "requires": {
+            "ms": "2.1.2"
+          }
+        },
+        "ms": {
+          "version": "2.1.2",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz",
+          "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
+        }
+      }
+    },
     "http-signature": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz",
@@ -6167,28 +8199,39 @@
       "version": "0.4.24",
       "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
       "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "dev": true,
       "requires": {
         "safer-buffer": ">= 2.1.2 < 3"
       }
     },
     "ieee754": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.12.tgz",
-      "integrity": "sha512-GguP+DRY+pJ3soyIiGPTvdiVXjZ+DbXOxGpXn3eMvNW4x4irjqXm4wHKscC+TfxSJ0yw/S1F24tqdMNsMZTiLA==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+      "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
       "dev": true
     },
     "ignore": {
-      "version": "3.3.5",
-      "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.5.tgz",
-      "integrity": "sha512-JLH93mL8amZQhh/p6mfQgVBH3M6epNq3DfsXsTSuSrInVjwyYlFE1nv2AgfRCC8PoOhM0jwQ5v8s9LgbK7yGDw==",
+      "version": "3.3.10",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-3.3.10.tgz",
+      "integrity": "sha512-Pgs951kaMm5GXP7MOvxERINe3gsaVjUWFm+UZPSq9xYriQAksyhg0csnS0KXSNRD5NmNdapXEpjxG49+AKh/ug==",
       "dev": true
     },
-    "ignore-walk": {
-      "version": "3.0.1",
-      "resolved": "https://registry.npmjs.org/ignore-walk/-/ignore-walk-3.0.1.tgz",
-      "integrity": "sha512-DTVlMx3IYPe0/JJcYP7Gxg7ttZZu3IInhuEhbchuqneY9wWe5Ojy2mXLBaQFUQmo0AW2r3qG7m1mg86js+gnlQ==",
+    "import-fresh": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
+      "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
+      "dev": true,
       "requires": {
-        "minimatch": "^3.0.4"
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "dependencies": {
+        "resolve-from": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+          "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+          "dev": true
+        }
       }
     },
     "imurmurhash": {
@@ -6228,9 +8271,10 @@
       "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4="
     },
     "ini": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.4.tgz",
-      "integrity": "sha1-BTfLedr1m1mhpRff9wbIbsA5Fi4="
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "dev": true
     },
     "inline-source-map": {
       "version": "0.6.2",
@@ -6279,9 +8323,9 @@
           }
         },
         "chalk": {
-          "version": "2.4.1",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-          "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.1",
@@ -6298,12 +8342,6 @@
             "escape-string-regexp": "^1.0.5"
           }
         },
-        "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-          "dev": true
-        },
         "is-fullwidth-code-point": {
           "version": "2.0.0",
           "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
@@ -6341,9 +8379,9 @@
       }
     },
     "insert-module-globals": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.0.tgz",
-      "integrity": "sha512-VE6NlW+WGn2/AeOMd496AHFYmE7eLKkUY6Ty31k4og5vmA3Fjuwe9v6ifH6Xx/Hz27QvdoMoviw1/pqWRB09Sw==",
+      "version": "7.2.1",
+      "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.2.1.tgz",
+      "integrity": "sha512-ufS5Qq9RZN+Bu899eA9QCAYThY+gGW7oRkmb0vC93Vlyu/CFGcH0OYPEjVkDXA5FEbTt1+VWzdoOD3Ny9N+8tg==",
       "dev": true,
       "requires": {
         "JSONStream": "^1.0.3",
@@ -6356,26 +8394,23 @@
         "through2": "^2.0.0",
         "undeclared-identifiers": "^1.1.2",
         "xtend": "^4.0.0"
-      },
-      "dependencies": {
-        "concat-stream": {
-          "version": "1.6.2",
-          "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz",
-          "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==",
-          "dev": true,
-          "requires": {
-            "buffer-from": "^1.0.0",
-            "inherits": "^2.0.3",
-            "readable-stream": "^2.2.2",
-            "typedarray": "^0.0.6"
-          }
-        }
+      }
+    },
+    "internal-slot": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/internal-slot/-/internal-slot-1.0.3.tgz",
+      "integrity": "sha512-O0DB1JC/sPyZl7cIo78n5dR7eUSwwpYPiXRhTzNxZVAMUuB8vlnRFyLxdrVToks6XPLVnFfbzaVd5WLjhgg+vA==",
+      "dev": true,
+      "requires": {
+        "get-intrinsic": "^1.1.0",
+        "has": "^1.0.3",
+        "side-channel": "^1.0.4"
       }
     },
     "interpret": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.0.4.tgz",
-      "integrity": "sha1-ggzdWIuGj/sZGoCVBtbJyPISsbA=",
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.4.0.tgz",
+      "integrity": "sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==",
       "dev": true
     },
     "invariant": {
@@ -6393,13 +8428,13 @@
       "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY="
     },
     "is-absolute": {
-      "version": "0.2.6",
-      "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-0.2.6.tgz",
-      "integrity": "sha1-IN5p89uULvLYe5wto28XIjWxtes=",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-absolute/-/is-absolute-1.0.0.tgz",
+      "integrity": "sha512-dOWoqflvcydARa360Gvv18DZ/gRuHKi2NU/wU5X1ZFzdYfH29nkiNZsF3mp4OJ3H4yo9Mx8A/uAGNzpzPN3yBA==",
       "dev": true,
       "requires": {
-        "is-relative": "^0.2.1",
-        "is-windows": "^0.2.0"
+        "is-relative": "^1.0.0",
+        "is-windows": "^1.0.1"
       }
     },
     "is-absolute-url": {
@@ -6418,9 +8453,9 @@
       }
     },
     "is-alphabetical": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.1.tgz",
-      "integrity": "sha1-x3B5zJHU76x3W+EDS/LSQ/lebwg=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-1.0.4.tgz",
+      "integrity": "sha512-DwzsA04LQ10FHTZuL0/grVDk4rFoVH1pjAToYwBrHSxcrBIGQuXrQMtD5U1b0U2XVgKZCTLLP8u2Qxqhy3l2Vg==",
       "dev": true
     },
     "is-alphanumeric": {
@@ -6430,20 +8465,35 @@
       "dev": true
     },
     "is-alphanumerical": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.1.tgz",
-      "integrity": "sha1-37SqTRCF4zvbYcLe6cgOnGwZ9Ts=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-1.0.4.tgz",
+      "integrity": "sha512-UzoZUr+XfVz3t3v4KyGEniVL9BDRoQtY7tOyrRybkVNjDFWyo1yhXNGrrBTQxp3ib9BLAWs7k2YKBQsFRkZG9A==",
       "dev": true,
       "requires": {
         "is-alphabetical": "^1.0.0",
         "is-decimal": "^1.0.0"
       }
     },
+    "is-arguments": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.0.tgz",
+      "integrity": "sha512-1Ij4lOMPl/xB5kBDn7I+b2ttPMKa8szhEIrXDuXQD/oe3HJLTLhqhgGspwgyGd6MOywBUqVvYicF72lkgDnIHg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0"
+      }
+    },
     "is-arrayish": {
       "version": "0.2.1",
       "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
       "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0="
     },
+    "is-bigint": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-bigint/-/is-bigint-1.0.2.tgz",
+      "integrity": "sha512-0JV5+SOCQkIdzjBK9buARcV804Ddu7A0Qet6sHi3FimE9ne6m4BGQZfRn+NZiXbBk4F4XmHfDZIipLj9pX8dSA==",
+      "dev": true
+    },
     "is-binary-path": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz",
@@ -6453,6 +8503,15 @@
         "binary-extensions": "^1.0.0"
       }
     },
+    "is-boolean-object": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/is-boolean-object/-/is-boolean-object-1.1.1.tgz",
+      "integrity": "sha512-bXdQWkECBUIAcCkeH1unwJLIpZYaa5VvuygSyS/c2lf719mTKZDU5UdDRlpd01UjADgmW8RfqaP+mRaVPdr/Ng==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2"
+      }
+    },
     "is-buffer": {
       "version": "1.1.5",
       "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.5.tgz",
@@ -6473,6 +8532,15 @@
       "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=",
       "dev": true
     },
+    "is-core-module": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.4.0.tgz",
+      "integrity": "sha512-6A2fkfq1rfeQZjxrZJGerpLCTHRNEBiSgnu0+obeJpEPZRUooHgsizvzv0ZjJwOz3iWIHdJtVWJ/tmPr3D21/A==",
+      "dev": true,
+      "requires": {
+        "has": "^1.0.3"
+      }
+    },
     "is-data-descriptor": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-0.1.4.tgz",
@@ -6489,9 +8557,9 @@
       "dev": true
     },
     "is-decimal": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.1.tgz",
-      "integrity": "sha1-9ftqlJlq2ejjdh+/vQkfH8qMToI=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-1.0.4.tgz",
+      "integrity": "sha512-RGdriMmQQvZ2aqaQq3awNA6dCGtKpiDFcOzrTWrDAT2MiWrKQVPmxLGHl7Y2nNu6led0kEyoX0enY0qXYsv9zw==",
       "dev": true
     },
     "is-descriptor": {
@@ -6535,19 +8603,16 @@
       "dev": true
     },
     "is-extglob": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
-      "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz",
+      "integrity": "sha1-qIwCU1eR8C7TfHahueqXc8gz+MI=",
       "dev": true
     },
     "is-finite": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.0.2.tgz",
-      "integrity": "sha1-zGZ3aVYCvlUO8R6LSqYwU0K20Ko=",
-      "dev": true,
-      "requires": {
-        "number-is-nan": "^1.0.0"
-      }
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-finite/-/is-finite-1.1.0.tgz",
+      "integrity": "sha512-cdyMtqX/BOqqNBBiKlIVkytNHm49MtMlYyn1zxzvJKWmFMlGzm+ry5BBfYyeY9YmNKbRSo/o7OX9w9ale0wg3w==",
+      "dev": true
     },
     "is-fullwidth-code-point": {
       "version": "1.0.0",
@@ -6557,66 +8622,55 @@
         "number-is-nan": "^1.0.0"
       }
     },
-    "is-function": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-function/-/is-function-1.0.1.tgz",
-      "integrity": "sha1-Es+5i2W1fdPRk6MSH19uL0N2ArU=",
-      "dev": true
-    },
     "is-generator": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/is-generator/-/is-generator-1.0.3.tgz",
       "integrity": "sha1-wUwhBX7TbjKNuANHlmxpP4hjifM=",
       "dev": true
     },
+    "is-generator-function": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/is-generator-function/-/is-generator-function-1.0.9.tgz",
+      "integrity": "sha512-ZJ34p1uvIfptHCN7sFTjGibB9/oBg17sHqzDLfuwhvmN/qLVvIQXRQ8licZQ35WJ8KuEQt/etnnzQFI9C9Ue/A==",
+      "dev": true
+    },
     "is-glob": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
-      "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.1.tgz",
+      "integrity": "sha512-5G0tKtBTFImOqDnLB2hG6Bp2qcKEFduo4tZu9MT/H6NQv/ghhy30o55ufafxJ/LdH79LLs2Kfrn85TLKyA7BUg==",
       "dev": true,
+      "optional": true,
       "requires": {
-        "is-extglob": "^1.0.0"
+        "is-extglob": "^2.1.1"
       }
     },
     "is-hexadecimal": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.1.tgz",
-      "integrity": "sha1-bghLvJIGH7sJcexYts5tQE4k2mk=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-1.0.4.tgz",
+      "integrity": "sha512-gyPJuv83bHMpocVYoqof5VDiZveEoGoFL8m3BXNb2VW8Xs+rz9kqO8LOQ5DH6EsuvilT1ApazU0pyl+ytbPtlw==",
+      "dev": true
+    },
+    "is-negative-zero": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-negative-zero/-/is-negative-zero-2.0.1.tgz",
+      "integrity": "sha512-2z6JzQvZRa9A2Y7xC6dQQm4FSTSTNWjKIYYTt4246eMTJmIo0Q+ZyOsU66X8lxK1AbB92dFeglPLrhwpeRKO6w==",
       "dev": true
     },
     "is-number": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz",
-      "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz",
+      "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=",
       "dev": true,
       "requires": {
         "kind-of": "^3.0.2"
       }
     },
-    "is-path-cwd": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-path-cwd/-/is-path-cwd-1.0.0.tgz",
-      "integrity": "sha1-0iXsIxMuie3Tj9p2dHLmLmXxEG0=",
+    "is-number-object": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/is-number-object/-/is-number-object-1.0.5.tgz",
+      "integrity": "sha512-RU0lI/n95pMoUKu9v1BZP5MBcZuNSVJkMkAG2dJqC4z2GlkGUNeH68SuHuBKBD/XFe+LHZ+f9BKkLET60Niedw==",
       "dev": true
     },
-    "is-path-in-cwd": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz",
-      "integrity": "sha1-ZHdYK4IU1gI0YJRWcAO+ip6sBNw=",
-      "dev": true,
-      "requires": {
-        "is-path-inside": "^1.0.0"
-      }
-    },
-    "is-path-inside": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-1.0.0.tgz",
-      "integrity": "sha1-/AbloWg/vaE95mev9xe7wQpI838=",
-      "dev": true,
-      "requires": {
-        "path-is-inside": "^1.0.1"
-      }
-    },
     "is-plain-obj": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz",
@@ -6659,36 +8713,42 @@
       "dev": true
     },
     "is-regex": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz",
-      "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.3.tgz",
+      "integrity": "sha512-qSVXFz28HM7y+IWX6vLCsexdlvzT1PJNFSBuaQLQ5o0IEw8UDYW6/2+eCMVyIsbM8CNLX2a/QWmSpyxYEHY7CQ==",
       "dev": true,
       "requires": {
-        "has": "^1.0.1"
+        "call-bind": "^1.0.2",
+        "has-symbols": "^1.0.2"
+      },
+      "dependencies": {
+        "has-symbols": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
+          "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+          "dev": true
+        }
       }
     },
     "is-relative": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-0.2.1.tgz",
-      "integrity": "sha1-0n9MfVFtF1+2ENuEu+7yPDvJeqU=",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-relative/-/is-relative-1.0.0.tgz",
+      "integrity": "sha512-Kw/ReK0iqwKeu0MITLFuj0jbPAmEiOsIwyIXvvbfa6QfmN9pkD1M+8pdk7Rl/dTKbH34/XBFMbgD4iMJhLQbGA==",
       "dev": true,
       "requires": {
-        "is-unc-path": "^0.1.1"
+        "is-unc-path": "^1.0.0"
       }
     },
     "is-resolvable": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.0.0.tgz",
-      "integrity": "sha1-jfV8YeouPFAUCNEA+wE8+NbgzGI=",
-      "dev": true,
-      "requires": {
-        "tryit": "^1.0.1"
-      }
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/is-resolvable/-/is-resolvable-1.1.0.tgz",
+      "integrity": "sha512-qgDYXFSR5WvEfuS5dMj6oTMEbrrSaM0CrFk2Yiq/gXnBvD9pMa2jGXxyhGLfvhZpuMZe18CJpFxAt3CRs42NMg==",
+      "dev": true
     },
     "is-ssh": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/is-ssh/-/is-ssh-1.3.0.tgz",
-      "integrity": "sha1-6+oRaaJhTaOSpjdANmw84EnY3/Y=",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/is-ssh/-/is-ssh-1.3.3.tgz",
+      "integrity": "sha512-NKzJmQzJfEEma3w5cJNcUMxoXfDjz0Zj0eyCalHn2E6VOwlzjZo0yuO2fcBSf8zhFuVCL/82/r5gRcoi6aEPVQ==",
       "dev": true,
       "requires": {
         "protocols": "^1.1.0"
@@ -6700,6 +8760,12 @@
       "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=",
       "dev": true
     },
+    "is-string": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.6.tgz",
+      "integrity": "sha512-2gdzbKUuqtQ3lYNrUTQYoClPhm7oQu4UdpSZMp1/DGgkHBT8E2Z1l0yMdb6D4zNAxwDiMv8MdulKROJGNl0Q0w==",
+      "dev": true
+    },
     "is-svg": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-svg/-/is-svg-2.1.0.tgz",
@@ -6710,10 +8776,34 @@
       }
     },
     "is-symbol": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz",
-      "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=",
-      "dev": true
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.4.tgz",
+      "integrity": "sha512-C/CPBqKWnvdcxqIARxyOh4v1UUEOCHpgDa0WYgpKDFMszcrPcffg5uhwSgPCLD2WWxmq6isisz87tzT01tuGhg==",
+      "dev": true,
+      "requires": {
+        "has-symbols": "^1.0.2"
+      },
+      "dependencies": {
+        "has-symbols": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
+          "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+          "dev": true
+        }
+      }
+    },
+    "is-typed-array": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.5.tgz",
+      "integrity": "sha512-S+GRDgJlR3PyEbsX/Fobd9cqpZBuvUS+8asRqYDMLCb2qMzt1oz5m5oxQCxOgUDxiWsOVNi4yaF+/uvdlHlYug==",
+      "dev": true,
+      "requires": {
+        "available-typed-arrays": "^1.0.2",
+        "call-bind": "^1.0.2",
+        "es-abstract": "^1.18.0-next.2",
+        "foreach": "^2.0.5",
+        "has-symbols": "^1.0.1"
+      }
     },
     "is-typedarray": {
       "version": "1.0.0",
@@ -6722,12 +8812,12 @@
       "dev": true
     },
     "is-unc-path": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-0.1.2.tgz",
-      "integrity": "sha1-arBTpyVzwQJQ/0FqOBTDUXivObk=",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/is-unc-path/-/is-unc-path-1.0.0.tgz",
+      "integrity": "sha512-mrGpVd0fs7WWLfVsStvgF6iEJnbjDFZh9/emhRDcGWTduTfNHd9CHeUwH3gYIjdbwo4On6hunkztwOaAw0yllQ==",
       "dev": true,
       "requires": {
-        "unc-path-regex": "^0.1.0"
+        "unc-path-regex": "^0.1.2"
       }
     },
     "is-utf8": {
@@ -6742,21 +8832,21 @@
       "dev": true
     },
     "is-whitespace-character": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-whitespace-character/-/is-whitespace-character-1.0.1.tgz",
-      "integrity": "sha1-muAXbzKCtlRXoZks2whPil+DPjs=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-whitespace-character/-/is-whitespace-character-1.0.4.tgz",
+      "integrity": "sha512-SDweEzfIZM0SJV0EUga669UTKlmL0Pq8Lno0QDQsPnvECB3IM2aP0gdx5TrU0A01MAPfViaZiI2V1QMZLaKK5w==",
       "dev": true
     },
     "is-windows": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-0.2.0.tgz",
-      "integrity": "sha1-3hqm1j6indJIc3tp8f+LgALSEIw=",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz",
+      "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==",
       "dev": true
     },
     "is-word-character": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/is-word-character/-/is-word-character-1.0.1.tgz",
-      "integrity": "sha1-WgP6HqkazopusMfNdw64bWXIvvs=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/is-word-character/-/is-word-character-1.0.4.tgz",
+      "integrity": "sha512-5SMO8RVennx3nZrqtKwCGyyetPE9VDba5ugvKLaD4KopPG5kR4mQ7tNt/r7feL5yt5h3lpuBbIUmCOG2eSzXHA==",
       "dev": true
     },
     "isarray": {
@@ -6770,13 +8860,10 @@
       "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA="
     },
     "isobject": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz",
-      "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=",
-      "dev": true,
-      "requires": {
-        "isarray": "1.0.0"
-      }
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
+      "dev": true
     },
     "isomorphic-fetch": {
       "version": "2.2.1",
@@ -6786,6 +8873,18 @@
       "requires": {
         "node-fetch": "^1.0.1",
         "whatwg-fetch": ">=0.10.0"
+      },
+      "dependencies": {
+        "node-fetch": {
+          "version": "1.7.3",
+          "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.3.tgz",
+          "integrity": "sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==",
+          "dev": true,
+          "requires": {
+            "encoding": "^0.1.11",
+            "is-stream": "^1.0.1"
+          }
+        }
       }
     },
     "isstream": {
@@ -6794,61 +8893,10 @@
       "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=",
       "dev": true
     },
-    "jison": {
-      "version": "0.4.13",
-      "resolved": "https://registry.npmjs.org/jison/-/jison-0.4.13.tgz",
-      "integrity": "sha1-kEFwfWIkE2f1iDRTK58ZwsNvrHg=",
-      "dev": true,
-      "requires": {
-        "JSONSelect": "0.4.0",
-        "cjson": "~0.2.1",
-        "ebnf-parser": "~0.1.9",
-        "escodegen": "0.0.21",
-        "esprima": "1.0.x",
-        "jison-lex": "0.2.x",
-        "lex-parser": "~0.1.3",
-        "nomnom": "1.5.2"
-      },
-      "dependencies": {
-        "escodegen": {
-          "version": "0.0.21",
-          "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-0.0.21.tgz",
-          "integrity": "sha1-U9ZSz6EDA4gnlFilJmxf/HCcY8M=",
-          "dev": true,
-          "requires": {
-            "esprima": "~1.0.2",
-            "estraverse": "~0.0.4",
-            "source-map": ">= 0.1.2"
-          }
-        },
-        "esprima": {
-          "version": "1.0.4",
-          "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz",
-          "integrity": "sha1-n1V+CPw7TSbs6d00+Pv0drYlha0=",
-          "dev": true
-        },
-        "estraverse": {
-          "version": "0.0.4",
-          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-0.0.4.tgz",
-          "integrity": "sha1-AaCTLf7ldGhKWYr1pnw7+bZCjbI=",
-          "dev": true
-        }
-      }
-    },
-    "jison-lex": {
-      "version": "0.2.1",
-      "resolved": "https://registry.npmjs.org/jison-lex/-/jison-lex-0.2.1.tgz",
-      "integrity": "sha1-rEuBXozOUTLrErXfz+jXB7iETf4=",
-      "dev": true,
-      "requires": {
-        "lex-parser": "0.1.x",
-        "nomnom": "1.5.2"
-      }
-    },
     "js-base64": {
-      "version": "2.4.9",
-      "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-2.4.9.tgz",
-      "integrity": "sha512-xcinL3AuDJk7VSzsHgb9DvvIXayBbadtMZ4HFPx8rUszbW1MuNMlwYVC4zzCZ6e1sqZpnNS5ZFYOhXqA39T7LQ==",
+      "version": "2.6.4",
+      "resolved": "https://registry.npmjs.org/js-base64/-/js-base64-2.6.4.tgz",
+      "integrity": "sha512-pZe//GGmwJndub7ZghVHz7vjb2LgC1m8B07Au3eYqeqv9emhESByMXxaEgkUkEqJe87oBbSniGYoQNIBklc7IQ==",
       "dev": true
     },
     "js-tokens": {
@@ -6858,19 +8906,19 @@
       "dev": true
     },
     "js-yaml": {
-      "version": "3.7.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.7.0.tgz",
-      "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=",
+      "version": "3.14.1",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.1.tgz",
+      "integrity": "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g==",
       "dev": true,
       "requires": {
         "argparse": "^1.0.7",
-        "esprima": "^2.6.0"
+        "esprima": "^4.0.0"
       },
       "dependencies": {
         "esprima": {
-          "version": "2.7.3",
-          "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
-          "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
+          "version": "4.0.1",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+          "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
           "dev": true
         }
       }
@@ -6900,9 +8948,9 @@
       "dev": true
     },
     "json-stable-stringify": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz",
-      "integrity": "sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=",
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-0.0.1.tgz",
+      "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=",
       "dev": true,
       "requires": {
         "jsonify": "~0.0.0"
@@ -6922,7 +8970,7 @@
     },
     "json5": {
       "version": "0.5.1",
-      "resolved": "http://registry.npmjs.org/json5/-/json5-0.5.1.tgz",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz",
       "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=",
       "dev": true
     },
@@ -6939,61 +8987,26 @@
       "dev": true
     },
     "jsonpath": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/jsonpath/-/jsonpath-1.0.0.tgz",
-      "integrity": "sha1-Rc2dTE0NaCXZC9fkD4PxGCsT3Qc=",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/jsonpath/-/jsonpath-1.1.0.tgz",
+      "integrity": "sha512-CZHwa1sZOf42qkIyK7evwToFXeTB4iplbl6Z9CVwU0wmBQPffL6gtYJXCoeciJoZENMuzaidPjhp2iOLRei4wQ==",
       "dev": true,
       "requires": {
         "esprima": "1.2.2",
-        "jison": "0.4.13",
-        "static-eval": "2.0.0",
+        "static-eval": "2.0.2",
         "underscore": "1.7.0"
       },
       "dependencies": {
-        "escodegen": {
-          "version": "1.11.0",
-          "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.11.0.tgz",
-          "integrity": "sha512-IeMV45ReixHS53K/OmfKAIztN/igDHzTJUhZM3k1jMhIZWjk45SMwAtBsEXiJp3vSPmTcu6CXn7mDvFHRN66fw==",
-          "dev": true,
-          "requires": {
-            "esprima": "^3.1.3",
-            "estraverse": "^4.2.0",
-            "esutils": "^2.0.2",
-            "optionator": "^0.8.1",
-            "source-map": "~0.6.1"
-          },
-          "dependencies": {
-            "esprima": {
-              "version": "3.1.3",
-              "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz",
-              "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=",
-              "dev": true
-            }
-          }
-        },
         "esprima": {
           "version": "1.2.2",
           "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.2.tgz",
           "integrity": "sha1-dqD9Zvz+FU/SkmZ9wmQBl1CxZXs=",
           "dev": true
         },
-        "estraverse": {
-          "version": "4.2.0",
-          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz",
-          "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=",
-          "dev": true
-        },
-        "source-map": {
-          "version": "0.6.1",
-          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
-          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
-          "dev": true,
-          "optional": true
-        },
         "static-eval": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.0.tgz",
-          "integrity": "sha512-6flshd3F1Gwm+Ksxq463LtFd1liC77N/PX1FVVc3OzL3hAmo2fwHFbuArkcfi7s9rTNsLEhcRmXGFZhlgy40uw==",
+          "version": "2.0.2",
+          "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.2.tgz",
+          "integrity": "sha512-N/D219Hcr2bPjLxPiV+TQE++Tsmrady7TqAJugLy7Xk1EumfDWS/f5dtBbkRCGE7wKKXuYockQoj8Rm2/pVKyg==",
           "dev": true,
           "requires": {
             "escodegen": "^1.8.1"
@@ -7020,18 +9033,19 @@
       "dev": true
     },
     "jsx-ast-utils": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-2.0.1.tgz",
-      "integrity": "sha1-6AGxs5mF4g//yHtA43SAgOLcrH8=",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.2.0.tgz",
+      "integrity": "sha512-EIsmt3O3ljsU6sot/J4E1zDRxfBNrhjyf/OKjlydwgEimQuznlM4Wv7U+ueONJMyEn1WRE0K8dhi3dVAXYT24Q==",
       "dev": true,
       "requires": {
-        "array-includes": "^3.0.3"
+        "array-includes": "^3.1.2",
+        "object.assign": "^4.1.2"
       }
     },
     "kebab-case": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/kebab-case/-/kebab-case-1.0.0.tgz",
-      "integrity": "sha1-P55JkK3K0MaGwOcB92RYaPdfkes=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/kebab-case/-/kebab-case-1.0.1.tgz",
+      "integrity": "sha512-txPHx6nVLhv8PHGXIlAk0nYoh894SpAqGPXNvbg2hh8spvHXIah3+vT87DLoa59nKgC6scD3u3xAuRIgiMqbfQ==",
       "dev": true
     },
     "kind-of": {
@@ -7044,22 +9058,13 @@
       }
     },
     "labeled-stream-splicer": {
-      "version": "2.0.1",
-      "resolved": "http://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.1.tgz",
-      "integrity": "sha512-MC94mHZRvJ3LfykJlTUipBqenZz1pacOZEMhhQ8dMGcDHs0SBE5GbsavUXV7YtP3icBW17W0Zy1I0lfASmo9Pg==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.2.tgz",
+      "integrity": "sha512-Ca4LSXFFZUjPScRaqOcFxneA0VpKZr4MMYCljyQr4LIewTLb3Y0IUTIsnBBsVubIeEfxeSZpSjSsRM8APEQaAw==",
       "dev": true,
       "requires": {
         "inherits": "^2.0.1",
-        "isarray": "^2.0.4",
         "stream-splicer": "^2.0.0"
-      },
-      "dependencies": {
-        "isarray": {
-          "version": "2.0.4",
-          "resolved": "https://registry.npmjs.org/isarray/-/isarray-2.0.4.tgz",
-          "integrity": "sha512-GMxXOiUirWg1xTKRipM0Ek07rX+ubx4nNVElTJdNLYmNO/2YrDkgJGw9CljXn+r4EWiDQg/8lsRdHyg2PJuUaA==",
-          "dev": true
-        }
       }
     },
     "lazy-cache": {
@@ -7095,16 +9100,10 @@
         "type-check": "~0.3.2"
       }
     },
-    "lex-parser": {
-      "version": "0.1.4",
-      "resolved": "https://registry.npmjs.org/lex-parser/-/lex-parser-0.1.4.tgz",
-      "integrity": "sha1-ZMTwJfF/1Tv7RXY/rrFvAVp0dVA=",
-      "dev": true
-    },
     "livereload-js": {
-      "version": "2.2.2",
-      "resolved": "https://registry.npmjs.org/livereload-js/-/livereload-js-2.2.2.tgz",
-      "integrity": "sha1-bIclfmSKtHW8JOoldFftzB+NC8I=",
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/livereload-js/-/livereload-js-2.4.0.tgz",
+      "integrity": "sha512-XPQH8Z2GDP/Hwz2PCDrh2mth4yFejwA1OZ/81Ti3LgKyhDcEjsSsqFWZojHG0va/duGd+WyosY7eXLDoOyqcPw==",
       "dev": true
     },
     "load-json-file": {
@@ -7138,9 +9137,9 @@
       }
     },
     "lodash": {
-      "version": "4.17.11",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.11.tgz",
-      "integrity": "sha512-cQKh8igo5QUhZ7lg38DYWAxMvjSAKG0A8wGSVimP07SIUEK2UO+arSRKbRZWtelMtN5V0Hkwh5ryOto/SshYIg==",
+      "version": "4.17.20",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.20.tgz",
+      "integrity": "sha512-PlhdFcillOINfeV7Ni6oF1TAEayyZBoZ8bcshTHqOYJYlrqzRK5hagpagky5o4HfCzzd1TRkXPMFq6cKk9rGmA==",
       "dev": true
     },
     "lodash.assign": {
@@ -7216,9 +9215,9 @@
       "dev": true
     },
     "longest-streak": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.1.tgz",
-      "integrity": "sha1-QtKRtUEeQDZcAOYxk0l+IkcxbjU=",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-2.0.4.tgz",
+      "integrity": "sha512-vM6rUVCVUJJt33bnmHiZEvr7wPT78ztX7rojL+LW51bHtLh6HTjx84LA5W4+oa6aKEJA7jJu5LR6vQRBpA5DVg==",
       "dev": true
     },
     "loose-envify": {
@@ -7237,24 +9236,44 @@
       "dev": true
     },
     "lru-cache": {
-      "version": "4.1.5",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.5.tgz",
-      "integrity": "sha512-sWZlbEP2OsHNkXrMl5GYk/jKk70MBng6UU4YI/qGDYbgf6YbP4EvmqISbXCoJiRKs+1bSpFHVgQxvJ17F2li5g==",
-      "dev": true,
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+      "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
       "requires": {
-        "pseudomap": "^1.0.2",
-        "yallist": "^2.1.2"
+        "yallist": "^4.0.0"
+      },
+      "dependencies": {
+        "yallist": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+          "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
+        }
       }
     },
     "magic-string": {
       "version": "0.22.5",
-      "resolved": "http://registry.npmjs.org/magic-string/-/magic-string-0.22.5.tgz",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.22.5.tgz",
       "integrity": "sha512-oreip9rJZkzvA8Qzk9HFs8fZGF/u7H/gtrE8EN6RjKJ9kh2HlC+yQ2QezifqTZfGyiuAV0dRv5a+y/8gBb1m9w==",
       "dev": true,
       "requires": {
         "vlq": "^0.2.2"
       }
     },
+    "make-dir": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/make-dir/-/make-dir-3.1.0.tgz",
+      "integrity": "sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==",
+      "requires": {
+        "semver": "^6.0.0"
+      },
+      "dependencies": {
+        "semver": {
+          "version": "6.3.0",
+          "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.0.tgz",
+          "integrity": "sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw=="
+        }
+      }
+    },
     "map-cache": {
       "version": "0.2.2",
       "resolved": "https://registry.npmjs.org/map-cache/-/map-cache-0.2.2.tgz",
@@ -7271,27 +9290,27 @@
       }
     },
     "markdown-escapes": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/markdown-escapes/-/markdown-escapes-1.0.1.tgz",
-      "integrity": "sha1-GZTfLTr0gR3lmmcUk0wrIpJzRRg=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/markdown-escapes/-/markdown-escapes-1.0.4.tgz",
+      "integrity": "sha512-8z4efJYk43E0upd0NbVXwgSTQs6cT3T06etieCMEg7dRbzCbxUCK/GHlX8mhHRDcp+OLlHkPKsvqQTCvsRl2cg==",
       "dev": true
     },
     "markdown-table": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.1.tgz",
-      "integrity": "sha1-Sz3ToTPRUYuO8NvHCb8qG0gkvIw=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/markdown-table/-/markdown-table-1.1.3.tgz",
+      "integrity": "sha512-1RUZVgQlpJSPWYbFSpmudq5nHY1doEIv89gBtF0s4gW1GF2XorxcA/70M5vq7rLv0a6mhOUccRsqkwhwLCIQ2Q==",
       "dev": true
     },
     "math-expression-evaluator": {
-      "version": "1.2.17",
-      "resolved": "https://registry.npmjs.org/math-expression-evaluator/-/math-expression-evaluator-1.2.17.tgz",
-      "integrity": "sha1-3oGf282E3M2PrlnGrreWFbnSZqw=",
+      "version": "1.3.7",
+      "resolved": "https://registry.npmjs.org/math-expression-evaluator/-/math-expression-evaluator-1.3.7.tgz",
+      "integrity": "sha512-nrbaifCl42w37hYd6oRLvoymFK42tWB+WQTMFtksDGQMi5GvlJwnz/CsS30FFAISFLtX+A0csJ0xLiuuyyec7w==",
       "dev": true
     },
     "math-random": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/math-random/-/math-random-1.0.1.tgz",
-      "integrity": "sha1-izqsWIuKZuSXXjzepn97sylgH6w=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/math-random/-/math-random-1.0.4.tgz",
+      "integrity": "sha512-rUxjysqif/BZQH2yhd5Aaq7vXMSx9NdEsQcyA07uEzIvxgI7zIr33gGsh+RU0/XjmQpCW7RsVof1vlkvQVCK5A==",
       "dev": true
     },
     "md5.js": {
@@ -7306,27 +9325,26 @@
       },
       "dependencies": {
         "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
           "dev": true
         }
       }
     },
     "mdast-util-compact": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-compact/-/mdast-util-compact-1.0.1.tgz",
-      "integrity": "sha1-zbX4TitqLTEU3zO9BdnLMuPECDo=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/mdast-util-compact/-/mdast-util-compact-1.0.4.tgz",
+      "integrity": "sha512-3YDMQHI5vRiS2uygEFYaqckibpJtKq5Sj2c8JioeOQBU6INpKbdWzfyLqFFnDwEcEnRFIdMsguzs5pC1Jp4Isg==",
       "dev": true,
       "requires": {
-        "unist-util-modify-children": "^1.0.0",
         "unist-util-visit": "^1.1.0"
       }
     },
     "mdast-util-definitions": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-1.2.2.tgz",
-      "integrity": "sha512-9NloPSwaB9f1PKcGqaScfqRf6zKOEjTIXVIbPOmgWI/JKxznlgVXC5C+8qgl3AjYg2vJBRgLYfLICaNiac89iA==",
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/mdast-util-definitions/-/mdast-util-definitions-1.2.5.tgz",
+      "integrity": "sha512-CJXEdoLfiISCDc2JB6QLb79pYfI6+GcIH+W2ox9nMc7od0Pz+bovcHsiq29xAQY6ayqe/9CsK2VzkSJdg1pFYA==",
       "dev": true,
       "requires": {
         "unist-util-visit": "^1.0.0"
@@ -7342,9 +9360,9 @@
       }
     },
     "mdast-util-to-hast": {
-      "version": "2.4.3",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-2.4.3.tgz",
-      "integrity": "sha1-zXh0yYMmJ/E0/TdWFjhz+T8rHeM=",
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-2.5.0.tgz",
+      "integrity": "sha1-8IeETSVcdUDzaQbaMLoQbA7l7i8=",
       "dev": true,
       "requires": {
         "collapse-white-space": "^1.0.0",
@@ -7361,15 +9379,15 @@
       }
     },
     "mdast-util-to-string": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-1.0.4.tgz",
-      "integrity": "sha1-XEVch4yTVfDB5/PotxnPWDaRrPs=",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-1.1.0.tgz",
+      "integrity": "sha512-jVU0Nr2B9X3MU4tSK7JP1CMkSvOj7X5l/GboG1tKRw52lLF1x2Ju92Ms9tNetCcbfX3hzlM73zYo2NKkWSfF/A==",
       "dev": true
     },
     "mdast-util-toc": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/mdast-util-toc/-/mdast-util-toc-2.0.1.tgz",
-      "integrity": "sha1-sdLLI7+wH4Evp7Vb/+iwqL7fbyE=",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-toc/-/mdast-util-toc-2.1.0.tgz",
+      "integrity": "sha512-ove/QQWSrYOrf9G3xn2MTAjy7PKCtCmm261wpQwecoPAsUtkihkMVczxFqil7VihxgSz4ID9c8bBTsyXR30gQg==",
       "dev": true,
       "requires": {
         "github-slugger": "^1.1.1",
@@ -7402,24 +9420,32 @@
       }
     },
     "micromatch": {
-      "version": "2.3.11",
-      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz",
-      "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=",
+      "version": "3.1.10",
+      "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-3.1.10.tgz",
+      "integrity": "sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==",
       "dev": true,
       "requires": {
-        "arr-diff": "^2.0.0",
-        "array-unique": "^0.2.1",
-        "braces": "^1.8.2",
-        "expand-brackets": "^0.1.4",
-        "extglob": "^0.3.1",
-        "filename-regex": "^2.0.0",
-        "is-extglob": "^1.0.0",
-        "is-glob": "^2.0.1",
-        "kind-of": "^3.0.2",
-        "normalize-path": "^2.0.1",
-        "object.omit": "^2.0.0",
-        "parse-glob": "^3.0.4",
-        "regex-cache": "^0.4.2"
+        "arr-diff": "^4.0.0",
+        "array-unique": "^0.3.2",
+        "braces": "^2.3.1",
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "extglob": "^2.0.4",
+        "fragment-cache": "^0.2.1",
+        "kind-of": "^6.0.2",
+        "nanomatch": "^1.2.9",
+        "object.pick": "^1.3.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.2"
+      },
+      "dependencies": {
+        "kind-of": {
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+          "dev": true
+        }
       }
     },
     "miller-rabin": {
@@ -7430,27 +9456,35 @@
       "requires": {
         "bn.js": "^4.0.0",
         "brorand": "^1.0.1"
+      },
+      "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        }
       }
     },
     "mime": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/mime/-/mime-1.4.1.tgz",
-      "integrity": "sha512-KI1+qOZu5DcW6wayYHSzR/tXKCDC5Om4s1z2QJjDULzLcmf3DvzS7oluY4HCTrc+9FiKmWUgeNLg7W3uIQvxtQ==",
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
       "dev": true
     },
     "mime-db": {
-      "version": "1.37.0",
-      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.37.0.tgz",
-      "integrity": "sha512-R3C4db6bgQhlIhPU48fUtdVmKnflq+hRdad7IyKhtFj06VPNVdk2RhiYL3UjQIlso8L+YxAtFkobT0VK+S/ybg==",
+      "version": "1.45.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.45.0.tgz",
+      "integrity": "sha512-CkqLUxUk15hofLoLyljJSrukZi8mAtgd+yE5uO4tqRZsdsAJKv0O+rFMhVDRJgozy+yG6md5KwuXhD4ocIoP+w==",
       "dev": true
     },
     "mime-types": {
-      "version": "2.1.21",
-      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.21.tgz",
-      "integrity": "sha512-3iL6DbwpyLzjR3xHSFNFeb9Nz/M8WDkX33t1GFQnFOllWk8pOrh/LSrB5OXlnlW5P9LH73X6loW/eogc+F5lJg==",
+      "version": "2.1.28",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.28.tgz",
+      "integrity": "sha512-0TO2yJ5YHYr7M2zzT7gDU1tbwHxEUWBCLt0lscSNpcdAfFyJOVEpRYNS7EXVcTLNj/25QO8gulHC5JtTzSE2UQ==",
       "dev": true,
       "requires": {
-        "mime-db": "~1.37.0"
+        "mime-db": "1.45.0"
       }
     },
     "mimic-fn": {
@@ -7479,6 +9513,23 @@
         "uglify-js": "^2.6.1"
       },
       "dependencies": {
+        "camelcase": {
+          "version": "1.2.1",
+          "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz",
+          "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=",
+          "dev": true
+        },
+        "cliui": {
+          "version": "2.1.0",
+          "resolved": "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz",
+          "integrity": "sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE=",
+          "dev": true,
+          "requires": {
+            "center-align": "^0.1.1",
+            "right-align": "^0.1.1",
+            "wordwrap": "0.0.2"
+          }
+        },
         "tmp": {
           "version": "0.0.28",
           "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.28.tgz",
@@ -7487,6 +9538,35 @@
           "requires": {
             "os-tmpdir": "~1.0.1"
           }
+        },
+        "uglify-js": {
+          "version": "2.8.29",
+          "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz",
+          "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=",
+          "dev": true,
+          "requires": {
+            "source-map": "~0.5.1",
+            "uglify-to-browserify": "~1.0.0",
+            "yargs": "~3.10.0"
+          }
+        },
+        "wordwrap": {
+          "version": "0.0.2",
+          "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz",
+          "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=",
+          "dev": true
+        },
+        "yargs": {
+          "version": "3.10.0",
+          "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz",
+          "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=",
+          "dev": true,
+          "requires": {
+            "camelcase": "^1.0.2",
+            "cliui": "^2.1.0",
+            "decamelize": "^1.0.0",
+            "window-size": "0.1.0"
+          }
         }
       }
     },
@@ -7511,43 +9591,14 @@
       }
     },
     "minimist": {
-      "version": "0.0.8",
-      "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz",
-      "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0="
-    },
-    "minipass": {
-      "version": "2.3.5",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-2.3.5.tgz",
-      "integrity": "sha512-Gi1W4k059gyRbyVUZQ4mEqLm0YIUiGYfvxhF6SIlk3ui1WVxMTGfGdQ2SInh3PDrRTVvPKgULkpJtT4RH10+VA==",
-      "requires": {
-        "safe-buffer": "^5.1.2",
-        "yallist": "^3.0.0"
-      },
-      "dependencies": {
-        "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
-        },
-        "yallist": {
-          "version": "3.0.3",
-          "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.3.tgz",
-          "integrity": "sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A=="
-        }
-      }
-    },
-    "minizlib": {
-      "version": "1.2.1",
-      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-1.2.1.tgz",
-      "integrity": "sha512-7+4oTUOWKg7AuL3vloEWekXY2/D20cevzsrNT2kGWm+39J9hGTCBv8VI5Pm5lXZ/o3/mdR4f8rflAPhnQb8mPA==",
-      "requires": {
-        "minipass": "^2.2.1"
-      }
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
+      "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw=="
     },
     "mixin-deep": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.1.tgz",
-      "integrity": "sha512-8ZItLHeEgaqEvd5lYBXfm4EZSFCX29Jb9K+lAHhDKzReKBQKj3R+7NOF6tjqYi9t4oI8VUfaWITJQm86wnXGNQ==",
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/mixin-deep/-/mixin-deep-1.3.2.tgz",
+      "integrity": "sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==",
       "dev": true,
       "requires": {
         "for-in": "^1.0.2",
@@ -7566,51 +9617,72 @@
       }
     },
     "mkdirp": {
-      "version": "0.5.1",
-      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz",
-      "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=",
+      "version": "0.5.5",
+      "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.5.tgz",
+      "integrity": "sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==",
       "requires": {
-        "minimist": "0.0.8"
+        "minimist": "^1.2.5"
       }
     },
-    "module-deps": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-6.2.0.tgz",
-      "integrity": "sha512-hKPmO06so6bL/ZvqVNVqdTVO8UAYsi3tQWlCa+z9KuWhoN4KDQtb5hcqQQv58qYiDE21wIvnttZEPiDgEbpwbA==",
+    "mkdirp-classic": {
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/mkdirp-classic/-/mkdirp-classic-0.5.3.tgz",
+      "integrity": "sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==",
+      "dev": true
+    },
+    "module-deps-sortable": {
+      "version": "4.0.6",
+      "resolved": "https://registry.npmjs.org/module-deps-sortable/-/module-deps-sortable-4.0.6.tgz",
+      "integrity": "sha1-ElGkuixEqS32mJvQKdoSGk8hCbA=",
       "dev": true,
       "requires": {
         "JSONStream": "^1.0.3",
         "browser-resolve": "^1.7.0",
-        "cached-path-relative": "^1.0.0",
-        "concat-stream": "~1.6.0",
+        "concat-stream": "~1.5.0",
         "defined": "^1.0.0",
-        "detective": "^5.0.2",
+        "detective": "^4.0.0",
         "duplexer2": "^0.1.2",
         "inherits": "^2.0.1",
         "parents": "^1.0.0",
         "readable-stream": "^2.0.2",
-        "resolve": "^1.4.0",
+        "resolve": "^1.1.3",
         "stream-combiner2": "^1.1.1",
         "subarg": "^1.0.0",
         "through2": "^2.0.0",
         "xtend": "^4.0.0"
       },
       "dependencies": {
-        "detective": {
-          "version": "5.1.0",
-          "resolved": "http://registry.npmjs.org/detective/-/detective-5.1.0.tgz",
-          "integrity": "sha512-TFHMqfOvxlgrfVzTEkNBSh9SvSNX/HfF4OFI2QFGCyPm02EsyILqnUeb5P6q7JZ3SFNTBL5t2sePRgrN4epUWQ==",
+        "concat-stream": {
+          "version": "1.5.2",
+          "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.5.2.tgz",
+          "integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=",
           "dev": true,
           "requires": {
-            "acorn-node": "^1.3.0",
-            "defined": "^1.0.0",
-            "minimist": "^1.1.1"
+            "inherits": "~2.0.1",
+            "readable-stream": "~2.0.0",
+            "typedarray": "~0.0.5"
+          },
+          "dependencies": {
+            "readable-stream": {
+              "version": "2.0.6",
+              "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz",
+              "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=",
+              "dev": true,
+              "requires": {
+                "core-util-is": "~1.0.0",
+                "inherits": "~2.0.1",
+                "isarray": "~1.0.0",
+                "process-nextick-args": "~1.0.6",
+                "string_decoder": "~0.10.x",
+                "util-deprecate": "~1.0.1"
+              }
+            }
           }
         },
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+        "string_decoder": {
+          "version": "0.10.31",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz",
+          "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=",
           "dev": true
         }
       }
@@ -7627,7 +9699,8 @@
     "ms": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
-      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g="
+      "integrity": "sha1-VgiurfwAvmwpAd9fmGF4jeDVl8g=",
+      "dev": true
     },
     "multimatch": {
       "version": "2.1.0",
@@ -7648,9 +9721,48 @@
       "dev": true
     },
     "nan": {
-      "version": "2.14.1",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.1.tgz",
-      "integrity": "sha512-isWHgVjnFjh2x2yuJ/tj3JbwoHu3UC2dX5G/88Cm24yB6YopVgxvBObDY7n5xW6ExmFhJpSEQqFPvq9zaXc8Jw=="
+      "version": "2.14.2",
+      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
+      "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ=="
+    },
+    "nanomatch": {
+      "version": "1.2.13",
+      "resolved": "https://registry.npmjs.org/nanomatch/-/nanomatch-1.2.13.tgz",
+      "integrity": "sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==",
+      "dev": true,
+      "requires": {
+        "arr-diff": "^4.0.0",
+        "array-unique": "^0.3.2",
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "fragment-cache": "^0.2.1",
+        "is-windows": "^1.0.2",
+        "kind-of": "^6.0.2",
+        "object.pick": "^1.3.0",
+        "regex-not": "^1.0.0",
+        "snapdragon": "^0.8.1",
+        "to-regex": "^3.0.1"
+      },
+      "dependencies": {
+        "arr-diff": {
+          "version": "4.0.0",
+          "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-4.0.0.tgz",
+          "integrity": "sha1-1kYQdP6/7HHn4VI1dhoyml3HxSA=",
+          "dev": true
+        },
+        "array-unique": {
+          "version": "0.3.2",
+          "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.3.2.tgz",
+          "integrity": "sha1-qJS3XUvE9s1nnvMkSp/Y9Gri1Cg=",
+          "dev": true
+        },
+        "kind-of": {
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+          "dev": true
+        }
+      }
     },
     "natural-compare": {
       "version": "1.4.0",
@@ -7658,23 +9770,6 @@
       "integrity": "sha1-Sr6/7tdUHywnrPspvbvRXI1bpPc=",
       "dev": true
     },
-    "needle": {
-      "version": "2.2.4",
-      "resolved": "https://registry.npmjs.org/needle/-/needle-2.2.4.tgz",
-      "integrity": "sha512-HyoqEb4wr/rsoaIDfTH2aVL9nWtQqba2/HvMv+++m8u0dz808MaagKILxtfeSN7QU7nvbQ79zk3vYOJp9zsNEA==",
-      "requires": {
-        "debug": "^2.1.2",
-        "iconv-lite": "^0.4.4",
-        "sax": "^1.2.4"
-      },
-      "dependencies": {
-        "sax": {
-          "version": "1.2.4",
-          "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
-          "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw=="
-        }
-      }
-    },
     "nice-try": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/nice-try/-/nice-try-1.0.5.tgz",
@@ -7691,41 +9786,41 @@
       }
     },
     "node-cmake": {
-      "version": "2.3.2",
-      "resolved": "https://registry.npmjs.org/node-cmake/-/node-cmake-2.3.2.tgz",
-      "integrity": "sha1-4PvFSxFAWwdwXk1tQYZa6VrSidA=",
+      "version": "2.5.1",
+      "resolved": "https://registry.npmjs.org/node-cmake/-/node-cmake-2.5.1.tgz",
+      "integrity": "sha512-gKnzheTyu9TJvFiqVwg1BGWyqxMwfNPWoR0Ab0kDqmoA+U/XSCxIo4s/fNbEubohhmIAFEo1i+CAJ4jZDnMTVw==",
       "requires": {
-        "nan": "*",
-        "which": "^1.2.14",
-        "yargs": "^7.0.2"
+        "debug": "^3.1.0",
+        "nan": "^2.8.0",
+        "which": "^1.3.0",
+        "yargs": "^7.1.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "3.2.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+          "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="
+        }
       }
     },
     "node-fetch": {
-      "version": "1.7.3",
-      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.3.tgz",
-      "integrity": "sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==",
-      "dev": true,
-      "requires": {
-        "encoding": "^0.1.11",
-        "is-stream": "^1.0.1"
-      }
+      "version": "2.6.1",
+      "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.1.tgz",
+      "integrity": "sha512-V4aYg89jEoVRxRb2fJdAg8FHvI7cEyYdVAh94HH0UIK8oJxUfkjlDQN9RbMx+bEjP7+ggMiFRprSti032Oipxw=="
     },
-    "node-pre-gyp": {
-      "version": "0.12.0",
-      "resolved": "https://registry.npmjs.org/node-pre-gyp/-/node-pre-gyp-0.12.0.tgz",
-      "integrity": "sha512-4KghwV8vH5k+g2ylT+sLTjy5wmUOb9vPhnM8NHvRf9dHmnW/CndrFXy2aRPaPST6dugXSdHXfeaHQm77PIz/1A==",
-      "requires": {
-        "detect-libc": "^1.0.2",
-        "mkdirp": "^0.5.1",
-        "needle": "^2.2.1",
-        "nopt": "^4.0.1",
-        "npm-packlist": "^1.1.6",
-        "npmlog": "^4.0.2",
-        "rc": "^1.2.7",
-        "rimraf": "^2.6.1",
-        "semver": "^5.3.0",
-        "tar": "^4"
-      }
+    "node-releases": {
+      "version": "1.1.73",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-1.1.73.tgz",
+      "integrity": "sha512-uW7fodD6pyW2FZNZnp/Z3hvWKeEW1Y8R1+1CnErE8cXFXzl5blBOoVB41CvMer6P6Q0S5FXDwcHgFd1Wj0U9zg==",
+      "dev": true
     },
     "node-timeout": {
       "version": "0.0.4",
@@ -7736,39 +9831,6 @@
         "options": "0.0.6"
       }
     },
-    "nomnom": {
-      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.5.2.tgz",
-      "integrity": "sha1-9DRUSKhTz71cDSYyDyR3qwUm/i8=",
-      "dev": true,
-      "requires": {
-        "colors": "0.5.x",
-        "underscore": "1.1.x"
-      },
-      "dependencies": {
-        "colors": {
-          "version": "0.5.1",
-          "resolved": "http://registry.npmjs.org/colors/-/colors-0.5.1.tgz",
-          "integrity": "sha1-fQAj6usVTo7p/Oddy5I9DtFmd3Q=",
-          "dev": true
-        },
-        "underscore": {
-          "version": "1.1.7",
-          "resolved": "http://registry.npmjs.org/underscore/-/underscore-1.1.7.tgz",
-          "integrity": "sha1-QLq4S60Z0jAJbo1u9ii/8FXYPbA=",
-          "dev": true
-        }
-      }
-    },
-    "nopt": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/nopt/-/nopt-4.0.1.tgz",
-      "integrity": "sha1-0NRoWv1UFRk8jHUFYC0NF81kR00=",
-      "requires": {
-        "abbrev": "1",
-        "osenv": "^0.1.4"
-      }
-    },
     "normalize-package-data": {
       "version": "2.4.0",
       "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz",
@@ -7807,20 +9869,6 @@
         "sort-keys": "^1.0.0"
       }
     },
-    "npm-bundled": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/npm-bundled/-/npm-bundled-1.0.5.tgz",
-      "integrity": "sha512-m/e6jgWu8/v5niCUKQi9qQl8QdeEduFA96xHDDzFGqly0OOjI7c+60KM/2sppfnUU9JJagf+zs+yGhqSOFj71g=="
-    },
-    "npm-packlist": {
-      "version": "1.1.12",
-      "resolved": "https://registry.npmjs.org/npm-packlist/-/npm-packlist-1.1.12.tgz",
-      "integrity": "sha512-WJKFOVMeAlsU/pjXuqVdzU0WfgtIBCupkEVwn+1Y0ERAbUfWw8R4GjgVbaKnUjRoD2FoQbHOCbOyT5Mbs9Lw4g==",
-      "requires": {
-        "ignore-walk": "^3.0.1",
-        "npm-bundled": "^1.0.1"
-      }
-    },
     "npmlog": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/npmlog/-/npmlog-4.1.2.tgz",
@@ -7886,15 +9934,42 @@
       }
     },
     "object-inspect": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.4.1.tgz",
-      "integrity": "sha512-wqdhLpfCUbEsoEwl3FXwGyv8ief1k/1aUdIPCqVnupM6e8l63BEJdiF/0swtn04/8p05tG/T0FrpTlfwvljOdw==",
+      "version": "1.10.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.10.3.tgz",
+      "integrity": "sha512-e5mCJlSH7poANfC8z8S9s9S2IN5/4Zb3aZ33f5s8YqoazCFzNLloLU8r5VCG+G7WoqLvAAZoVMcy3tp/3X0Plw==",
       "dev": true
     },
+    "object-is": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/object-is/-/object-is-1.1.4.tgz",
+      "integrity": "sha512-1ZvAZ4wlF7IyPVOcE1Omikt7UpaFlOQq0HlSti+ZvDH3UiD2brwGMwDbyV43jao2bKJ+4+WdPJHSd7kgzKYVqg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "dev": true,
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        }
+      }
+    },
     "object-keys": {
-      "version": "1.0.11",
-      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.11.tgz",
-      "integrity": "sha1-xUYBd4rVYPEULODgG8yotW0TQm0=",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
       "dev": true
     },
     "object-visit": {
@@ -7914,6 +9989,55 @@
         }
       }
     },
+    "object.assign": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/object.assign/-/object.assign-4.1.2.tgz",
+      "integrity": "sha512-ixT2L5THXsApyiUPYKmW+2EHpXXe5Ii3M+f4e+aJFAHao5amFRW6J0OO6c/LU8Be47utCx2GL89hxGB6XSmKuQ==",
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3",
+        "has-symbols": "^1.0.1",
+        "object-keys": "^1.1.1"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="
+        }
+      }
+    },
+    "object.entries": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/object.entries/-/object.entries-1.1.4.tgz",
+      "integrity": "sha512-h4LWKWE+wKQGhtMjZEBud7uLGhqyLwj8fpHOarZhD2uY3C9cRtk57VQ89ke3moByLXMedqs3XCHzyb4AmA2DjA==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.2"
+      }
+    },
+    "object.fromentries": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/object.fromentries/-/object.fromentries-2.0.4.tgz",
+      "integrity": "sha512-EsFBshs5RUUpQEY1D4q/m59kMfz4YJvxuNCJcv/jWwOJr34EaVnG11ZrZa0UHB3wnzV1wx8m58T4hQL8IuNXlQ==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.0-next.2",
+        "has": "^1.0.3"
+      }
+    },
     "object.omit": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz",
@@ -7924,6 +10048,34 @@
         "is-extendable": "^0.1.1"
       }
     },
+    "object.pick": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/object.pick/-/object.pick-1.3.0.tgz",
+      "integrity": "sha1-h6EKxMFpS9Lhy/U1kaZhQftd10c=",
+      "dev": true,
+      "requires": {
+        "isobject": "^3.0.1"
+      },
+      "dependencies": {
+        "isobject": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+          "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
+          "dev": true
+        }
+      }
+    },
+    "object.values": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/object.values/-/object.values-1.1.4.tgz",
+      "integrity": "sha512-TnGo7j4XSnKQoK3MfvkzqKCi0nVe/D9I9IjwTNYdb/fxYHpjrluHVOgw0AF6jrRFGMPHdfuidR09tIDiIvnaSg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.2"
+      }
+    },
     "once": {
       "version": "1.4.0",
       "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
@@ -7980,7 +10132,8 @@
     "os-homedir": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz",
-      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M="
+      "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=",
+      "dev": true
     },
     "os-locale": {
       "version": "1.4.0",
@@ -7993,16 +10146,8 @@
     "os-tmpdir": {
       "version": "1.0.2",
       "resolved": "http://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz",
-      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ="
-    },
-    "osenv": {
-      "version": "0.1.5",
-      "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.1.5.tgz",
-      "integrity": "sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==",
-      "requires": {
-        "os-homedir": "^1.0.0",
-        "os-tmpdir": "^1.0.0"
-      }
+      "integrity": "sha1-u+Z0BseaqFxc/sdm/lc0VV36EnQ=",
+      "dev": true
     },
     "output-file-sync": {
       "version": "1.1.2",
@@ -8016,10 +10161,13 @@
       }
     },
     "p-limit": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.1.0.tgz",
-      "integrity": "sha1-sH/y2aXYi+yAYDWJWiurZqJ5iLw=",
-      "dev": true
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz",
+      "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==",
+      "dev": true,
+      "requires": {
+        "p-try": "^1.0.0"
+      }
     },
     "p-locate": {
       "version": "2.0.0",
@@ -8030,12 +10178,35 @@
         "p-limit": "^1.1.0"
       }
     },
-    "pako": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.7.tgz",
-      "integrity": "sha512-3HNK5tW4x8o5mO8RuHZp3Ydw9icZXx0RANAOMzlMzx7LVXhMJ4mo3MOBpzyd7r/+RUu8BmndP47LXT+vzjtWcQ==",
+    "p-try": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz",
+      "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=",
       "dev": true
     },
+    "pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "dev": true
+    },
+    "parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dev": true,
+      "requires": {
+        "callsites": "^3.0.0"
+      },
+      "dependencies": {
+        "callsites": {
+          "version": "3.1.0",
+          "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+          "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+          "dev": true
+        }
+      }
+    },
     "parents": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz",
@@ -8046,22 +10217,22 @@
       }
     },
     "parse-asn1": {
-      "version": "5.1.1",
-      "resolved": "http://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz",
-      "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.6.tgz",
+      "integrity": "sha512-RnZRo1EPU6JBnra2vGHj0yhp6ebyjBZpmUCLHWiFhxlzvBCCpAuZ7elsBp1PVAbQN0/04VD/19rfzlBSwLstMw==",
       "dev": true,
       "requires": {
-        "asn1.js": "^4.0.0",
+        "asn1.js": "^5.2.0",
         "browserify-aes": "^1.0.0",
-        "create-hash": "^1.1.0",
         "evp_bytestokey": "^1.0.0",
-        "pbkdf2": "^3.0.3"
+        "pbkdf2": "^3.0.3",
+        "safe-buffer": "^5.1.1"
       }
     },
     "parse-entities": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-1.1.1.tgz",
-      "integrity": "sha1-gRLYhHExnyerrk1klksSL+ThuJA=",
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-1.2.2.tgz",
+      "integrity": "sha512-NzfpbxW/NPrzZ/yYSoQxyqUZMZXIdCfE0OIN4ESsnptHJECoUk3FZktxNuzQf4tjt5UEopnxpYJbvYuxIFDdsg==",
       "dev": true,
       "requires": {
         "character-entities": "^1.0.0",
@@ -8073,12 +10244,12 @@
       }
     },
     "parse-filepath": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.1.tgz",
-      "integrity": "sha1-FZ1hVdQ5BNFsEO9piRHaHpGWm3M=",
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/parse-filepath/-/parse-filepath-1.0.2.tgz",
+      "integrity": "sha1-pjISf1Oq89FYdvWHLz/6x2PWyJE=",
       "dev": true,
       "requires": {
-        "is-absolute": "^0.2.3",
+        "is-absolute": "^1.0.0",
         "map-cache": "^0.2.0",
         "path-root": "^0.1.1"
       }
@@ -8102,6 +10273,23 @@
         "is-dotfile": "^1.0.0",
         "is-extglob": "^1.0.0",
         "is-glob": "^2.0.0"
+      },
+      "dependencies": {
+        "is-extglob": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz",
+          "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=",
+          "dev": true
+        },
+        "is-glob": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz",
+          "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=",
+          "dev": true,
+          "requires": {
+            "is-extglob": "^1.0.0"
+          }
+        }
       }
     },
     "parse-json": {
@@ -8112,16 +10300,28 @@
         "error-ex": "^1.2.0"
       }
     },
-    "parse-url": {
-      "version": "1.3.11",
-      "resolved": "https://registry.npmjs.org/parse-url/-/parse-url-1.3.11.tgz",
-      "integrity": "sha1-V8FUKKuKiSsfQ4aWRccR0OFEtVQ=",
+    "parse-path": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/parse-path/-/parse-path-3.0.4.tgz",
+      "integrity": "sha512-wP70vtwv2DyrM2YoA7ZHVv4zIXa4P7dGgHlj+VwyXNDduLLVJ7NMY1zsFxjUUJ3DAwJLupGb1H5gMDDiNlJaxw==",
       "dev": true,
       "requires": {
         "is-ssh": "^1.3.0",
         "protocols": "^1.4.0"
       }
     },
+    "parse-url": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/parse-url/-/parse-url-3.0.2.tgz",
+      "integrity": "sha1-YCeHpwY6eV1yuGcxl1BecvYGEL4=",
+      "dev": true,
+      "requires": {
+        "is-ssh": "^1.3.0",
+        "normalize-url": "^1.9.1",
+        "parse-path": "^3.0.1",
+        "protocols": "^1.4.0"
+      }
+    },
     "pascalcase": {
       "version": "0.1.1",
       "resolved": "https://registry.npmjs.org/pascalcase/-/pascalcase-0.1.1.tgz",
@@ -8129,9 +10329,9 @@
       "dev": true
     },
     "path-browserify": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.1.tgz",
-      "integrity": "sha512-BapA40NHICOS+USX9SN4tyhq+A2RrN/Ws5F0Z5aMHDp98Fl86lX8Oti8B7uN93L4Ifv4fHOEA+pQw87gmMO/lQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
       "dev": true
     },
     "path-dirname": {
@@ -8166,9 +10366,9 @@
       "dev": true
     },
     "path-parse": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz",
-      "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+      "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
       "dev": true
     },
     "path-platform": {
@@ -8203,9 +10403,9 @@
       }
     },
     "pbkdf2": {
-      "version": "3.0.17",
-      "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.17.tgz",
-      "integrity": "sha512-U/il5MsrZp7mGg3mSQfn742na2T+1/vHDCG5/iTI3X9MKUuYUZVLQhyRsg06mCgDBTd57TxzgZt7P+fYfjRLtA==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.1.2.tgz",
+      "integrity": "sha512-iuh7L6jA7JEGu2WxDwtQP1ddOpaJNC4KlDEFfdQajSGgGPNi4OyDc2R7QnbY2bR9QjBVGwgvTdNJZoE7RaxUMA==",
       "dev": true,
       "requires": {
         "create-hash": "^1.1.2",
@@ -8221,6 +10421,13 @@
       "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=",
       "dev": true
     },
+    "picomatch": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.0.tgz",
+      "integrity": "sha512-lY1Q/PiJGC2zOv/z391WOTD+Z02bCgsFfvxoXXf6h7kv9o+WmsmzYqrAwY63sNgOxE4xEdq0WyUnXfKeBrSvYw==",
+      "dev": true,
+      "optional": true
+    },
     "pify": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz",
@@ -8251,6 +10458,12 @@
       "integrity": "sha1-TytxbKgRNKbLqkiJddI27LHMKEA=",
       "dev": true
     },
+    "posix-character-classes": {
+      "version": "0.1.1",
+      "resolved": "https://registry.npmjs.org/posix-character-classes/-/posix-character-classes-0.1.1.tgz",
+      "integrity": "sha1-AerA/jta9xoqbAL+q7jB/vfgDqs=",
+      "dev": true
+    },
     "postcss": {
       "version": "5.2.18",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-5.2.18.tgz",
@@ -8282,7 +10495,7 @@
     },
     "postcss-calc": {
       "version": "5.3.1",
-      "resolved": "http://registry.npmjs.org/postcss-calc/-/postcss-calc-5.3.1.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-calc/-/postcss-calc-5.3.1.tgz",
       "integrity": "sha1-d7rnypKK2FcW4v2kLyYb98HWW14=",
       "dev": true,
       "requires": {
@@ -8314,7 +10527,7 @@
     },
     "postcss-discard-comments": {
       "version": "2.0.4",
-      "resolved": "http://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-2.0.4.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-discard-comments/-/postcss-discard-comments-2.0.4.tgz",
       "integrity": "sha1-vv6J+v1bPazlzM5Rt2uBUUvgDj0=",
       "dev": true,
       "requires": {
@@ -8332,7 +10545,7 @@
     },
     "postcss-discard-empty": {
       "version": "2.1.0",
-      "resolved": "http://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-2.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-discard-empty/-/postcss-discard-empty-2.1.0.tgz",
       "integrity": "sha1-0rS9nVztXr2Nyt52QMfXzX9PkrU=",
       "dev": true,
       "requires": {
@@ -8341,7 +10554,7 @@
     },
     "postcss-discard-overridden": {
       "version": "0.1.1",
-      "resolved": "http://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-0.1.1.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-discard-overridden/-/postcss-discard-overridden-0.1.1.tgz",
       "integrity": "sha1-ix6vVU9ob7KIzYdMVWZ7CqNmjVg=",
       "dev": true,
       "requires": {
@@ -8350,7 +10563,7 @@
     },
     "postcss-discard-unused": {
       "version": "2.2.3",
-      "resolved": "http://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-2.2.3.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-discard-unused/-/postcss-discard-unused-2.2.3.tgz",
       "integrity": "sha1-vOMLLMWR/8Y0Mitfs0ZLbZNPRDM=",
       "dev": true,
       "requires": {
@@ -8369,7 +10582,7 @@
     },
     "postcss-merge-idents": {
       "version": "2.1.7",
-      "resolved": "http://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-2.1.7.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-merge-idents/-/postcss-merge-idents-2.1.7.tgz",
       "integrity": "sha1-TFUwMTwI4dWzu/PSu8dH4njuonA=",
       "dev": true,
       "requires": {
@@ -8398,6 +10611,18 @@
         "postcss": "^5.0.4",
         "postcss-selector-parser": "^2.2.2",
         "vendors": "^1.0.0"
+      },
+      "dependencies": {
+        "browserslist": {
+          "version": "1.7.7",
+          "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-1.7.7.tgz",
+          "integrity": "sha1-C9dnBCWL6CmyOYu1Dkti0aFmsLk=",
+          "dev": true,
+          "requires": {
+            "caniuse-db": "^1.0.30000639",
+            "electron-to-chromium": "^1.2.7"
+          }
+        }
       }
     },
     "postcss-message-helpers": {
@@ -8408,7 +10633,7 @@
     },
     "postcss-minify-font-values": {
       "version": "1.0.5",
-      "resolved": "http://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-1.0.5.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-minify-font-values/-/postcss-minify-font-values-1.0.5.tgz",
       "integrity": "sha1-S1jttWZB66fIR0qzUmyv17vey2k=",
       "dev": true,
       "requires": {
@@ -8419,7 +10644,7 @@
     },
     "postcss-minify-gradients": {
       "version": "1.0.5",
-      "resolved": "http://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-1.0.5.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-minify-gradients/-/postcss-minify-gradients-1.0.5.tgz",
       "integrity": "sha1-Xb2hE3NwP4PPtKPqOIHY11/15uE=",
       "dev": true,
       "requires": {
@@ -8429,7 +10654,7 @@
     },
     "postcss-minify-params": {
       "version": "1.2.2",
-      "resolved": "http://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-1.2.2.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-minify-params/-/postcss-minify-params-1.2.2.tgz",
       "integrity": "sha1-rSzgcTc7lDs9kwo/pZo1jCjW8fM=",
       "dev": true,
       "requires": {
@@ -8441,7 +10666,7 @@
     },
     "postcss-minify-selectors": {
       "version": "2.1.1",
-      "resolved": "http://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-2.1.1.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-minify-selectors/-/postcss-minify-selectors-2.1.1.tgz",
       "integrity": "sha1-ssapjAByz5G5MtGkllCBFDEXNb8=",
       "dev": true,
       "requires": {
@@ -8453,7 +10678,7 @@
     },
     "postcss-normalize-charset": {
       "version": "1.1.1",
-      "resolved": "http://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-1.1.1.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-charset/-/postcss-normalize-charset-1.1.1.tgz",
       "integrity": "sha1-757nEhLX/nWceO0WL2HtYrXLk/E=",
       "dev": true,
       "requires": {
@@ -8462,7 +10687,7 @@
     },
     "postcss-normalize-url": {
       "version": "3.0.8",
-      "resolved": "http://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-3.0.8.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-normalize-url/-/postcss-normalize-url-3.0.8.tgz",
       "integrity": "sha1-EI90s/L82viRov+j6kWSJ5/HgiI=",
       "dev": true,
       "requires": {
@@ -8484,7 +10709,7 @@
     },
     "postcss-reduce-idents": {
       "version": "2.4.0",
-      "resolved": "http://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-2.4.0.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-idents/-/postcss-reduce-idents-2.4.0.tgz",
       "integrity": "sha1-wsbSDMlYKE9qv75j92Cb9AkFmtM=",
       "dev": true,
       "requires": {
@@ -8494,7 +10719,7 @@
     },
     "postcss-reduce-initial": {
       "version": "1.0.1",
-      "resolved": "http://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-1.0.1.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-initial/-/postcss-reduce-initial-1.0.1.tgz",
       "integrity": "sha1-aPgGlfBF0IJjqHmtJA343WT2ROo=",
       "dev": true,
       "requires": {
@@ -8503,7 +10728,7 @@
     },
     "postcss-reduce-transforms": {
       "version": "1.0.4",
-      "resolved": "http://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-1.0.4.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-reduce-transforms/-/postcss-reduce-transforms-1.0.4.tgz",
       "integrity": "sha1-/3b02CEkN7McKYpC0uFEQCV3GuE=",
       "dev": true,
       "requires": {
@@ -8525,7 +10750,7 @@
     },
     "postcss-svgo": {
       "version": "2.1.6",
-      "resolved": "http://registry.npmjs.org/postcss-svgo/-/postcss-svgo-2.1.6.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-svgo/-/postcss-svgo-2.1.6.tgz",
       "integrity": "sha1-tt8YqmE7Zm4TPwittSGcJoSsEI0=",
       "dev": true,
       "requires": {
@@ -8537,7 +10762,7 @@
     },
     "postcss-unique-selectors": {
       "version": "2.0.2",
-      "resolved": "http://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-2.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-unique-selectors/-/postcss-unique-selectors-2.0.2.tgz",
       "integrity": "sha1-mB1X0p3csz57Hf4f1DuGSfkzyh0=",
       "dev": true,
       "requires": {
@@ -8554,7 +10779,7 @@
     },
     "postcss-zindex": {
       "version": "2.2.0",
-      "resolved": "http://registry.npmjs.org/postcss-zindex/-/postcss-zindex-2.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/postcss-zindex/-/postcss-zindex-2.2.0.tgz",
       "integrity": "sha1-0hCd3AVbka9n/EyzsCWUZjnSryI=",
       "dev": true,
       "requires": {
@@ -8582,9 +10807,9 @@
       "dev": true
     },
     "private": {
-      "version": "0.1.7",
-      "resolved": "https://registry.npmjs.org/private/-/private-0.1.7.tgz",
-      "integrity": "sha1-aM5eih7woju1cMwoU3tTMqumPvE=",
+      "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/private/-/private-0.1.8.tgz",
+      "integrity": "sha512-VvivMrbvd2nKkiG38qjULzlc+4Vx4wm/whI9pQD35YrARNnhxeiRktSOhSukRLFNlzg6Br/cJPet5J/u19r/mg==",
       "dev": true
     },
     "process": {
@@ -8614,13 +10839,25 @@
       }
     },
     "prop-types": {
-      "version": "15.6.2",
-      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.6.2.tgz",
-      "integrity": "sha512-3pboPvLiWD7dkI3qf3KbUe6hKFKa52w+AE0VCqECtf+QHAKgOL37tTaNCnuX1nAAQ4ZhyP+kYVKf8rLmJ/feDQ==",
+      "version": "15.7.2",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.7.2.tgz",
+      "integrity": "sha512-8QQikdH7//R2vurIJSutZ1smHYTcLpRWEOlHnzcWHmBYrOGUysKwSsrC89BCiFj3CbrfJ/nXFdJepOVrY1GCHQ==",
       "dev": true,
       "requires": {
-        "loose-envify": "^1.3.1",
-        "object-assign": "^4.1.1"
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.8.1"
+      },
+      "dependencies": {
+        "loose-envify": {
+          "version": "1.4.0",
+          "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+          "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+          "dev": true,
+          "requires": {
+            "js-tokens": "^3.0.0 || ^4.0.0"
+          }
+        }
       }
     },
     "property-information": {
@@ -8630,9 +10867,9 @@
       "dev": true
     },
     "protocols": {
-      "version": "1.4.6",
-      "resolved": "https://registry.npmjs.org/protocols/-/protocols-1.4.6.tgz",
-      "integrity": "sha1-+LsmPqG1/Xp2BNJri+Ob13Z4v4o=",
+      "version": "1.4.8",
+      "resolved": "https://registry.npmjs.org/protocols/-/protocols-1.4.8.tgz",
+      "integrity": "sha512-IgjKyaUSjsROSO8/D49Ab7hP8mJgTYcqApOqdPhLoPxAplXmkp+zRvsrSQjFn5by0rhm4VH0GAUELIPpx7B1yg==",
       "dev": true
     },
     "pseudomap": {
@@ -8642,9 +10879,9 @@
       "dev": true
     },
     "psl": {
-      "version": "1.1.29",
-      "resolved": "https://registry.npmjs.org/psl/-/psl-1.1.29.tgz",
-      "integrity": "sha512-AeUmQ0oLN02flVHXWh9sSJF7mcdFq0ppid/JkErufc3hGIV/AMa8Fo9VgDo/cT2jFdOWoFvHp90qqBH54W+gjQ==",
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/psl/-/psl-1.8.0.tgz",
+      "integrity": "sha512-RIdOzyoavK+hA18OGGWDqUTsCLhtA7IcZ/6NCs4fFJaHBDab+pDDmDIByWFRQJq2Cd7r1OoQxBGKOaztq+hjIQ==",
       "dev": true
     },
     "public-encrypt": {
@@ -8661,10 +10898,16 @@
         "safe-buffer": "^5.1.2"
       },
       "dependencies": {
+        "bn.js": {
+          "version": "4.12.0",
+          "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
+          "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+          "dev": true
+        },
         "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
           "dev": true
         }
       }
@@ -8682,10 +10925,13 @@
       "dev": true
     },
     "qs": {
-      "version": "6.4.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.4.0.tgz",
-      "integrity": "sha1-E+JtKK1rD/qpExLNO/cI7TUecjM=",
-      "dev": true
+      "version": "6.10.1",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.10.1.tgz",
+      "integrity": "sha512-M528Hph6wsSVOBiYUnGf+K/7w0hNshs/duGsNXPUCLH5XAqjEtiPGwNONLV0tBH8NoGb0mvD5JubnUTrujKDTg==",
+      "dev": true,
+      "requires": {
+        "side-channel": "^1.0.4"
+      }
     },
     "query-string": {
       "version": "4.3.4",
@@ -8718,14 +10964,6 @@
         "buffer-equal": "0.0.1",
         "minimist": "^1.1.3",
         "through2": "^2.0.0"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-          "dev": true
-        }
       }
     },
     "randomatic": {
@@ -8746,17 +10984,17 @@
           "dev": true
         },
         "kind-of": {
-          "version": "6.0.2",
-          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.2.tgz",
-          "integrity": "sha512-s5kLOcnH0XqDO+FvuaLX8DDjZ18CGFk7VygH40QoKPUQhW4e2rvM0rwUq0t8IQDOwYSeLK01U90OjzBTme2QqA==",
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
           "dev": true
         }
       }
     },
     "randombytes": {
-      "version": "2.0.6",
-      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz",
-      "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.1.0.tgz",
+      "integrity": "sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==",
       "dev": true,
       "requires": {
         "safe-buffer": "^5.1.0"
@@ -8790,28 +11028,10 @@
         }
       }
     },
-    "rc": {
-      "version": "1.2.8",
-      "resolved": "https://registry.npmjs.org/rc/-/rc-1.2.8.tgz",
-      "integrity": "sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==",
-      "requires": {
-        "deep-extend": "^0.6.0",
-        "ini": "~1.3.0",
-        "minimist": "^1.2.0",
-        "strip-json-comments": "~2.0.1"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ="
-        }
-      }
-    },
     "react": {
-      "version": "15.6.2",
-      "resolved": "https://registry.npmjs.org/react/-/react-15.6.2.tgz",
-      "integrity": "sha1-26BDSrQ5z+gvEI8PURZjkIF5qnI=",
+      "version": "15.7.0",
+      "resolved": "https://registry.npmjs.org/react/-/react-15.7.0.tgz",
+      "integrity": "sha512-5/MMRYmpmM0sMTHGLossnJCrmXQIiJilD6y3YN3TzAwGFj6zdnMtFv6xmi65PHKRV+pehIHpT7oy67Sr6s9AHA==",
       "dev": true,
       "requires": {
         "create-react-class": "^15.6.0",
@@ -8822,9 +11042,9 @@
       }
     },
     "react-dom": {
-      "version": "15.6.2",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-15.6.2.tgz",
-      "integrity": "sha1-Qc+t9pO3V/rycIRDodH9WgK+9zA=",
+      "version": "15.7.0",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-15.7.0.tgz",
+      "integrity": "sha512-mpjXqC2t1FuYsILOLCj0kg6pbg460byZkVA/80VtDmKU/pYmoTdHOtaMcTRIDiyXLz4sIur0cQ04nOC6iGndJg==",
       "dev": true,
       "requires": {
         "fbjs": "^0.8.9",
@@ -8833,6 +11053,12 @@
         "prop-types": "^15.5.10"
       }
     },
+    "react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+      "dev": true
+    },
     "read-only-stream": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz",
@@ -8876,15 +11102,14 @@
       }
     },
     "readdirp": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz",
-      "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=",
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.2.1.tgz",
+      "integrity": "sha512-1JU/8q+VgFZyxwrJ+SVIOsh+KywWGpds3NTqikiKpDMZWScmAYyKIgqkO+ARvNWJfXeXR1zxz7aHF4u4CyH6vQ==",
       "dev": true,
       "requires": {
-        "graceful-fs": "^4.1.2",
-        "minimatch": "^3.0.2",
-        "readable-stream": "^2.0.2",
-        "set-immediate-shim": "^1.0.1"
+        "graceful-fs": "^4.1.11",
+        "micromatch": "^3.1.10",
+        "readable-stream": "^2.0.2"
       }
     },
     "rechoir": {
@@ -8898,7 +11123,7 @@
     },
     "reduce-css-calc": {
       "version": "1.3.0",
-      "resolved": "http://registry.npmjs.org/reduce-css-calc/-/reduce-css-calc-1.3.0.tgz",
+      "resolved": "https://registry.npmjs.org/reduce-css-calc/-/reduce-css-calc-1.3.0.tgz",
       "integrity": "sha1-dHyRTgSWFKTJz7umKYca0dKSdxY=",
       "dev": true,
       "requires": {
@@ -8922,28 +11147,29 @@
       "dev": true
     },
     "reduce-function-call": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/reduce-function-call/-/reduce-function-call-1.0.2.tgz",
-      "integrity": "sha1-WiAL+S4ON3UXUv5FsKszD9S2vpk=",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/reduce-function-call/-/reduce-function-call-1.0.3.tgz",
+      "integrity": "sha512-Hl/tuV2VDgWgCSEeWMLwxLZqX7OK59eU1guxXsRKTAyeYimivsKdtcV4fu3r710tpG5GmDKDhQ0HSZLExnNmyQ==",
       "dev": true,
       "requires": {
-        "balanced-match": "^0.4.2"
-      },
-      "dependencies": {
-        "balanced-match": {
-          "version": "0.4.2",
-          "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-0.4.2.tgz",
-          "integrity": "sha1-yz8+PHMtwPAe5wtAPzAuYddwmDg=",
-          "dev": true
-        }
+        "balanced-match": "^1.0.0"
       }
     },
     "regenerate": {
-      "version": "1.3.3",
-      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.3.3.tgz",
-      "integrity": "sha512-jVpo1GadrDAK59t/0jRx5VxYWQEDkkEKi6+HjE3joFVLfDOh9Xrdh0dF1eSq+BI/SwvTQ44gSscJ8N5zYL61sg==",
+      "version": "1.4.2",
+      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz",
+      "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==",
       "dev": true
     },
+    "regenerate-unicode-properties": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-8.2.0.tgz",
+      "integrity": "sha512-F9DjY1vKLo/tPePDycuH3dn9H1OTPIkVD9Kz4LODu+F2C75mgjAJ7x/gwy6ZcSNRAAkhNlJSOHRe8k3p+K9WhA==",
+      "dev": true,
+      "requires": {
+        "regenerate": "^1.4.0"
+      }
+    },
     "regenerator-runtime": {
       "version": "0.11.0",
       "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.11.0.tgz",
@@ -8970,9 +11196,46 @@
         "is-equal-shallow": "^0.1.3"
       }
     },
+    "regex-not": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/regex-not/-/regex-not-1.0.2.tgz",
+      "integrity": "sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==",
+      "dev": true,
+      "requires": {
+        "extend-shallow": "^3.0.2",
+        "safe-regex": "^1.1.0"
+      }
+    },
+    "regexp.prototype.flags": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/regexp.prototype.flags/-/regexp.prototype.flags-1.3.1.tgz",
+      "integrity": "sha512-JiBdRBq91WlY7uRJ0ds7R+dU02i6LKi8r3BuQhNXn+kmeLN+EfHhfjqMRis1zJxnlu88hq/4dx0P2OP3APRTOA==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "dev": true,
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        }
+      }
+    },
     "regexpp": {
       "version": "1.1.0",
-      "resolved": "http://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz",
+      "resolved": "https://registry.npmjs.org/regexpp/-/regexpp-1.1.0.tgz",
       "integrity": "sha512-LOPw8FpgdQF9etWMaAfG/WRthIdXJGYp4mJ2Jgn/2lpkbod9jPn0t9UqN7AxBOKNfzRbYyVfgc7Vk4t/MpnXgw==",
       "dev": true
     },
@@ -9142,9 +11405,9 @@
       "dev": true
     },
     "request": {
-      "version": "2.88.0",
-      "resolved": "https://registry.npmjs.org/request/-/request-2.88.0.tgz",
-      "integrity": "sha512-NAqBSrijGLZdM0WZNsInLJpkJokL72XYjUpnB0iwsRgxh7dB6COrHnTBNwN0E+lHDAJzu7kLAkDeY08z2/A0hg==",
+      "version": "2.88.2",
+      "resolved": "https://registry.npmjs.org/request/-/request-2.88.2.tgz",
+      "integrity": "sha512-MsvtOrfG9ZcrOwAW+Qi+F6HbD0CWXEh9ou77uOb7FM2WPhwT7smM833PzanhJLsgXjN89Ir6V2PczXNnMpwKhw==",
       "dev": true,
       "requires": {
         "aws-sign2": "~0.7.0",
@@ -9154,7 +11417,7 @@
         "extend": "~3.0.2",
         "forever-agent": "~0.6.1",
         "form-data": "~2.3.2",
-        "har-validator": "~5.1.0",
+        "har-validator": "~5.1.3",
         "http-signature": "~1.2.0",
         "is-typedarray": "~1.0.0",
         "isstream": "~0.1.2",
@@ -9164,7 +11427,7 @@
         "performance-now": "^2.1.0",
         "qs": "~6.5.2",
         "safe-buffer": "^5.1.2",
-        "tough-cookie": "~2.4.3",
+        "tough-cookie": "~2.5.0",
         "tunnel-agent": "^0.6.0",
         "uuid": "^3.3.2"
       },
@@ -9182,9 +11445,9 @@
           "dev": true
         },
         "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
           "dev": true
         }
       }
@@ -9210,12 +11473,13 @@
       }
     },
     "resolve": {
-      "version": "1.4.0",
-      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.4.0.tgz",
-      "integrity": "sha512-aW7sVKPufyHqOmyyLzg/J+8606v5nevBgaliIlV7nUpVMsDnoBGV/cbSLNjZAg9q0Cfd/+easKVKQ8vOu8fn1Q==",
+      "version": "1.20.0",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.20.0.tgz",
+      "integrity": "sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==",
       "dev": true,
       "requires": {
-        "path-parse": "^1.0.5"
+        "is-core-module": "^2.2.0",
+        "path-parse": "^1.0.6"
       }
     },
     "resolve-from": {
@@ -9265,11 +11529,26 @@
       }
     },
     "rimraf": {
-      "version": "2.6.2",
-      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz",
-      "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==",
+      "version": "2.7.1",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz",
+      "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==",
       "requires": {
-        "glob": "^7.0.5"
+        "glob": "^7.1.3"
+      },
+      "dependencies": {
+        "glob": {
+          "version": "7.1.6",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+          "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        }
       }
     },
     "ripemd160": {
@@ -9341,9 +11620,9 @@
       }
     },
     "rxjs": {
-      "version": "6.3.3",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.3.3.tgz",
-      "integrity": "sha512-JTWmoY9tWCs7zvIk/CvRjhjGaOd+OVBM987mxFo+OW66cGpdKjZcpmc74ES1sB//7Kl/PAe8+wEakuhG4pcgOw==",
+      "version": "6.6.3",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.3.tgz",
+      "integrity": "sha512-trsQc+xYYXZ3urjOiJOuCOa5N3jAZ3eiSpQB5hIT8zGlL2QfnHLJ2r7GMkBGuIausdJN1OneaI6gQlsqNHHmZQ==",
       "dev": true,
       "requires": {
         "tslib": "^1.9.0"
@@ -9372,7 +11651,8 @@
     "safer-buffer": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
-      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true
     },
     "sax": {
       "version": "0.4.2",
@@ -9390,22 +11670,27 @@
       "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
       "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc="
     },
-    "set-immediate-shim": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz",
-      "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=",
-      "dev": true
-    },
     "set-value": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.0.tgz",
-      "integrity": "sha512-hw0yxk9GT/Hr5yJEYnHNKYXkIA8mVJgd9ditYZCe16ZczcaELYYcfvaXesNACk2O8O0nTiPQcQhGUQj8JLzeeg==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/set-value/-/set-value-2.0.1.tgz",
+      "integrity": "sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==",
       "dev": true,
       "requires": {
         "extend-shallow": "^2.0.1",
         "is-extendable": "^0.1.1",
         "is-plain-object": "^2.0.3",
         "split-string": "^3.0.1"
+      },
+      "dependencies": {
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        }
       }
     },
     "setimmediate": {
@@ -9416,7 +11701,7 @@
     },
     "sha.js": {
       "version": "2.4.11",
-      "resolved": "http://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
+      "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.11.tgz",
       "integrity": "sha512-QMEp5B7cftE7APOjk5Y6xgrbWu+WkLVQwk8JNjZ8nKRciZaByEW6MubieAiToS7+dwvrjGhH8jRXz3MVd0AYqQ==",
       "dev": true,
       "requires": {
@@ -9432,23 +11717,21 @@
     },
     "shasum": {
       "version": "1.0.2",
-      "resolved": "http://registry.npmjs.org/shasum/-/shasum-1.0.2.tgz",
+      "resolved": "https://registry.npmjs.org/shasum/-/shasum-1.0.2.tgz",
       "integrity": "sha1-5wEjENj0F/TetXEhUOVni4euVl8=",
       "dev": true,
       "requires": {
         "json-stable-stringify": "~0.0.0",
         "sha.js": "~2.4.4"
-      },
-      "dependencies": {
-        "json-stable-stringify": {
-          "version": "0.0.1",
-          "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-0.0.1.tgz",
-          "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=",
-          "dev": true,
-          "requires": {
-            "jsonify": "~0.0.0"
-          }
-        }
+      }
+    },
+    "shasum-object": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/shasum-object/-/shasum-object-1.0.0.tgz",
+      "integrity": "sha512-Iqo5rp/3xVi6M4YheapzZhhGPVs0yZwHj7wvwQ1B9z8H6zk+FEnI7y3Teq7qwnekfEhu8WmG2z0z4iWZaxLWVg==",
+      "dev": true,
+      "requires": {
+        "fast-safe-stringify": "^2.0.7"
       }
     },
     "shebang-command": {
@@ -9467,16 +11750,10 @@
       "dev": true
     },
     "shell-quote": {
-      "version": "1.6.1",
-      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.6.1.tgz",
-      "integrity": "sha1-9HgZSczkAmlxJ0MOo7PFR29IF2c=",
-      "dev": true,
-      "requires": {
-        "array-filter": "~0.0.0",
-        "array-map": "~0.0.0",
-        "array-reduce": "~0.0.0",
-        "jsonify": "~0.0.0"
-      }
+      "version": "1.7.2",
+      "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.7.2.tgz",
+      "integrity": "sha512-mRz/m/JVscCrkMyPqHc/bczi3OQHkLTqXHEFu0zDhK/qfv3UcOA4SVmRCLmos4bhjr9ekVQubj/R7waKapmiQg==",
+      "dev": true
     },
     "shelljs": {
       "version": "0.7.8",
@@ -9489,15 +11766,26 @@
         "rechoir": "^0.6.2"
       }
     },
+    "side-channel": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.4.tgz",
+      "integrity": "sha512-q5XPytqFEIKHkGdiMIrY10mvLRvnQh42/+GoBlFW3b2LXLE2xxJpZFdm94we0BaoV3RwJyGqg5wS7epxTv0Zvw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "get-intrinsic": "^1.0.2",
+        "object-inspect": "^1.9.0"
+      }
+    },
     "signal-exit": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz",
       "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0="
     },
     "simple-concat": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.0.tgz",
-      "integrity": "sha1-c0TLuLbib7J9ZrL8hvn21Zl1IcY=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/simple-concat/-/simple-concat-1.0.1.tgz",
+      "integrity": "sha512-cSFtAPtRhljv69IK0hTVZQ+OfE9nePi/rtJmw5UjHeVyVroEqJXP1sFztKUy1qU+xvz3u/sfYJLa947b7nAN2Q==",
       "dev": true
     },
     "simplicial-complex": {
@@ -9517,9 +11805,9 @@
       "dev": true
     },
     "slash": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz",
-      "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/slash/-/slash-2.0.0.tgz",
+      "integrity": "sha512-ZYKh3Wh2z1PpEXWr0MpSBZ0V6mZHAQfYevttO11c51CaWjGTaadiKZ+wVt1PbMlDV5qhMFslpZCemhwOK7C89A==",
       "dev": true
     },
     "slice-ansi": {
@@ -9539,6 +11827,105 @@
         }
       }
     },
+    "snapdragon": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/snapdragon/-/snapdragon-0.8.2.tgz",
+      "integrity": "sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==",
+      "dev": true,
+      "requires": {
+        "base": "^0.11.1",
+        "debug": "^2.2.0",
+        "define-property": "^0.2.5",
+        "extend-shallow": "^2.0.1",
+        "map-cache": "^0.2.2",
+        "source-map": "^0.5.6",
+        "source-map-resolve": "^0.5.0",
+        "use": "^3.1.0"
+      },
+      "dependencies": {
+        "define-property": {
+          "version": "0.2.5",
+          "resolved": "https://registry.npmjs.org/define-property/-/define-property-0.2.5.tgz",
+          "integrity": "sha1-w1se+RjsPJkPmlvFe+BKrOxcgRY=",
+          "dev": true,
+          "requires": {
+            "is-descriptor": "^0.1.0"
+          }
+        },
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        }
+      }
+    },
+    "snapdragon-node": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/snapdragon-node/-/snapdragon-node-2.1.1.tgz",
+      "integrity": "sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==",
+      "dev": true,
+      "requires": {
+        "define-property": "^1.0.0",
+        "isobject": "^3.0.0",
+        "snapdragon-util": "^3.0.1"
+      },
+      "dependencies": {
+        "define-property": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/define-property/-/define-property-1.0.0.tgz",
+          "integrity": "sha1-dp66rz9KY6rTr56NMEybvnm/sOY=",
+          "dev": true,
+          "requires": {
+            "is-descriptor": "^1.0.0"
+          }
+        },
+        "is-accessor-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-accessor-descriptor/-/is-accessor-descriptor-1.0.0.tgz",
+          "integrity": "sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-data-descriptor": {
+          "version": "1.0.0",
+          "resolved": "https://registry.npmjs.org/is-data-descriptor/-/is-data-descriptor-1.0.0.tgz",
+          "integrity": "sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==",
+          "dev": true,
+          "requires": {
+            "kind-of": "^6.0.0"
+          }
+        },
+        "is-descriptor": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/is-descriptor/-/is-descriptor-1.0.2.tgz",
+          "integrity": "sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==",
+          "dev": true,
+          "requires": {
+            "is-accessor-descriptor": "^1.0.0",
+            "is-data-descriptor": "^1.0.0",
+            "kind-of": "^6.0.2"
+          }
+        },
+        "isobject": {
+          "version": "3.0.1",
+          "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+          "integrity": "sha1-TkMekrEalzFjaqH5yNHMvP2reN8=",
+          "dev": true
+        },
+        "kind-of": {
+          "version": "6.0.3",
+          "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+          "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+          "dev": true
+        }
+      }
+    },
     "snapdragon-util": {
       "version": "3.0.1",
       "resolved": "https://registry.npmjs.org/snapdragon-util/-/snapdragon-util-3.0.1.tgz",
@@ -9564,12 +11951,12 @@
       "dev": true
     },
     "source-map-resolve": {
-      "version": "0.5.2",
-      "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz",
-      "integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==",
+      "version": "0.5.3",
+      "resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.3.tgz",
+      "integrity": "sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==",
       "dev": true,
       "requires": {
-        "atob": "^2.1.1",
+        "atob": "^2.1.2",
         "decode-uri-component": "^0.2.0",
         "resolve-url": "^0.2.1",
         "source-map-url": "^0.4.0",
@@ -9592,13 +11979,10 @@
       "dev": true
     },
     "space-separated-tokens": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.1.tgz",
-      "integrity": "sha1-lpW5355lrsGBHUw/nOUlILwvfk0=",
-      "dev": true,
-      "requires": {
-        "trim": "0.0.1"
-      }
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-1.1.5.tgz",
+      "integrity": "sha512-q/JSVd1Lptzhf5bkYm4ob4iWPjx0KiRe3sRFBNrVqbJkFaBm5vbbowy1mymoPNLRa52+oadOhJ+K49wsSeSjTA==",
+      "dev": true
     },
     "spdx-correct": {
       "version": "1.0.2",
@@ -9625,27 +12009,6 @@
       "dev": true,
       "requires": {
         "extend-shallow": "^3.0.0"
-      },
-      "dependencies": {
-        "extend-shallow": {
-          "version": "3.0.2",
-          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-3.0.2.tgz",
-          "integrity": "sha1-Jqcarwc7OfshJxcnRhMcJwQCjbg=",
-          "dev": true,
-          "requires": {
-            "assign-symbols": "^1.0.0",
-            "is-extendable": "^1.0.1"
-          }
-        },
-        "is-extendable": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-1.0.1.tgz",
-          "integrity": "sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==",
-          "dev": true,
-          "requires": {
-            "is-plain-object": "^2.0.4"
-          }
-        }
       }
     },
     "sprintf": {
@@ -9661,9 +12024,9 @@
       "dev": true
     },
     "sshpk": {
-      "version": "1.15.2",
-      "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.15.2.tgz",
-      "integrity": "sha512-Ra/OXQtuh0/enyl4ETZAfTaeksa6BXks5ZcjpSUNrjBr0DvrJKX+1fsKDPpT9TBXgHAFsa4510aNVgI8g/+SzA==",
+      "version": "1.16.1",
+      "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.16.1.tgz",
+      "integrity": "sha512-HXXqVUq7+pcKeLqqZj6mHFUMvXtOJt1uoUx09pFW6011inTMxqI8BA8PM95myrIyyKwdnzjdFjLiE6KBPVtJIg==",
       "dev": true,
       "requires": {
         "asn1": "~0.2.3",
@@ -9728,18 +12091,46 @@
       }
     },
     "state-toggle": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/state-toggle/-/state-toggle-1.0.0.tgz",
-      "integrity": "sha1-0g+aYWu08MO5i5GSLSW2QKorxCU=",
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/state-toggle/-/state-toggle-1.0.3.tgz",
+      "integrity": "sha512-d/5Z4/2iiCnHw6Xzghyhb+GcmF89bxwgXG60wjIiZaxnymbyOmI8Hk4VqHXiVVp6u2ysaskFfXg3ekCj4WNftQ==",
       "dev": true
     },
     "static-eval": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.0.tgz",
-      "integrity": "sha512-6flshd3F1Gwm+Ksxq463LtFd1liC77N/PX1FVVc3OzL3hAmo2fwHFbuArkcfi7s9rTNsLEhcRmXGFZhlgy40uw==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.1.0.tgz",
+      "integrity": "sha512-agtxZ/kWSsCkI5E4QifRwsaPs0P0JmZV6dkLz6ILYfFYQGn+5plctanRN+IC8dJRiFkyXHrwEE3W9Wmx67uDbw==",
       "dev": true,
       "requires": {
-        "escodegen": "^1.8.1"
+        "escodegen": "^1.11.1"
+      },
+      "dependencies": {
+        "escodegen": {
+          "version": "1.14.3",
+          "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.14.3.tgz",
+          "integrity": "sha512-qFcX0XJkdg+PB3xjZZG/wKSuT1PnQWx57+TVSjIMmILd2yC/6ByYElPwJnslDsuWuSAp4AwJGumarAAmJch5Kw==",
+          "dev": true,
+          "requires": {
+            "esprima": "^4.0.1",
+            "estraverse": "^4.2.0",
+            "esutils": "^2.0.2",
+            "optionator": "^0.8.1",
+            "source-map": "~0.6.1"
+          }
+        },
+        "esprima": {
+          "version": "4.0.1",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
+          "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
+          "dev": true
+        },
+        "source-map": {
+          "version": "0.6.1",
+          "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+          "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+          "dev": true,
+          "optional": true
+        }
       }
     },
     "static-extend": {
@@ -9786,13 +12177,19 @@
       },
       "dependencies": {
         "convert-source-map": {
-          "version": "1.6.0",
-          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.6.0.tgz",
-          "integrity": "sha512-eFu7XigvxdZ1ETfbgPBohgyQ/Z++C0eEhTor0qRwBw9unw+L0/6V8wkSuGgzdThkiS5lSpdptOQPD8Ak40a+7A==",
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.7.0.tgz",
+          "integrity": "sha512-4FJkXzKXEDB1snCFZlLP4gpC3JILicCpGbzG9f9G7tGqGCzETQ2hWPrcinA9oU4wtf2biUaEH5065UnMeR33oA==",
           "dev": true,
           "requires": {
             "safe-buffer": "~5.1.1"
           }
+        },
+        "object-inspect": {
+          "version": "1.4.1",
+          "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.4.1.tgz",
+          "integrity": "sha512-wqdhLpfCUbEsoEwl3FXwGyv8ief1k/1aUdIPCqVnupM6e8l63BEJdiF/0swtn04/8p05tG/T0FrpTlfwvljOdw==",
+          "dev": true
         }
       }
     },
@@ -9829,13 +12226,47 @@
       }
     },
     "stream-browserify": {
-      "version": "2.0.1",
-      "resolved": "http://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz",
-      "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-3.0.0.tgz",
+      "integrity": "sha512-H73RAHsVBapbim0tU2JwwOiXUj+fikfiaoYAKHF3VJfA0pe2BCzkhAHBlLG6REzE+2WNZcxOXjK7lkso+9euLA==",
       "dev": true,
       "requires": {
-        "inherits": "~2.0.1",
-        "readable-stream": "^2.0.2"
+        "inherits": "~2.0.4",
+        "readable-stream": "^3.5.0"
+      },
+      "dependencies": {
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+          "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
+          "dev": true,
+          "requires": {
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
+          }
+        },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
+        "string_decoder": {
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.2.0"
+          }
+        }
       }
     },
     "stream-combiner2": {
@@ -9846,74 +12277,64 @@
       "requires": {
         "duplexer2": "~0.1.0",
         "readable-stream": "^2.0.2"
-      },
-      "dependencies": {
-        "duplexer2": {
-          "version": "0.1.4",
-          "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz",
-          "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=",
-          "dev": true,
-          "requires": {
-            "readable-stream": "^2.0.2"
-          }
-        }
       }
     },
     "stream-http": {
-      "version": "2.8.3",
-      "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.8.3.tgz",
-      "integrity": "sha512-+TSkfINHDo4J+ZobQLWiMouQYB+UVYFttRA94FpEzzJ7ZdqcL4uUUQ7WkdkI4DSozGmgBUE/a47L+38PenXhUw==",
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-3.2.0.tgz",
+      "integrity": "sha512-Oq1bLqisTyK3TSCXpPbT4sdeYNdmyZJv1LxpEm2vu1ZhK89kSE5YXwZc3cWk0MagGaKriBh9mCFbVGtO+vY29A==",
       "dev": true,
       "requires": {
         "builtin-status-codes": "^3.0.0",
-        "inherits": "^2.0.1",
-        "readable-stream": "^2.3.6",
-        "to-arraybuffer": "^1.0.0",
-        "xtend": "^4.0.0"
+        "inherits": "^2.0.4",
+        "readable-stream": "^3.6.0",
+        "xtend": "^4.0.2"
       },
       "dependencies": {
-        "process-nextick-args": {
-          "version": "2.0.0",
-          "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz",
-          "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==",
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
           "dev": true
         },
         "readable-stream": {
-          "version": "2.3.6",
-          "resolved": "http://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz",
-          "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==",
+          "version": "3.6.0",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.0.tgz",
+          "integrity": "sha512-BViHy7LKeTz4oNnkcLJ+lVSL6vpiFeX6/d3oSH8zCW7UxP2onchk+vTGB143xuFjHS3deTgkKoXXymXqymiIdA==",
           "dev": true,
           "requires": {
-            "core-util-is": "~1.0.0",
-            "inherits": "~2.0.3",
-            "isarray": "~1.0.0",
-            "process-nextick-args": "~2.0.0",
-            "safe-buffer": "~5.1.1",
-            "string_decoder": "~1.1.1",
-            "util-deprecate": "~1.0.1"
+            "inherits": "^2.0.3",
+            "string_decoder": "^1.1.1",
+            "util-deprecate": "^1.0.1"
           }
         },
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        },
         "string_decoder": {
-          "version": "1.1.1",
-          "resolved": "http://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
-          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+          "version": "1.3.0",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+          "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
           "dev": true,
           "requires": {
-            "safe-buffer": "~5.1.0"
+            "safe-buffer": "~5.2.0"
           }
         }
       }
     },
     "stream-shift": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz",
-      "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.1.tgz",
+      "integrity": "sha512-AiisoFqQ0vbGcZgQPY1cdP2I76glaVA/RauYR4G4thNFgkTqr90yXTo4LYX60Jl+sIlPNHHdGSwo01AvbKUSVQ==",
       "dev": true
     },
     "stream-splicer": {
-      "version": "2.0.0",
-      "resolved": "http://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.0.tgz",
-      "integrity": "sha1-G2O+Q4oTPktnHMGTUZdgAXWRDYM=",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.1.tgz",
+      "integrity": "sha512-Xizh4/NPuYSyAXyT7g8IvdJ9HJpxIGL9PjyhtywCZvvP0OPIdqyrr4dMikeuvY8xahpdKEBlBTySe583totajg==",
       "dev": true,
       "requires": {
         "inherits": "^2.0.1",
@@ -9942,15 +12363,193 @@
         "strip-ansi": "^3.0.0"
       }
     },
-    "string.prototype.trim": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz",
-      "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=",
+    "string.prototype.matchall": {
+      "version": "4.0.5",
+      "resolved": "https://registry.npmjs.org/string.prototype.matchall/-/string.prototype.matchall-4.0.5.tgz",
+      "integrity": "sha512-Z5ZaXO0svs0M2xd/6By3qpeKpLKd9mO4v4q3oMEQrk8Ck4xOD5d5XeBOOjGrmVZZ/AHB1S0CgG4N5r1G9N3E2Q==",
       "dev": true,
       "requires": {
-        "define-properties": "^1.1.2",
-        "es-abstract": "^1.5.0",
-        "function-bind": "^1.0.2"
+        "call-bind": "^1.0.2",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.2",
+        "get-intrinsic": "^1.1.1",
+        "has-symbols": "^1.0.2",
+        "internal-slot": "^1.0.3",
+        "regexp.prototype.flags": "^1.3.1",
+        "side-channel": "^1.0.4"
+      },
+      "dependencies": {
+        "get-intrinsic": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.1.1.tgz",
+          "integrity": "sha512-kWZrnVM42QCiEA2Ig1bG8zjoIMOgxWwYCEeNdwY6Tv/cOSeGpcoX4pXHfKUxNKVoArnrEr2e9srnAxxGIraS9Q==",
+          "dev": true,
+          "requires": {
+            "function-bind": "^1.1.1",
+            "has": "^1.0.3",
+            "has-symbols": "^1.0.1"
+          }
+        },
+        "has-symbols": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
+          "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+          "dev": true
+        }
+      }
+    },
+    "string.prototype.trim": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.3.tgz",
+      "integrity": "sha512-16IL9pIBA5asNOSukPfxX2W68BaBvxyiRK16H3RA/lWW9BDosh+w7f+LhomPHpXJ82QEe7w7/rY/S1CV97raLg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3",
+        "es-abstract": "^1.18.0-next.1"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "dev": true,
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "es-abstract": {
+          "version": "1.18.0-next.2",
+          "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.18.0-next.2.tgz",
+          "integrity": "sha512-Ih4ZMFHEtZupnUh6497zEL4y2+w8+1ljnCyaTa+adcoafI1GOvMwFlDjBLfWR7y9VLfrjRJe9ocuHY1PSR9jjw==",
+          "dev": true,
+          "requires": {
+            "call-bind": "^1.0.2",
+            "es-to-primitive": "^1.2.1",
+            "function-bind": "^1.1.1",
+            "get-intrinsic": "^1.0.2",
+            "has": "^1.0.3",
+            "has-symbols": "^1.0.1",
+            "is-callable": "^1.2.2",
+            "is-negative-zero": "^2.0.1",
+            "is-regex": "^1.1.1",
+            "object-inspect": "^1.9.0",
+            "object-keys": "^1.1.1",
+            "object.assign": "^4.1.2",
+            "string.prototype.trimend": "^1.0.3",
+            "string.prototype.trimstart": "^1.0.3"
+          }
+        },
+        "es-to-primitive": {
+          "version": "1.2.1",
+          "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
+          "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
+          "dev": true,
+          "requires": {
+            "is-callable": "^1.1.4",
+            "is-date-object": "^1.0.1",
+            "is-symbol": "^1.0.2"
+          }
+        },
+        "has": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+          "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+          "dev": true,
+          "requires": {
+            "function-bind": "^1.1.1"
+          }
+        },
+        "is-callable": {
+          "version": "1.2.2",
+          "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.2.2.tgz",
+          "integrity": "sha512-dnMqspv5nU3LoewK2N/y7KLtxtakvTuaCsU9FU50/QDmdbHNy/4/JuRtMHqRU22o3q+W89YQndQEeCVwK+3qrA==",
+          "dev": true
+        },
+        "is-regex": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.1.1.tgz",
+          "integrity": "sha512-1+QkEcxiLlB7VEyFtyBg94e08OAsvq7FUBgApTq/w2ymCLyKJgDPsybBENVtA7XCQEgEXxKPonG+mvYRxh/LIg==",
+          "dev": true,
+          "requires": {
+            "has-symbols": "^1.0.1"
+          }
+        },
+        "is-symbol": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.3.tgz",
+          "integrity": "sha512-OwijhaRSgqvhm/0ZdAcXNZt9lYdKFpcRDT5ULUuYXPoT794UNOdU+gpT6Rzo7b4V2HUl/op6GqY894AZwv9faQ==",
+          "dev": true,
+          "requires": {
+            "has-symbols": "^1.0.1"
+          }
+        },
+        "object-inspect": {
+          "version": "1.9.0",
+          "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.9.0.tgz",
+          "integrity": "sha512-i3Bp9iTqwhaLZBxGkRfo5ZbE07BQRT7MGu8+nNgwW9ItGp1TzCTw2DLEoWwjClxBjOFI/hWljTAmYGCEwmtnOw==",
+          "dev": true
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        }
+      }
+    },
+    "string.prototype.trimend": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimend/-/string.prototype.trimend-1.0.3.tgz",
+      "integrity": "sha512-ayH0pB+uf0U28CtjlLvL7NaohvR1amUvVZk+y3DYb0Ey2PUV5zPkkKy9+U1ndVEIXO8hNg18eIv9Jntbii+dKw==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "dev": true,
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        }
+      }
+    },
+    "string.prototype.trimstart": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/string.prototype.trimstart/-/string.prototype.trimstart-1.0.3.tgz",
+      "integrity": "sha512-oBIBUy5lea5tt0ovtOFiEQaBkoBBkyJhZXzJYrSmDo5IUUqbOPvVezuRs/agBIdZ2p2Eo1FD6bD9USyBLfl3xg==",
+      "dev": true,
+      "requires": {
+        "call-bind": "^1.0.0",
+        "define-properties": "^1.1.3"
+      },
+      "dependencies": {
+        "define-properties": {
+          "version": "1.1.3",
+          "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.3.tgz",
+          "integrity": "sha512-3MqfYKj2lLzdMSf8ZIZE/V+Zuy+BgD6f164e8K2w7dgnpKArBDerGYpM46IYYcjnkdPNMjPk9A6VFB8+3SKlXQ==",
+          "dev": true,
+          "requires": {
+            "object-keys": "^1.0.12"
+          }
+        },
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        }
       }
     },
     "string_decoder": {
@@ -9962,9 +12561,9 @@
       }
     },
     "stringify-entities": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-1.3.1.tgz",
-      "integrity": "sha1-sVDsLXKsTBtfMktR+2soyc3/BYw=",
+      "version": "1.3.2",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-1.3.2.tgz",
+      "integrity": "sha512-nrBAQClJAPN2p+uGCVJRPIPakKeKWZ9GtBCmormE7pWOSlHat7+x5A8gx85M7HM5Dt0BP3pP5RhVW77WdbJJ3A==",
       "dev": true,
       "requires": {
         "character-entities-html4": "^1.0.0",
@@ -10002,7 +12601,8 @@
     "strip-json-comments": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
-      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo="
+      "integrity": "sha1-PFMZQukIwml8DsNEhYwobHygpgo=",
+      "dev": true
     },
     "subarg": {
       "version": "1.0.0",
@@ -10011,14 +12611,6 @@
       "dev": true,
       "requires": {
         "minimist": "^1.1.0"
-      },
-      "dependencies": {
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-          "dev": true
-        }
       }
     },
     "supports-color": {
@@ -10042,6 +12634,22 @@
         "whet.extend": "~0.9.9"
       },
       "dependencies": {
+        "esprima": {
+          "version": "2.7.3",
+          "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz",
+          "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=",
+          "dev": true
+        },
+        "js-yaml": {
+          "version": "3.7.0",
+          "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.7.0.tgz",
+          "integrity": "sha1-XJZ93YN6m/3KXy3oQlOr6KHAO4A=",
+          "dev": true,
+          "requires": {
+            "argparse": "^1.0.7",
+            "esprima": "^2.6.0"
+          }
+        },
         "sax": {
           "version": "1.2.4",
           "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz",
@@ -10052,7 +12660,7 @@
     },
     "syntax-error": {
       "version": "1.4.0",
-      "resolved": "http://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz",
+      "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz",
       "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==",
       "dev": true,
       "requires": {
@@ -10101,9 +12709,9 @@
           }
         },
         "chalk": {
-          "version": "2.4.1",
-          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz",
-          "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==",
+          "version": "2.4.2",
+          "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+          "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
           "dev": true,
           "requires": {
             "ansi-styles": "^3.2.1",
@@ -10111,12 +12719,6 @@
             "supports-color": "^5.3.0"
           }
         },
-        "has-flag": {
-          "version": "3.0.0",
-          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-          "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=",
-          "dev": true
-        },
         "is-fullwidth-code-point": {
           "version": "2.0.0",
           "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
@@ -10211,113 +12813,109 @@
       }
     },
     "tape": {
-      "version": "4.8.0",
-      "resolved": "https://registry.npmjs.org/tape/-/tape-4.8.0.tgz",
-      "integrity": "sha512-TWILfEnvO7I8mFe35d98F6T5fbLaEtbFTG/lxWvid8qDfFTxt19EBijWmB4j3+Hoh5TfHE2faWs73ua+EphuBA==",
+      "version": "4.13.3",
+      "resolved": "https://registry.npmjs.org/tape/-/tape-4.13.3.tgz",
+      "integrity": "sha512-0/Y20PwRIUkQcTCSi4AASs+OANZZwqPKaipGCEwp10dQMipVvSZwUUCi01Y/OklIGyHKFhIcjock+DKnBfLAFw==",
       "dev": true,
       "requires": {
-        "deep-equal": "~1.0.1",
+        "deep-equal": "~1.1.1",
         "defined": "~1.0.0",
-        "for-each": "~0.3.2",
-        "function-bind": "~1.1.0",
-        "glob": "~7.1.2",
-        "has": "~1.0.1",
-        "inherits": "~2.0.3",
-        "minimist": "~1.2.0",
-        "object-inspect": "~1.3.0",
-        "resolve": "~1.4.0",
+        "dotignore": "~0.1.2",
+        "for-each": "~0.3.3",
+        "function-bind": "~1.1.1",
+        "glob": "~7.1.6",
+        "has": "~1.0.3",
+        "inherits": "~2.0.4",
+        "is-regex": "~1.0.5",
+        "minimist": "~1.2.5",
+        "object-inspect": "~1.7.0",
+        "resolve": "~1.17.0",
         "resumer": "~0.0.0",
-        "string.prototype.trim": "~1.1.2",
+        "string.prototype.trim": "~1.2.1",
         "through": "~2.3.8"
       },
       "dependencies": {
         "deep-equal": {
-          "version": "1.0.1",
-          "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz",
-          "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=",
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.1.1.tgz",
+          "integrity": "sha512-yd9c5AdiqVcR+JjcwUQb9DkhJc8ngNr0MahEBGvDiJw8puWab2yZlh+nkasOnZP+EGTAP6rRp2JzJhJZzvNF8g==",
+          "dev": true,
+          "requires": {
+            "is-arguments": "^1.0.4",
+            "is-date-object": "^1.0.1",
+            "is-regex": "^1.0.4",
+            "object-is": "^1.0.1",
+            "object-keys": "^1.1.1",
+            "regexp.prototype.flags": "^1.2.0"
+          }
+        },
+        "glob": {
+          "version": "7.1.6",
+          "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz",
+          "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==",
+          "dev": true,
+          "requires": {
+            "fs.realpath": "^1.0.0",
+            "inflight": "^1.0.4",
+            "inherits": "2",
+            "minimatch": "^3.0.4",
+            "once": "^1.3.0",
+            "path-is-absolute": "^1.0.0"
+          }
+        },
+        "has": {
+          "version": "1.0.3",
+          "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz",
+          "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==",
+          "dev": true,
+          "requires": {
+            "function-bind": "^1.1.1"
+          }
+        },
+        "inherits": {
+          "version": "2.0.4",
+          "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+          "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
           "dev": true
         },
-        "minimist": {
-          "version": "1.2.0",
-          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
-          "dev": true
+        "is-regex": {
+          "version": "1.0.5",
+          "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.5.tgz",
+          "integrity": "sha512-vlKW17SNq44owv5AQR3Cq0bQPEb8+kF3UKZ2fiZNOWtztYE5i0CzCZxFDwO58qAOWtxdBRVO/V5Qin1wjCqFYQ==",
+          "dev": true,
+          "requires": {
+            "has": "^1.0.3"
+          }
         },
         "object-inspect": {
-          "version": "1.3.0",
-          "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.3.0.tgz",
-          "integrity": "sha512-OHHnLgLNXpM++GnJRyyhbr2bwl3pPVm4YvaraHrRvDt/N3r+s/gDVHciA7EJBTkijKXj61ssgSAikq1fb0IBRg==",
+          "version": "1.7.0",
+          "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.7.0.tgz",
+          "integrity": "sha512-a7pEHdh1xKIAgTySUGgLMx/xwDZskN1Ud6egYYN3EdRW4ZMPNEDUTF+hwy2LUC+Bl+SyLXANnwz/jyh/qutKUw==",
           "dev": true
-        }
-      }
-    },
-    "tar": {
-      "version": "4.4.8",
-      "resolved": "https://registry.npmjs.org/tar/-/tar-4.4.8.tgz",
-      "integrity": "sha512-LzHF64s5chPQQS0IYBn9IN5h3i98c12bo4NCO7e0sGM2llXQ3p2FGC5sdENN4cTW48O915Sh+x+EXx7XW96xYQ==",
-      "requires": {
-        "chownr": "^1.1.1",
-        "fs-minipass": "^1.2.5",
-        "minipass": "^2.3.4",
-        "minizlib": "^1.1.1",
-        "mkdirp": "^0.5.0",
-        "safe-buffer": "^5.1.2",
-        "yallist": "^3.0.2"
-      },
-      "dependencies": {
-        "safe-buffer": {
-          "version": "5.1.2",
-          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
-          "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g=="
         },
-        "yallist": {
-          "version": "3.0.3",
-          "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.0.3.tgz",
-          "integrity": "sha512-S+Zk8DEWE6oKpV+vI3qWkaK+jSbIK86pCwe2IF/xwIpQ8jEuxpw9NyaGjmp9+BoJv5FV2piqCDcoCtStppiq2A=="
-        }
-      }
-    },
-    "tar-pack": {
-      "version": "3.4.1",
-      "resolved": "https://registry.npmjs.org/tar-pack/-/tar-pack-3.4.1.tgz",
-      "integrity": "sha512-PPRybI9+jM5tjtCbN2cxmmRU7YmqT3Zv/UDy48tAh2XRkLa9bAORtSWLkVc13+GJF+cdTh1yEnHEk3cpTaL5Kg==",
-      "dev": true,
-      "optional": true,
-      "requires": {
-        "debug": "^2.2.0",
-        "fstream": "^1.0.10",
-        "fstream-ignore": "^1.0.5",
-        "once": "^1.3.3",
-        "readable-stream": "^2.1.4",
-        "rimraf": "^2.5.1",
-        "tar": "^2.2.1",
-        "uid-number": "^0.0.6"
-      },
-      "dependencies": {
-        "tar": {
-          "version": "2.2.1",
-          "resolved": "http://registry.npmjs.org/tar/-/tar-2.2.1.tgz",
-          "integrity": "sha1-jk0qJWwOIYXGsYrWlK7JaLg8sdE=",
+        "object-keys": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+          "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+          "dev": true
+        },
+        "path-parse": {
+          "version": "1.0.6",
+          "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.6.tgz",
+          "integrity": "sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==",
+          "dev": true
+        },
+        "resolve": {
+          "version": "1.17.0",
+          "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.17.0.tgz",
+          "integrity": "sha512-ic+7JYiV8Vi2yzQGFWOkiZD5Z9z7O2Zhm9XMaTxdJExKasieFCr+yXZ/WmXsckHiKl12ar0y6XiXDx3m4RHn1w==",
           "dev": true,
-          "optional": true,
           "requires": {
-            "block-stream": "*",
-            "fstream": "^1.0.2",
-            "inherits": "2"
+            "path-parse": "^1.0.6"
           }
         }
       }
     },
-    "test-value": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/test-value/-/test-value-3.0.0.tgz",
-      "integrity": "sha512-sVACdAWcZkSU9x7AOmJo5TqE+GyNJknHaHsMrR6ZnhjVlVN9Yx6FjHrsKZ3BjIpPCT68zYesPWkakrNupwfOTQ==",
-      "dev": true,
-      "requires": {
-        "array-back": "^2.0.0",
-        "typical": "^2.6.1"
-      }
-    },
     "text-table": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
@@ -10331,13 +12929,45 @@
       "dev": true
     },
     "through2": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz",
-      "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=",
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.5.tgz",
+      "integrity": "sha512-/mrRod8xqpA+IHSLyGCQ2s8SPHiCDEeQJSep1jqLYeEUClOFG2Qsh+4FU6G9VeqpZnGW/Su8LQGc4YKni5rYSQ==",
       "dev": true,
       "requires": {
-        "readable-stream": "^2.1.5",
+        "readable-stream": "~2.3.6",
         "xtend": "~4.0.1"
+      },
+      "dependencies": {
+        "process-nextick-args": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+          "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+          "dev": true
+        },
+        "readable-stream": {
+          "version": "2.3.7",
+          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.7.tgz",
+          "integrity": "sha512-Ebho8K4jIbHAxnuxi7o42OrZgF/ZTNcsZj6nRKyUmkhLFq8CHItp/fy6hQZuZmP/n3yZ9VBUbp4zz/mX8hmYPw==",
+          "dev": true,
+          "requires": {
+            "core-util-is": "~1.0.0",
+            "inherits": "~2.0.3",
+            "isarray": "~1.0.0",
+            "process-nextick-args": "~2.0.0",
+            "safe-buffer": "~5.1.1",
+            "string_decoder": "~1.1.1",
+            "util-deprecate": "~1.0.1"
+          }
+        },
+        "string_decoder": {
+          "version": "1.1.1",
+          "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+          "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+          "dev": true,
+          "requires": {
+            "safe-buffer": "~5.1.0"
+          }
+        }
       }
     },
     "through2-filter": {
@@ -10352,7 +12982,7 @@
     },
     "timers-browserify": {
       "version": "1.4.2",
-      "resolved": "http://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz",
+      "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz",
       "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=",
       "dev": true,
       "requires": {
@@ -10360,17 +12990,34 @@
       }
     },
     "tiny-lr": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/tiny-lr/-/tiny-lr-1.0.5.tgz",
-      "integrity": "sha512-YrxUSiMgOVh3PnAqtdAUQuUVEVRnqcRCxJ3BHrl/aaWV2fplKKB60oClM0GH2Gio2hcXvkxMUxsC/vXZrQePlg==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tiny-lr/-/tiny-lr-1.1.1.tgz",
+      "integrity": "sha512-44yhA3tsaRoMOjQQ+5v5mVdqef+kH6Qze9jTpqtVufgYjYt08zyZAwNwwVBj3i1rJMnR52IxOW0LK0vBzgAkuA==",
       "dev": true,
       "requires": {
         "body": "^5.1.0",
-        "debug": "~2.6.7",
+        "debug": "^3.1.0",
         "faye-websocket": "~0.10.0",
-        "livereload-js": "^2.2.2",
+        "livereload-js": "^2.3.0",
         "object-assign": "^4.1.0",
         "qs": "^6.4.0"
+      },
+      "dependencies": {
+        "debug": {
+          "version": "3.2.7",
+          "resolved": "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz",
+          "integrity": "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==",
+          "dev": true,
+          "requires": {
+            "ms": "^2.1.1"
+          }
+        },
+        "ms": {
+          "version": "2.1.3",
+          "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+          "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+          "dev": true
+        }
       }
     },
     "tmp": {
@@ -10389,14 +13036,19 @@
       "dev": true,
       "requires": {
         "extend-shallow": "^2.0.1"
+      },
+      "dependencies": {
+        "extend-shallow": {
+          "version": "2.0.1",
+          "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz",
+          "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=",
+          "dev": true,
+          "requires": {
+            "is-extendable": "^0.1.0"
+          }
+        }
       }
     },
-    "to-arraybuffer": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz",
-      "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=",
-      "dev": true
-    },
     "to-fast-properties": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/to-fast-properties/-/to-fast-properties-1.0.3.tgz",
@@ -10412,14 +13064,53 @@
         "kind-of": "^3.0.2"
       }
     },
-    "tough-cookie": {
-      "version": "2.4.3",
-      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.4.3.tgz",
-      "integrity": "sha512-Q5srk/4vDM54WJsJio3XNn6K2sCG+CQ8G5Wz6bZhRZoAe/+TxjWB/GlFAnYEbkYVlON9FMk/fE3h2RLpPXo4lQ==",
+    "to-regex": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/to-regex/-/to-regex-3.0.2.tgz",
+      "integrity": "sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==",
       "dev": true,
       "requires": {
-        "psl": "^1.1.24",
-        "punycode": "^1.4.1"
+        "define-property": "^2.0.2",
+        "extend-shallow": "^3.0.2",
+        "regex-not": "^1.0.2",
+        "safe-regex": "^1.1.0"
+      }
+    },
+    "to-regex-range": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
+      "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+      "dev": true,
+      "optional": true,
+      "requires": {
+        "is-number": "^7.0.0"
+      },
+      "dependencies": {
+        "is-number": {
+          "version": "7.0.0",
+          "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
+          "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+          "dev": true,
+          "optional": true
+        }
+      }
+    },
+    "tough-cookie": {
+      "version": "2.5.0",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.5.0.tgz",
+      "integrity": "sha512-nlLsUzgm1kfLXSXfRZMc1KLAugd4hqJHDTvc2hDIwS3mZAfMEuMbc03SujMF+GEcpaX/qboeycw6iO8JwVv2+g==",
+      "dev": true,
+      "requires": {
+        "psl": "^1.1.28",
+        "punycode": "^2.1.1"
+      },
+      "dependencies": {
+        "punycode": {
+          "version": "2.1.1",
+          "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.1.1.tgz",
+          "integrity": "sha512-XRsRjdf+j5ml+y/6GKHPZbrF/8p2Yga0JPtdqTIY2Xe5ohJPD9saDJJLPvp9+NSBprVvevdXZybnj2cv8OEd0A==",
+          "dev": true
+        }
       }
     },
     "transform-filter": {
@@ -10439,9 +13130,9 @@
       "dev": true
     },
     "trim-lines": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-1.1.0.tgz",
-      "integrity": "sha1-mSbQPt4Tuhj31CIiYx+wTHn/Jv4=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-1.1.3.tgz",
+      "integrity": "sha512-E0ZosSWYK2mkSu+KEtQ9/KqarVjA9HztOSX+9FDdNacRAq29RRV6ZQNgob3iuW8Htar9vAfEa6yyt5qBAHZDBA==",
       "dev": true
     },
     "trim-right": {
@@ -10451,27 +13142,21 @@
       "dev": true
     },
     "trim-trailing-lines": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-1.1.0.tgz",
-      "integrity": "sha1-eu+7eAjfnWafbaLkOMrIxGradoQ=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/trim-trailing-lines/-/trim-trailing-lines-1.1.4.tgz",
+      "integrity": "sha512-rjUWSqnfTNrjbB9NQWfPMH/xRK1deHeGsHoVfpxJ++XeYXE0d6B1En37AHfw3jtfTU7dzMzZL2jjpe8Qb5gLIQ==",
       "dev": true
     },
     "trough": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.1.tgz",
-      "integrity": "sha1-qf2LA5Swro//guBjOgo2zK1bX4Y=",
-      "dev": true
-    },
-    "tryit": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/tryit/-/tryit-1.0.3.tgz",
-      "integrity": "sha1-OTvnMKlEb9Hq1tpZoBQwjzbCics=",
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-1.0.5.tgz",
+      "integrity": "sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==",
       "dev": true
     },
     "tslib": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz",
-      "integrity": "sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==",
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
       "dev": true
     },
     "tty-browserify": {
@@ -10881,9 +13566,9 @@
       },
       "dependencies": {
         "minimist": {
-          "version": "1.2.0",
-          "resolved": "http://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz",
-          "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=",
+          "version": "1.2.5",
+          "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.5.tgz",
+          "integrity": "sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==",
           "dev": true
         }
       }
@@ -11067,58 +13752,16 @@
       "dev": true
     },
     "ua-parser-js": {
-      "version": "0.7.19",
-      "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.19.tgz",
-      "integrity": "sha512-T3PVJ6uz8i0HzPxOF9SWzWAlfN/DavlpQqepn22xgve/5QecC+XMCAtmUNnY7C9StehaV6exjUCI801lOI7QlQ==",
+      "version": "0.7.28",
+      "resolved": "https://registry.npmjs.org/ua-parser-js/-/ua-parser-js-0.7.28.tgz",
+      "integrity": "sha512-6Gurc1n//gjp9eQNXjD9O3M/sMwVtN5S8Lv9bvOYBfKfDNiIIhqiyi01vMBO45u4zkDE420w/e0se7Vs+sIg+g==",
       "dev": true
     },
     "uglify-js": {
-      "version": "2.8.29",
-      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz",
-      "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=",
-      "dev": true,
-      "requires": {
-        "source-map": "~0.5.1",
-        "uglify-to-browserify": "~1.0.0",
-        "yargs": "~3.10.0"
-      },
-      "dependencies": {
-        "camelcase": {
-          "version": "1.2.1",
-          "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz",
-          "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=",
-          "dev": true
-        },
-        "cliui": {
-          "version": "2.1.0",
-          "resolved": "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz",
-          "integrity": "sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE=",
-          "dev": true,
-          "requires": {
-            "center-align": "^0.1.1",
-            "right-align": "^0.1.1",
-            "wordwrap": "0.0.2"
-          }
-        },
-        "wordwrap": {
-          "version": "0.0.2",
-          "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz",
-          "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=",
-          "dev": true
-        },
-        "yargs": {
-          "version": "3.10.0",
-          "resolved": "http://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz",
-          "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=",
-          "dev": true,
-          "requires": {
-            "camelcase": "^1.0.2",
-            "cliui": "^2.1.0",
-            "decamelize": "^1.0.0",
-            "window-size": "0.1.0"
-          }
-        }
-      }
+      "version": "3.13.9",
+      "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.13.9.tgz",
+      "integrity": "sha512-wZbyTQ1w6Y7fHdt8sJnHfSIuWeDgk6B5rCb4E/AM6QNNPbOMIZph21PW5dRB3h7Df0GszN+t7RuUH6sWK5bF0g==",
+      "dev": true
     },
     "uglify-to-browserify": {
       "version": "1.0.2",
@@ -11127,19 +13770,32 @@
       "dev": true,
       "optional": true
     },
-    "uid-number": {
-      "version": "0.0.6",
-      "resolved": "https://registry.npmjs.org/uid-number/-/uid-number-0.0.6.tgz",
-      "integrity": "sha1-DqEOgDXo61uOREnwbaHHMGY7qoE=",
-      "dev": true,
-      "optional": true
-    },
     "umd": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.3.tgz",
       "integrity": "sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==",
       "dev": true
     },
+    "unbox-primitive": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.0.1.tgz",
+      "integrity": "sha512-tZU/3NqK3dA5gpE1KtyiJUrEB0lxnGkMFHptJ7q6ewdZ8s12QrODwNbhIJStmJkd1QDXa1NRA8aF2A1zk/Ypyw==",
+      "dev": true,
+      "requires": {
+        "function-bind": "^1.1.1",
+        "has-bigints": "^1.0.1",
+        "has-symbols": "^1.0.2",
+        "which-boxed-primitive": "^1.0.2"
+      },
+      "dependencies": {
+        "has-symbols": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.2.tgz",
+          "integrity": "sha512-chXa79rL/UC2KlX17jo3vRGz0azaWEx5tGqZg5pO3NUyEJVB17dMruQlzCCOfUvElghKcm5194+BCRvi2Rv/Gw==",
+          "dev": true
+        }
+      }
+    },
     "unc-path-regex": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/unc-path-regex/-/unc-path-regex-0.1.2.tgz",
@@ -11147,12 +13803,13 @@
       "dev": true
     },
     "undeclared-identifiers": {
-      "version": "1.1.2",
-      "resolved": "https://registry.npmjs.org/undeclared-identifiers/-/undeclared-identifiers-1.1.2.tgz",
-      "integrity": "sha512-13EaeocO4edF/3JKime9rD7oB6QI8llAGhgn5fKOPyfkJbRb6NFv9pYV6dFEmpa4uRjKeBqLZP8GpuzqHlKDMQ==",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/undeclared-identifiers/-/undeclared-identifiers-1.1.3.tgz",
+      "integrity": "sha512-pJOW4nxjlmfwKApE4zvxLScM/njmwj/DiUBv7EabwE4O8kRUy+HIwxQtZLBPll/jx1LJyBcqNfB3/cpv9EZwOw==",
       "dev": true,
       "requires": {
         "acorn-node": "^1.3.0",
+        "dash-ast": "^1.0.0",
         "get-assigned-identifiers": "^1.2.0",
         "simple-concat": "^1.0.0",
         "xtend": "^4.0.1"
@@ -11165,19 +13822,47 @@
       "dev": true
     },
     "unherit": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/unherit/-/unherit-1.1.0.tgz",
-      "integrity": "sha1-a5qu379z3xdWrZ4xbdmBiFhAzX0=",
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/unherit/-/unherit-1.1.3.tgz",
+      "integrity": "sha512-Ft16BJcnapDKp0+J/rqFC3Rrk6Y/Ng4nzsC028k2jdDII/rdZ7Wd3pPT/6+vIIxRagwRc9K0IUX0Ra4fKvw+WQ==",
       "dev": true,
       "requires": {
-        "inherits": "^2.0.1",
-        "xtend": "^4.0.1"
+        "inherits": "^2.0.0",
+        "xtend": "^4.0.0"
       }
     },
+    "unicode-canonical-property-names-ecmascript": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/unicode-canonical-property-names-ecmascript/-/unicode-canonical-property-names-ecmascript-1.0.4.tgz",
+      "integrity": "sha512-jDrNnXWHd4oHiTZnx/ZG7gtUTVp+gCcTTKr8L0HjlwphROEW3+Him+IpvC+xcJEFegapiMZyZe02CyuOnRmbnQ==",
+      "dev": true
+    },
+    "unicode-match-property-ecmascript": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-ecmascript/-/unicode-match-property-ecmascript-1.0.4.tgz",
+      "integrity": "sha512-L4Qoh15vTfntsn4P1zqnHulG0LdXgjSO035fEpdtp6YxXhMT51Q6vgM5lYdG/5X3MjS+k/Y9Xw4SFCY9IkR0rg==",
+      "dev": true,
+      "requires": {
+        "unicode-canonical-property-names-ecmascript": "^1.0.4",
+        "unicode-property-aliases-ecmascript": "^1.0.4"
+      }
+    },
+    "unicode-match-property-value-ecmascript": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/unicode-match-property-value-ecmascript/-/unicode-match-property-value-ecmascript-1.2.0.tgz",
+      "integrity": "sha512-wjuQHGQVofmSJv1uVISKLE5zO2rNGzM/KCYZch/QQvez7C1hUhBIuZ701fYXExuufJFMPhv2SyL8CyoIfMLbIQ==",
+      "dev": true
+    },
+    "unicode-property-aliases-ecmascript": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/unicode-property-aliases-ecmascript/-/unicode-property-aliases-ecmascript-1.1.0.tgz",
+      "integrity": "sha512-PqSoPh/pWetQ2phoj5RLiaqIk4kCNwoV3CI+LfGmWLKI3rE3kl1h59XpX2BjgDrmbxD9ARtQobPGU1SguCYuQg==",
+      "dev": true
+    },
     "unified": {
-      "version": "6.1.5",
-      "resolved": "https://registry.npmjs.org/unified/-/unified-6.1.5.tgz",
-      "integrity": "sha1-cWk3hyYhpjE15iztLzrGoGPG+4c=",
+      "version": "6.2.0",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-6.2.0.tgz",
+      "integrity": "sha512-1k+KPhlVtqmG99RaTbAv/usu85fcSRu3wY8X+vnsEhIxNP5VbVIDiXnLqyKIG+UMdyTg0ZX9EI6k2AfjJkHPtA==",
       "dev": true,
       "requires": {
         "bail": "^1.0.0",
@@ -11185,7 +13870,6 @@
         "is-plain-obj": "^1.1.0",
         "trough": "^1.0.0",
         "vfile": "^2.0.0",
-        "x-is-function": "^1.0.4",
         "x-is-string": "^0.1.0"
       }
     },
@@ -11196,29 +13880,15 @@
       "dev": true
     },
     "union-value": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.0.tgz",
-      "integrity": "sha1-XHHDTLW61dzr4+oM0IIHulqhrqQ=",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/union-value/-/union-value-1.0.1.tgz",
+      "integrity": "sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==",
       "dev": true,
       "requires": {
         "arr-union": "^3.1.0",
         "get-value": "^2.0.6",
         "is-extendable": "^0.1.1",
-        "set-value": "^0.4.3"
-      },
-      "dependencies": {
-        "set-value": {
-          "version": "0.4.3",
-          "resolved": "https://registry.npmjs.org/set-value/-/set-value-0.4.3.tgz",
-          "integrity": "sha1-fbCPnT0i3H945Trzw79GZuzfzPE=",
-          "dev": true,
-          "requires": {
-            "extend-shallow": "^2.0.1",
-            "is-extendable": "^0.1.1",
-            "is-plain-object": "^2.0.1",
-            "to-object-path": "^0.3.0"
-          }
-        }
+        "set-value": "^2.0.1"
       }
     },
     "uniq": {
@@ -11234,55 +13904,58 @@
       "dev": true
     },
     "unique-stream": {
-      "version": "2.2.1",
-      "resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-2.2.1.tgz",
-      "integrity": "sha1-WqADz76Uxf+GbE59ZouxxNuts2k=",
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/unique-stream/-/unique-stream-2.3.1.tgz",
+      "integrity": "sha512-2nY4TnBE70yoxHkDli7DMazpWiP7xMdCYqU2nBRO0UB+ZpEkGsSija7MvmvnZFUeC+mrgiUfcHSr3LmRFIg4+A==",
       "dev": true,
       "requires": {
-        "json-stable-stringify": "^1.0.0",
-        "through2-filter": "^2.0.0"
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "through2-filter": "^3.0.0"
+      },
+      "dependencies": {
+        "through2-filter": {
+          "version": "3.0.0",
+          "resolved": "https://registry.npmjs.org/through2-filter/-/through2-filter-3.0.0.tgz",
+          "integrity": "sha512-jaRjI2WxN3W1V8/FMZ9HKIBXixtiqs3SQSX4/YGIiP3gL6djW48VoZq9tDqeCWs3MT8YY5wb/zli8VW8snY1CA==",
+          "dev": true,
+          "requires": {
+            "through2": "~2.0.0",
+            "xtend": "~4.0.0"
+          }
+        }
       }
     },
     "unist-builder": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/unist-builder/-/unist-builder-1.0.2.tgz",
-      "integrity": "sha1-jDuZA+9kvPsRfdfPal2Y/Bs7J7Y=",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/unist-builder/-/unist-builder-1.0.4.tgz",
+      "integrity": "sha512-v6xbUPP7ILrT15fHGrNyHc1Xda8H3xVhP7/HAIotHOhVPjH5dCXA097C3Rry1Q2O+HbOLCao4hfPB+EYEjHgVg==",
       "dev": true,
       "requires": {
         "object-assign": "^4.1.0"
       }
     },
     "unist-util-generated": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.1.tgz",
-      "integrity": "sha1-mfFseJWayFTe58YVwpGSTIv03n8=",
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/unist-util-generated/-/unist-util-generated-1.1.6.tgz",
+      "integrity": "sha512-cln2Mm1/CZzN5ttGK7vkoGw+RZ8VcUH6BtGbq98DDtRGquAAOXig1mrBQYelOwMXYS8rK+vZDyyojSjp7JX+Lg==",
       "dev": true
     },
     "unist-util-is": {
-      "version": "2.1.1",
-      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-2.1.1.tgz",
-      "integrity": "sha1-DDEmKeP5YMZukx6BLT2A53AQlHs=",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-3.0.0.tgz",
+      "integrity": "sha512-sVZZX3+kspVNmLWBPAB6r+7D9ZgAFPNWm66f7YNb420RlQSbn+n8rG8dGZSkrER7ZIXGQYNm5pqC3v3HopH24A==",
       "dev": true
     },
-    "unist-util-modify-children": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/unist-util-modify-children/-/unist-util-modify-children-1.1.1.tgz",
-      "integrity": "sha1-ZtfmpEnm9nIguXarPLi166w55R0=",
-      "dev": true,
-      "requires": {
-        "array-iterate": "^1.0.0"
-      }
-    },
     "unist-util-position": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.0.0.tgz",
-      "integrity": "sha1-5uHgPu64HF4a/lU+jUrfvXwNj4I=",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-3.1.0.tgz",
+      "integrity": "sha512-w+PkwCbYSFw8vpgWD0v7zRCl1FpY3fjDSQ3/N/wNd9Ffa4gPi8+4keqt99N3XW6F99t/mUzp2xAhNmfKWp95QA==",
       "dev": true
     },
     "unist-util-remove-position": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-1.1.1.tgz",
-      "integrity": "sha1-WoXBVV/BugwQG4ZwfRXlD6TIcbs=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/unist-util-remove-position/-/unist-util-remove-position-1.1.4.tgz",
+      "integrity": "sha512-tLqd653ArxJIPnKII6LMZwH+mb5q+n/GtXQZo6S6csPRs5zB0u79Yw8ouR3wTw8wxvdJFhpP6Y7jorWdCgLO0A==",
       "dev": true,
       "requires": {
         "unist-util-visit": "^1.1.0"
@@ -11290,7 +13963,7 @@
     },
     "unist-util-select": {
       "version": "1.5.0",
-      "resolved": "http://registry.npmjs.org/unist-util-select/-/unist-util-select-1.5.0.tgz",
+      "resolved": "https://registry.npmjs.org/unist-util-select/-/unist-util-select-1.5.0.tgz",
       "integrity": "sha1-qTwr6MD2U4J4A7gTMa3sKqJM2TM=",
       "dev": true,
       "requires": {
@@ -11300,16 +13973,28 @@
       }
     },
     "unist-util-stringify-position": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-1.1.1.tgz",
-      "integrity": "sha1-PMvcU2ee7W7PN3fdf14yKcG2qjw=",
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-1.1.2.tgz",
+      "integrity": "sha512-pNCVrk64LZv1kElr0N1wPiHEUoXNVFERp+mlTg/s9R5Lwg87f9bM/3sQB99w+N9D/qnM9ar3+AKDBwo/gm/iQQ==",
       "dev": true
     },
     "unist-util-visit": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-1.1.3.tgz",
-      "integrity": "sha1-7CaOcxudJ3p5pbWqBkOZDkBdYAs=",
-      "dev": true
+      "version": "1.4.1",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-1.4.1.tgz",
+      "integrity": "sha512-AvGNk7Bb//EmJZyhtRUnNMEpId/AZ5Ph/KUpTI09WHQuDZHKovQ1oEv3mfmKpWKtoMzyMC4GLBm1Zy5k12fjIw==",
+      "dev": true,
+      "requires": {
+        "unist-util-visit-parents": "^2.0.0"
+      }
+    },
+    "unist-util-visit-parents": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-2.1.2.tgz",
+      "integrity": "sha512-DyN5vD4NE3aSeB+PXYNKxzGsfocxp6asDc2XXE3b0ekO2BaRUpBicbbUygfSvYfUz1IkmjFR1YF7dPklraMZ2g==",
+      "dev": true,
+      "requires": {
+        "unist-util-is": "^3.0.0"
+      }
     },
     "unset-value": {
       "version": "1.0.0",
@@ -11357,6 +14042,13 @@
         }
       }
     },
+    "upath": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/upath/-/upath-1.2.0.tgz",
+      "integrity": "sha512-aZwGpamFO61g3OlfT7OQCHqhGnW43ieH9WZeP7QxN/G/jS4jfqUkZxoryvJgVPEcrl5NL/ggHsSmLMHuH64Lhg==",
+      "dev": true,
+      "optional": true
+    },
     "upper-case": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/upper-case/-/upper-case-1.1.3.tgz",
@@ -11364,9 +14056,9 @@
       "dev": true
     },
     "uri-js": {
-      "version": "4.2.2",
-      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.2.2.tgz",
-      "integrity": "sha512-KY9Frmirql91X2Qgjry0Wd4Y+YTdrdZheS8TFwvkbLWf/G5KNJDCh6pKL5OZctEW4+0Baa5idK2ZQuELRwPznQ==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
       "dev": true,
       "requires": {
         "punycode": "^2.1.0"
@@ -11417,12 +14109,25 @@
       "dev": true
     },
     "util": {
-      "version": "0.10.4",
-      "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
-      "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==",
+      "version": "0.12.4",
+      "resolved": "https://registry.npmjs.org/util/-/util-0.12.4.tgz",
+      "integrity": "sha512-bxZ9qtSlGUWSOy9Qa9Xgk11kSslpuZwaxCg4sNIDj6FLucDab2JxnHwyNTCpHMtK1MjoQiWQ6DiUMZYbSrO+Sw==",
       "dev": true,
       "requires": {
-        "inherits": "2.0.3"
+        "inherits": "^2.0.3",
+        "is-arguments": "^1.0.4",
+        "is-generator-function": "^1.0.7",
+        "is-typed-array": "^1.1.3",
+        "safe-buffer": "^5.1.2",
+        "which-typed-array": "^1.1.2"
+      },
+      "dependencies": {
+        "safe-buffer": {
+          "version": "5.2.1",
+          "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+          "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+          "dev": true
+        }
       }
     },
     "util-deprecate": {
@@ -11431,9 +14136,9 @@
       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8="
     },
     "uuid": {
-      "version": "3.3.2",
-      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.3.2.tgz",
-      "integrity": "sha512-yXJmeNaw3DnnKAOKJE51sL/ZaYfWJRl1pK9dr19YFCu0ObS231AB1/LbqTKRAQ5kw8A90rA6fr4riOUpTZvQZA==",
+      "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.4.0.tgz",
+      "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A==",
       "dev": true
     },
     "v8flags": {
@@ -11461,9 +14166,9 @@
       }
     },
     "vendors": {
-      "version": "1.0.2",
-      "resolved": "https://registry.npmjs.org/vendors/-/vendors-1.0.2.tgz",
-      "integrity": "sha512-w/hry/368nO21AN9QljsaIhb9ZiZtZARoVH5f3CsFbawdLdayCgKRPup7CggujvySMxx0I91NOyxdVENohprLQ==",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/vendors/-/vendors-1.0.4.tgz",
+      "integrity": "sha512-/juG65kTL4Cy2su4P8HjtkTxk6VmJDiOPBufWniqQ6wknac6jNiXS9vU+hO3wgusiyqWlzTbVHi0dyJqRONg3w==",
       "dev": true
     },
     "verror": {
@@ -11478,22 +14183,32 @@
       }
     },
     "vfile": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/vfile/-/vfile-2.2.0.tgz",
-      "integrity": "sha1-zkek+zNZIrIz5TXbD32BIdj87U4=",
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-2.3.0.tgz",
+      "integrity": "sha512-ASt4mBUHcTpMKD/l5Q+WJXNtshlWxOogYyGYYrg4lt/vuRjC1EFQtlAofL5VmtVNIZJzWYFJjzGWZ0Gw8pzW1w==",
       "dev": true,
       "requires": {
         "is-buffer": "^1.1.4",
         "replace-ext": "1.0.0",
-        "unist-util-stringify-position": "^1.0.0"
+        "unist-util-stringify-position": "^1.0.0",
+        "vfile-message": "^1.0.0"
       }
     },
     "vfile-location": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-2.0.2.tgz",
-      "integrity": "sha1-02dcWch3SY5JK0dW/2Xkrxp1IlU=",
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/vfile-location/-/vfile-location-2.0.6.tgz",
+      "integrity": "sha512-sSFdyCP3G6Ka0CEmN83A2YCMKIieHx0EDaj5IDP4g1pa5ZJ4FJDvpO0WODLxo4LUX4oe52gmSCK7Jw4SBghqxA==",
       "dev": true
     },
+    "vfile-message": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-1.1.1.tgz",
+      "integrity": "sha512-1WmsopSGhWt5laNir+633LszXvZ+Z/lxveBf6yhGsqnQIhlhzooZae7zV6YVM1Sdkw68dtAW3ow0pOdPANugvA==",
+      "dev": true,
+      "requires": {
+        "unist-util-stringify-position": "^1.1.1"
+      }
+    },
     "vfile-reporter": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/vfile-reporter/-/vfile-reporter-4.0.0.tgz",
@@ -11507,10 +14222,16 @@
         "vfile-statistics": "^1.1.0"
       },
       "dependencies": {
+        "has-flag": {
+          "version": "2.0.0",
+          "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz",
+          "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=",
+          "dev": true
+        },
         "supports-color": {
-          "version": "4.4.0",
-          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.4.0.tgz",
-          "integrity": "sha512-rKC3+DyXWgK0ZLKwmRsrkyHVZAjNkfzeehuFWdGGcqGDTZFH73+RH6S/RDAAxl9GusSjZSUWYLmT9N5pzXFOXQ==",
+          "version": "4.5.0",
+          "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz",
+          "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=",
           "dev": true,
           "requires": {
             "has-flag": "^2.0.0"
@@ -11519,21 +14240,21 @@
       }
     },
     "vfile-sort": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-2.1.0.tgz",
-      "integrity": "sha1-SVAcnou+Wt/y6bOnZx7hseIMUhA=",
+      "version": "2.2.2",
+      "resolved": "https://registry.npmjs.org/vfile-sort/-/vfile-sort-2.2.2.tgz",
+      "integrity": "sha512-tAyUqD2R1l/7Rn7ixdGkhXLD3zsg+XLAeUDUhXearjfIcpL1Hcsj5hHpCoy/gvfK/Ws61+e972fm0F7up7hfYA==",
       "dev": true
     },
     "vfile-statistics": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-1.1.0.tgz",
-      "integrity": "sha1-AhBMYP3u0dEbH3OtZTMLdjSz2JU=",
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/vfile-statistics/-/vfile-statistics-1.1.4.tgz",
+      "integrity": "sha512-lXhElVO0Rq3frgPvFBwahmed3X03vjPF8OcjKMy8+F1xU/3Q3QU3tKEDp743SFtb74PdF0UWpxPvtOP0GCLheA==",
       "dev": true
     },
     "vinyl": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.1.0.tgz",
-      "integrity": "sha1-Ah+cLPlR1rk5lDyJ617lrdT9kkw=",
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/vinyl/-/vinyl-2.2.1.tgz",
+      "integrity": "sha512-LII3bXRFBZLlezoG5FfZVcXflZgWP/4dCwKtxd5ky9+LOtM4CS3bIRQsmR1KMnMW07jpE8fqR2lcxPZ+8sJIcw==",
       "dev": true,
       "requires": {
         "clone": "^2.1.1",
@@ -11542,14 +14263,6 @@
         "cloneable-readable": "^1.0.0",
         "remove-trailing-separator": "^1.0.1",
         "replace-ext": "^1.0.0"
-      },
-      "dependencies": {
-        "clone": {
-          "version": "2.1.1",
-          "resolved": "https://registry.npmjs.org/clone/-/clone-2.1.1.tgz",
-          "integrity": "sha1-0hfR6WERjjrJpLi7oyhVU79kfNs=",
-          "dev": true
-        }
       }
     },
     "vinyl-fs": {
@@ -11577,6 +14290,12 @@
         "vinyl": "^1.0.0"
       },
       "dependencies": {
+        "clone": {
+          "version": "1.0.4",
+          "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
+          "integrity": "sha1-2jCcwmPfFZlMaIypAheco8fNfH4=",
+          "dev": true
+        },
         "clone-stats": {
           "version": "0.0.1",
           "resolved": "https://registry.npmjs.org/clone-stats/-/clone-stats-0.0.1.tgz",
@@ -11609,25 +14328,26 @@
       "dev": true
     },
     "vm-browserify": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.0.tgz",
-      "integrity": "sha512-iq+S7vZJE60yejDYM0ek6zg308+UZsdtPExWP9VZoCFCz1zkJoXFnAX7aZfd/ZwrkidzdUZL0C/ryW+JwAiIGw==",
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-1.1.2.tgz",
+      "integrity": "sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==",
       "dev": true
     },
     "websocket-driver": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.0.tgz",
-      "integrity": "sha1-DK+dLXVdk67gSdS90NP+LMoqJOs=",
+      "version": "0.7.4",
+      "resolved": "https://registry.npmjs.org/websocket-driver/-/websocket-driver-0.7.4.tgz",
+      "integrity": "sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==",
       "dev": true,
       "requires": {
-        "http-parser-js": ">=0.4.0",
+        "http-parser-js": ">=0.5.1",
+        "safe-buffer": ">=5.1.0",
         "websocket-extensions": ">=0.1.1"
       }
     },
     "websocket-extensions": {
-      "version": "0.1.2",
-      "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.2.tgz",
-      "integrity": "sha1-Dhh4HeYpoYMIzhSBZQ9n/6JpOl0=",
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/websocket-extensions/-/websocket-extensions-0.1.4.tgz",
+      "integrity": "sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==",
       "dev": true
     },
     "wgs84": {
@@ -11637,9 +14357,9 @@
       "dev": true
     },
     "whatwg-fetch": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-3.0.0.tgz",
-      "integrity": "sha512-9GSJUgz1D4MfyKU7KRqwOjXCXTqWdFNvEr7eUBYchQiVc744mqK/MzXPNR2WsPkmkOa4ywfg8C2n8h+13Bey1Q==",
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/whatwg-fetch/-/whatwg-fetch-3.6.2.tgz",
+      "integrity": "sha512-bJlen0FcuU/0EMLrdbJ7zOnW6ITZLrZMIarMUVmdKtsGvZna8vxKYaexICWPfZ8qwf9fzNq+UEIZrnSaApt6RA==",
       "dev": true
     },
     "whet.extend": {
@@ -11656,11 +14376,39 @@
         "isexe": "^2.0.0"
       }
     },
+    "which-boxed-primitive": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/which-boxed-primitive/-/which-boxed-primitive-1.0.2.tgz",
+      "integrity": "sha512-bwZdv0AKLpplFY2KZRX6TvyuN7ojjr7lwkg6ml0roIy9YeuSr7JS372qlNW18UQYzgYK9ziGcerWqZOmEn9VNg==",
+      "dev": true,
+      "requires": {
+        "is-bigint": "^1.0.1",
+        "is-boolean-object": "^1.1.0",
+        "is-number-object": "^1.0.4",
+        "is-string": "^1.0.5",
+        "is-symbol": "^1.0.3"
+      }
+    },
     "which-module": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/which-module/-/which-module-1.0.0.tgz",
       "integrity": "sha1-u6Y8qGGUiZT/MHc2CJ47lgJsKk8="
     },
+    "which-typed-array": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.4.tgz",
+      "integrity": "sha512-49E0SpUe90cjpoc7BOJwyPHRqSAd12c10Qm2amdEZrJPCY2NDxaW01zHITrem+rnETY3dwrbH3UUrUwagfCYDA==",
+      "dev": true,
+      "requires": {
+        "available-typed-arrays": "^1.0.2",
+        "call-bind": "^1.0.0",
+        "es-abstract": "^1.18.0-next.1",
+        "foreach": "^2.0.5",
+        "function-bind": "^1.1.1",
+        "has-symbols": "^1.0.1",
+        "is-typed-array": "^1.1.3"
+      }
+    },
     "wide-align": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz",
@@ -11714,12 +14462,6 @@
         "mkdirp": "^0.5.1"
       }
     },
-    "x-is-function": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/x-is-function/-/x-is-function-1.0.4.tgz",
-      "integrity": "sha1-XSlNw9Joy90GJYDgxd93o5HR+h4=",
-      "dev": true
-    },
     "x-is-string": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/x-is-string/-/x-is-string-0.1.0.tgz",
@@ -11745,9 +14487,9 @@
       }
     },
     "xtend": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz",
-      "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=",
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.2.tgz",
+      "integrity": "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==",
       "dev": true
     },
     "y18n": {
@@ -11762,9 +14504,9 @@
       "dev": true
     },
     "yargs": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.0.tgz",
-      "integrity": "sha1-a6MY6xaWFyf10oT46gA+jWFU0Mg=",
+      "version": "7.1.1",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-7.1.1.tgz",
+      "integrity": "sha512-huO4Fr1f9PmiJJdll5kwoS2e4GqzGSsMT3PPMpOwoVkOK8ckqAewMTZyA6LXVQWflleb/Z8oPBEvNsMft0XE+g==",
       "requires": {
         "camelcase": "^3.0.0",
         "cliui": "^3.2.0",
@@ -11778,15 +14520,16 @@
         "string-width": "^1.0.2",
         "which-module": "^1.0.0",
         "y18n": "^3.2.1",
-        "yargs-parser": "^5.0.0"
+        "yargs-parser": "5.0.0-security.0"
       }
     },
     "yargs-parser": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.0.tgz",
-      "integrity": "sha1-J17PDX/+Bcd+ZOfIbkzZS/DhIoo=",
+      "version": "5.0.0-security.0",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-5.0.0-security.0.tgz",
+      "integrity": "sha512-T69y4Ps64LNesYxeYGYPvfoMTt/7y1XtfpIslUeK4um+9Hu7hlGoRtaDLvdXb7+/tfq4opVa2HRY5xGip022rQ==",
       "requires": {
-        "camelcase": "^3.0.0"
+        "camelcase": "^3.0.0",
+        "object.assign": "^4.1.0"
       }
     }
   }
diff --git a/package.json b/package.json
index 43634204a..ccb56bf34 100644
--- a/package.json
+++ b/package.json
@@ -1,14 +1,15 @@
 {
   "name": "osrm",
-  "version": "5.24.0-unreleased",
+  "version": "5.27.0-unreleased",
   "private": false,
   "description": "The Open Source Routing Machine is a high performance routing engine written in C++14 designed to run on OpenStreetMap data.",
   "dependencies": {
-    "mkdirp": "^0.5.1",
-    "nan": "^2.14.1",
-    "node-cmake": "^2.3.2",
-    "node-pre-gyp": "^0.12.0",
-    "rimraf": "^2.5.4"
+    "@mapbox/node-pre-gyp": "^1.0.1",
+    "cheap-ruler": "^3.0.2",
+    "mkdirp": "^0.5.5",
+    "nan": "^2.14.2",
+    "node-cmake": "^2.5.1",
+    "rimraf": "^2.7.1"
   },
   "browserify": {
     "transform": [
@@ -38,40 +39,47 @@
     "node": ">=4.0.0"
   },
   "devDependencies": {
-    "ansi-escape-sequences": "^4.0.0",
+    "@babel/cli": "^7.14.5",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.5",
+    "@babel/preset-react": "^7.14.5",
+    "acorn": "^8.4.0",
+    "ansi-escape-sequences": "^5.1.2",
     "aws-sdk": "~2.0.31",
     "babel-plugin-transform-class-properties": "^6.24.1",
+    "babelify": "^10.0.0",
+    "browserify": "^17.0.0",
     "chalk": "^1.1.3",
-    "command-line-args": "^5.0.2",
+    "command-line-args": "^5.1.1",
     "command-line-usage": "^5.0.4",
     "csv-stringify": "^3.0.0",
     "cucumber": "^1.2.1",
     "d3-queue": "^2.0.3",
     "docbox": "^1.0.11",
-    "documentation": "^4.0.0-rc.1",
-    "eslint": "^5.10.0",
+    "documentation": "^4.0.0",
+    "eslint": "^5.16.0",
     "faucet": "^0.0.1",
-    "jsonpath": "^1.0.0",
+    "jsonpath": "^1.1.0",
     "node-timeout": "0.0.4",
     "polyline": "^0.2.0",
-    "request": "^2.88.0",
-    "tape": "^4.7.0",
+    "request": "^2.88.2",
+    "tape": "^4.13.3",
     "turf": "^3.0.14",
+    "uglify-js": "^3.13.9",
     "xmlbuilder": "^4.2.1"
   },
   "bundleDependencies": [
     "mkdirp",
     "nan",
     "node-cmake",
-    "node-pre-gyp",
     "rimraf"
   ],
   "main": "lib/index.js",
   "binary": {
     "module_name": "node_osrm",
     "module_path": "./lib/binding/",
-    "host": "https://mapbox-node-binary.s3.amazonaws.com",
-    "remote_path": "./{name}/v{version}/{configuration}/",
-    "package_name": "{node_abi}-{platform}-{arch}.tar.gz"
+    "host": "https://github.com",
+    "remote_path": "./Project-OSRM/osrm-backend/releases/download/v{version}/",
+    "package_name": "{module_name}-v{version}-{node_abi}-{platform}-{arch}-{configuration}.tar.gz"
   }
 }
diff --git a/profiles/bicycle.lua b/profiles/bicycle.lua
index 223954f02..58740db48 100644
--- a/profiles/bicycle.lua
+++ b/profiles/bicycle.lua
@@ -543,21 +543,6 @@ function safety_handler(profile,way,result,data)
     if result.duration > 0 then
       result.weight = result.duration / forward_penalty
     end
-
-    if data.highway == "bicycle" then
-      safety_bonus = safety_bonus + 0.2
-      if result.forward_speed > 0 then
-        -- convert from km/h to m/s
-        result.forward_rate = result.forward_speed / 3.6 * safety_bonus
-      end
-      if result.backward_speed > 0 then
-        -- convert from km/h to m/s
-        result.backward_rate = result.backward_speed / 3.6 * safety_bonus
-      end
-      if result.duration > 0 then
-        result.weight = result.duration / safety_bonus
-      end
-    end
   end
 end
 
diff --git a/profiles/car.lua b/profiles/car.lua
index e034e7828..fddae14d7 100644
--- a/profiles/car.lua
+++ b/profiles/car.lua
@@ -270,6 +270,8 @@ function setup()
       ["at:rural"] = 100,
       ["at:trunk"] = 100,
       ["be:motorway"] = 120,
+      ["be-bru:rural"] = 70,
+      ["be-bru:urban"] = 30,
       ["be-vlg:rural"] = 70,
       ["by:urban"] = 60,
       ["by:motorway"] = 110,
@@ -340,7 +342,18 @@ function process_node(profile, node, result, relations)
       local bollard = node:get_value_by_key("bollard")
       local rising_bollard = bollard and "rising" == bollard
 
-      if not profile.barrier_whitelist[barrier] and not rising_bollard or restricted_by_height then
+      -- make an exception for lowered/flat barrier=kerb
+      -- and incorrect tagging of highway crossing kerb as highway barrier
+      local kerb = node:get_value_by_key("kerb")
+      local highway = node:get_value_by_key("highway")
+      local flat_kerb = kerb and ("lowered" == kerb or "flush" == kerb)
+      local highway_crossing_kerb = barrier == "kerb" and highway and highway == "crossing"
+
+      if not profile.barrier_whitelist[barrier]
+                and not rising_bollard
+                and not flat_kerb
+                and not highway_crossing_kerb
+                or restricted_by_height then
         result.barrier = true
       end
     end
@@ -419,8 +432,8 @@ function process_way(profile, way, result, relations)
 
     -- compute speed taking into account way type, maxspeed tags, etc.
     WayHandlers.speed,
-    WayHandlers.surface,
     WayHandlers.maxspeed,
+    WayHandlers.surface,
     WayHandlers.penalties,
 
     -- compute class labels
diff --git a/profiles/debug_way.lua b/profiles/debug_way.lua
new file mode 100644
index 000000000..7c577e9a0
--- /dev/null
+++ b/profiles/debug_way.lua
@@ -0,0 +1,44 @@
+--
+-- Fetch a way from the OpenStreetMap API and run the given profile over it.
+--
+-- You'll need to install xml2lua first (may require admin privileges):
+--    > luarocks install xml2lua
+--
+-- You may also need to install luasec and luasocket if you don't have them already.
+--
+-- Then to test way 2606296 using the foot profile:
+--    > lua debug_way.lua foot 2606296
+--
+
+-- initialise libraries
+local pprint = require('lib/pprint')
+local Debug = require('lib/profile_debugger')
+local xml2lua = require('xml2lua')
+local handler = require('xmlhandler.tree')
+local https = require('ssl.https')
+
+-- load the profile
+Debug.load_profile(arg[1])
+
+-- load way from the OSM API
+local url = 'https://www.openstreetmap.org/api/0.6/way/'..arg[2]
+local body, statusCode, headers, statusText = https.request(url)
+
+-- parse way tags
+local parser = xml2lua.parser(handler)
+parser:parse(body)
+
+-- convert XML-flavoured table to a simple k/v table
+local way = {}
+for i, p in pairs(handler.root.osm.way.tag) do
+  way[p._attr.k] = p._attr.v
+end
+
+-- call the way function
+local result = {}
+Debug.process_way(way,result)
+
+-- print input and output
+pprint(way)
+print("=>")
+pprint(result)
diff --git a/profiles/lib/measure.lua b/profiles/lib/measure.lua
index d1f00c601..0583b3345 100644
--- a/profiles/lib/measure.lua
+++ b/profiles/lib/measure.lua
@@ -72,7 +72,7 @@ function Measure.get_max_height(raw_value, element)
   if raw_value then
     if height_non_numerical_values[raw_value] then
       if element then
-        return element:get_location_tag('maxheight') or default_maxheight
+        return tonumber(element:get_location_tag('maxheight')) or default_maxheight
       else
         return default_maxheight
       end
diff --git a/profiles/lib/profile_debugger.lua b/profiles/lib/profile_debugger.lua
index 15f835609..276850160 100644
--- a/profiles/lib/profile_debugger.lua
+++ b/profiles/lib/profile_debugger.lua
@@ -52,7 +52,7 @@ end
 function canonicalizeStringList(str)
   return str
 end
- 
+
  
  
 -- debug helper
@@ -123,11 +123,14 @@ function Debug.process_way(way,result)
   result.forward_classes = {}
   result.backward_classes = {}
   
-  -- intercept tag function normally provided via C++
+  -- intercept tag functions normally provided via C++
   function way:get_value_by_key(k)
     Debug.register_tag_fetch(k)
     return self[k]
   end
+  function way:get_location_tag(k)
+    return nil
+  end
   
   -- reset tag counts
   Debug:reset_tag_fetch_counts()
diff --git a/scripts/travis/before_install.armhf.sh b/scripts/ci/before_install.armhf.sh
similarity index 100%
rename from scripts/travis/before_install.armhf.sh
rename to scripts/ci/before_install.armhf.sh
diff --git a/scripts/travis/before_install.i686.sh b/scripts/ci/before_install.i686.sh
similarity index 88%
rename from scripts/travis/before_install.i686.sh
rename to scripts/ci/before_install.i686.sh
index ce0e23a2d..a7b8c5f61 100644
--- a/scripts/travis/before_install.i686.sh
+++ b/scripts/ci/before_install.i686.sh
@@ -3,4 +3,4 @@
 sudo dpkg --add-architecture i386
 sudo add-apt-repository --yes ppa:ubuntu-toolchain-r/test && ( sudo apt-get update -qq --yes || true )
 
-sudo apt-get install -qq --yes --force-yes g++-7-multilib libxml2-dev:i386 libexpat1-dev:i386 libzip-dev:i386 libbz2-dev:i386 libtbb-dev:i386 lua5.2:i386 liblua5.2-dev:i386 libboost-date-time-dev:i386 libboost-filesystem-dev:i386 libboost-iostreams-dev:i386 libboost-program-options-dev:i386 libboost-regex-dev:i386 libboost-system-dev:i386 libboost-thread-dev:i386 libboost-test-dev:i386
+sudo apt-get install -qq --yes --force-yes g++-9-multilib libxml2-dev:i386 libexpat1-dev:i386 libzip-dev:i386 libbz2-dev:i386 libtbb-dev:i386 lua5.2:i386 liblua5.2-dev:i386 libboost-date-time-dev:i386 libboost-filesystem-dev:i386 libboost-iostreams-dev:i386 libboost-program-options-dev:i386 libboost-regex-dev:i386 libboost-system-dev:i386 libboost-thread-dev:i386 libboost-test-dev:i386
diff --git a/scripts/travis/before_install.x86_64-asan.sh b/scripts/ci/before_install.x86_64-asan.sh
similarity index 100%
rename from scripts/travis/before_install.x86_64-asan.sh
rename to scripts/ci/before_install.x86_64-asan.sh
diff --git a/scripts/travis/is_pr_merge.sh b/scripts/ci/is_pr_merge.sh
similarity index 100%
rename from scripts/travis/is_pr_merge.sh
rename to scripts/ci/is_pr_merge.sh
diff --git a/scripts/travis/leaksanitizer.conf b/scripts/ci/leaksanitizer.conf
similarity index 100%
rename from scripts/travis/leaksanitizer.conf
rename to scripts/ci/leaksanitizer.conf
diff --git a/scripts/travis/publish.sh b/scripts/ci/node_package.sh
similarity index 93%
rename from scripts/travis/publish.sh
rename to scripts/ci/node_package.sh
index 35c6f9565..fd62c8adb 100755
--- a/scripts/travis/publish.sh
+++ b/scripts/ci/node_package.sh
@@ -31,7 +31,7 @@ if [[ ${PUBLISH} == 'On' ]]; then
         fi
     fi
 
-    ./node_modules/.bin/node-pre-gyp package publish info $NPM_FLAGS
+    ./node_modules/.bin/node-pre-gyp package testpackage $NPM_FLAGS
 else
     echo "PUBLISH is set to '${PUBLISH}', skipping."
 fi
diff --git a/scripts/travis/travis_helper.sh b/scripts/ci/travis_helper.sh
similarity index 100%
rename from scripts/travis/travis_helper.sh
rename to scripts/ci/travis_helper.sh
diff --git a/scripts/ci/undefinedsanitizer.conf b/scripts/ci/undefinedsanitizer.conf
new file mode 100644
index 000000000..fc1fd8996
--- /dev/null
+++ b/scripts/ci/undefinedsanitizer.conf
@@ -0,0 +1,16 @@
+enum:include/tbb/pipeline.h
+vptr:src/util/log.cpp
+vptr:include/tbb/task.h
+vptr:include/tbb/parallel_reduce.h
+vptr:include/boost/smart_ptr/detail/shared_count.hpp
+vptr:include/boost/smart_ptr/detail/sp_counted_base_gcc_atomic.hpp
+vptr:include/boost/program_options/variables_map.hpp
+vptr:include/boost/program_options/value_semantic.hpp
+vptr:src/tools/contract.cpp
+vptr:src/tools/extract.cpp
+pointer-overflow:include/partitioner/cell_storage.hpp
+signed-integer-overflow:include/engine/internal_route_result.hpp
+pointer-overflow:third_party/sol2/sol/stack_core.hpp
+pointer-overflow:third_party/rapidjson/include/rapidjson/internal/stack.h
+nonnull-attribute:third_party/microtar/src/microtar.c
+integer-divide-by-zero:unit_tests/library/route.cpp
\ No newline at end of file
diff --git a/scripts/ci/windows-build.bat b/scripts/ci/windows-build.bat
new file mode 100644
index 000000000..19eb8c7b4
--- /dev/null
+++ b/scripts/ci/windows-build.bat
@@ -0,0 +1,99 @@
+@ECHO OFF
+SETLOCAL
+SET EL=0
+
+ECHO NUMBER_OF_PROCESSORS^: %NUMBER_OF_PROCESSORS%
+
+SET PROJECT_DIR=%CD%
+SET CONFIGURATION=Release
+
+mkdir build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+cd build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+cmake -DENABLE_CONAN=ON -DCMAKE_BUILD_TYPE=%CONFIGURATION% -DBUILD_TOOLS=ON -G "Visual Studio 17 2022" ..
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+msbuild OSRM.sln ^
+/p:Configuration=%CONFIGURATION% ^
+/p:Platform=x64 ^
+/t:rebuild ^
+/p:BuildInParallel=true ^
+/m:%NUMBER_OF_PROCESSORS% ^
+/toolsversion:Current ^
+/clp:Verbosity=normal ^
+/nologo
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+dir C:\Users\runneradmin\.conan\
+dir C:\Users\runneradmin\.conan\data\tbb\2020.3\_\_\package\e9a552ebe8f994398de9ceee972f0ad207df0658\lib\
+SET PATH=C:\Users\runneradmin\.conan\data\tbb\2020.3\_\_\package\e9a552ebe8f994398de9ceee972f0ad207df0658\lib\;%PATH%
+
+CD %PROJECT_DIR%\build
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running extractor-tests.exe ...
+unit_tests\%CONFIGURATION%\extractor-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running contractor-tests.exe ...
+unit_tests\%CONFIGURATION%\contractor-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running engine-tests.exe ...
+unit_tests\%CONFIGURATION%\engine-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running util-tests.exe ...
+unit_tests\%CONFIGURATION%\util-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running server-tests.exe ...
+unit_tests\%CONFIGURATION%\server-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running partitioner-tests.exe ...
+unit_tests\%CONFIGURATION%\partitioner-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+ECHO running customizer-tests.exe ...
+unit_tests\%CONFIGURATION%\customizer-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+SET test_region=monaco
+SET test_region_ch=ch\monaco
+SET test_region_corech=corech\monaco
+SET test_region_mld=mld\monaco
+SET test_osm=%test_region%.osm.pbf
+COPY %PROJECT_DIR%\test\data\%test_region%.osm.pbf %test_osm% 
+%CONFIGURATION%\osrm-extract.exe -p %PROJECT_DIR%\profiles\car.lua %test_osm%
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+MKDIR ch
+XCOPY %test_region%.osrm.* ch\
+XCOPY %test_region%.osrm ch\
+MKDIR corech
+XCOPY %test_region%.osrm.* corech\
+XCOPY %test_region%.osrm corech\
+MKDIR mld
+XCOPY %test_region%.osrm.* mld\
+XCOPY %test_region%.osrm mld\
+%CONFIGURATION%\osrm-contract.exe %test_region_ch%.osrm
+%CONFIGURATION%\osrm-contract.exe --core 0.8 %test_region_corech%.osrm
+%CONFIGURATION%\osrm-partition.exe %test_region_mld%.osrm
+%CONFIGURATION%\osrm-customize.exe %test_region_mld%.osrm
+XCOPY /Y ch\*.* ..\test\data\ch\
+XCOPY /Y corech\*.* ..\test\data\corech\
+XCOPY /Y mld\*.* ..\test\data\mld\
+unit_tests\%CONFIGURATION%\library-tests.exe
+IF %ERRORLEVEL% NEQ 0 GOTO ERROR
+
+:ERROR
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ ERROR %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ECHO ERRORLEVEL^: %ERRORLEVEL%
+SET EL=%ERRORLEVEL%
+
+:DONE
+ECHO ~~~~~~~~~~~~~~~~~~~~~~ DONE %~f0 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+EXIT /b %EL%
diff --git a/scripts/error_on_dirty.sh b/scripts/error_on_dirty.sh
index f0328646d..84e4eadf6 100755
--- a/scripts/error_on_dirty.sh
+++ b/scripts/error_on_dirty.sh
@@ -10,6 +10,7 @@ dirty=$(git ls-files --modified)
 if [[ $dirty ]]; then
     echo $MSG
     echo $dirty
+    git diff
     exit 1
 else
     exit 0
diff --git a/scripts/format.sh b/scripts/format.sh
index 6b14688dc..cd462756d 100755
--- a/scripts/format.sh
+++ b/scripts/format.sh
@@ -19,18 +19,18 @@ elif [[ ${OS} = "Darwin" ]] ; then
 fi
 
 # Discover clang-format
-if type clang-format-3.8 2> /dev/null ; then
-    CLANG_FORMAT=clang-format-3.8
+if type clang-format-10.0.0 2> /dev/null ; then
+    CLANG_FORMAT=clang-format-10.0.0
 elif type clang-format 2> /dev/null ; then
     # Clang format found, but need to check version
     CLANG_FORMAT=clang-format
     V=$(clang-format --version)
-    if [[ $V != *3.8* ]] ; then
-        echo "clang-format is not 3.8 (returned ${V})"
+    if [[ $V != *10.0* ]] ; then
+        echo "clang-format is not 10.0 (returned ${V})"
         #exit 1
     fi
 else
-    echo "No appropriate clang-format found (expected clang-format-3.8, or clang-format)"
+    echo "No appropriate clang-format found (expected clang-format-10.0.0, or clang-format)"
     exit 1
 fi
 
diff --git a/src/benchmarks/alias.cpp b/src/benchmarks/alias.cpp
index b2a4ad1da..f8ca5dd12 100644
--- a/src/benchmarks/alias.cpp
+++ b/src/benchmarks/alias.cpp
@@ -20,7 +20,7 @@ struct interger_alias
 struct double_alias
 {
 };
-}
+} // namespace tag
 
 int main(int, char **)
 {
diff --git a/src/benchmarks/match.cpp b/src/benchmarks/match.cpp
index 7c1b3608b..932820e88 100644
--- a/src/benchmarks/match.cpp
+++ b/src/benchmarks/match.cpp
@@ -18,7 +18,8 @@
 
 #include <cstdlib>
 
-int main(int argc, const char *argv[]) try
+int main(int argc, const char *argv[])
+try
 {
     if (argc < 2)
     {
diff --git a/src/benchmarks/static_rtree.cpp b/src/benchmarks/static_rtree.cpp
index 5b642498d..d40d6390e 100644
--- a/src/benchmarks/static_rtree.cpp
+++ b/src/benchmarks/static_rtree.cpp
@@ -74,8 +74,8 @@ void benchmark(BenchStaticRTree &rtree, unsigned num_queries)
         return rtree.Nearest(q, 10);
     });
 }
-}
-}
+} // namespace benchmarks
+} // namespace osrm
 
 int main(int argc, char **argv)
 {
diff --git a/src/contractor/contractor_search.cpp b/src/contractor/contractor_search.cpp
index e010723b8..f9e336c8e 100644
--- a/src/contractor/contractor_search.cpp
+++ b/src/contractor/contractor_search.cpp
@@ -32,20 +32,22 @@ void relaxNode(ContractorHeap &heap,
         }
         const EdgeWeight to_weight = node_weight + data.weight;
 
+        const auto toHeapNode = heap.GetHeapNodeIfWasInserted(to);
         // New Node discovered -> Add to Heap + Node Info Storage
-        if (!heap.WasInserted(to))
+        if (!toHeapNode)
         {
             heap.Insert(to, to_weight, ContractorHeapData{current_hop, false});
         }
         // Found a shorter Path -> Update weight
-        else if (to_weight < heap.GetKey(to))
+        else if (to_weight < toHeapNode->weight)
         {
-            heap.DecreaseKey(to, to_weight);
-            heap.GetData(to).hop = current_hop;
+            toHeapNode->weight = to_weight;
+            heap.DecreaseKey(*toHeapNode);
+            toHeapNode->data.hop = current_hop;
         }
     }
 }
-}
+} // namespace
 
 void search(ContractorHeap &heap,
             const ContractorGraph &graph,
@@ -83,5 +85,5 @@ void search(ContractorHeap &heap,
         relaxNode(heap, graph, node, node_weight, forbidden_node);
     }
 }
-}
-}
+} // namespace contractor
+} // namespace osrm
diff --git a/src/contractor/graph_contractor.cpp b/src/contractor/graph_contractor.cpp
index 8615156dd..0b3e87cc2 100644
--- a/src/contractor/graph_contractor.cpp
+++ b/src/contractor/graph_contractor.cpp
@@ -560,7 +560,7 @@ bool IsNodeIndependent(const util::XORFastHash<> &hash,
     }
     return true;
 }
-}
+} // namespace
 
 std::vector<bool> contractGraph(ContractorGraph &graph,
                                 std::vector<bool> node_is_uncontracted_,
@@ -671,10 +671,10 @@ std::vector<bool> contractGraph(ContractorGraph &graph,
             });
 
         // sort all remaining nodes to the beginning of the sequence
-        const auto begin_independent_nodes =
-            stable_partition(remaining_nodes.begin(),
-                             remaining_nodes.end(),
-                             [](RemainingNodeData node_data) { return !node_data.is_independent; });
+        const auto begin_independent_nodes = std::stable_partition(
+            remaining_nodes.begin(), remaining_nodes.end(), [](RemainingNodeData node_data) {
+                return !node_data.is_independent;
+            });
         auto begin_independent_nodes_idx =
             std::distance(remaining_nodes.begin(), begin_independent_nodes);
         auto end_independent_nodes_idx = remaining_nodes.size();
diff --git a/src/customize/customizer.cpp b/src/customize/customizer.cpp
index 7c96617a6..da95f9967 100644
--- a/src/customize/customizer.cpp
+++ b/src/customize/customizer.cpp
@@ -108,8 +108,9 @@ std::vector<CellMetric> customizeFilteredMetrics(const partitioner::MultiLevelEd
                                                  const std::vector<std::vector<bool>> &node_filters)
 {
     std::vector<CellMetric> metrics;
+    metrics.reserve(node_filters.size());
 
-    for (auto filter : node_filters)
+    for (const auto &filter : node_filters)
     {
         auto metric = storage.MakeMetric();
         customizer.Customize(graph, storage, filter, metric);
@@ -118,7 +119,7 @@ std::vector<CellMetric> customizeFilteredMetrics(const partitioner::MultiLevelEd
 
     return metrics;
 }
-}
+} // namespace
 
 int Customizer::Run(const CustomizationConfig &config)
 {
@@ -191,5 +192,5 @@ int Customizer::Run(const CustomizationConfig &config)
     return 0;
 }
 
-} // namespace customizer$
+} // namespace customizer
 } // namespace osrm
diff --git a/src/engine/api/json_factory.cpp b/src/engine/api/json_factory.cpp
index 8df45c94c..a0f71e50e 100644
--- a/src/engine/api/json_factory.cpp
+++ b/src/engine/api/json_factory.cpp
@@ -19,7 +19,6 @@
 #include <utility>
 #include <vector>
 
-namespace TurnType = osrm::guidance::TurnType;
 using TurnInstruction = osrm::guidance::TurnInstruction;
 
 namespace osrm
@@ -193,8 +192,8 @@ util::json::Object makeRouteStep(guidance::RouteStep step, util::json::Value geo
         }
     }
 
-    route_step.values["mode"] = extractor::travelModeToString(std::move(step.mode));
-    route_step.values["maneuver"] = makeStepManeuver(std::move(step.maneuver));
+    route_step.values["mode"] = extractor::travelModeToString(step.mode);
+    route_step.values["maneuver"] = makeStepManeuver(step.maneuver);
     route_step.values["geometry"] = std::move(geometry);
     route_step.values["driving_side"] = step.is_left_hand_driving ? "left" : "right";
 
@@ -242,7 +241,7 @@ util::json::Object makeWaypoint(const util::Coordinate &location,
                                 std::string name,
                                 const Hint &hint)
 {
-    auto waypoint = makeWaypoint(location, distance, name);
+    auto waypoint = makeWaypoint(location, distance, std::move(name));
     waypoint.values["hint"] = hint.ToBase64();
     return waypoint;
 }
diff --git a/src/engine/douglas_peucker.cpp b/src/engine/douglas_peucker.cpp
index 9a7bd500b..424f94940 100644
--- a/src/engine/douglas_peucker.cpp
+++ b/src/engine/douglas_peucker.cpp
@@ -119,5 +119,5 @@ std::vector<util::Coordinate> douglasPeucker(std::vector<util::Coordinate>::cons
 
     return simplified_geometry;
 }
-} // ns engine
-} // ns osrm
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/engine_config.cpp b/src/engine/engine_config.cpp
index ac7723ba9..c227a9b8a 100644
--- a/src/engine/engine_config.cpp
+++ b/src/engine/engine_config.cpp
@@ -27,5 +27,5 @@ bool EngineConfig::IsValid() const
             storage_config.IsValid()) &&
            limits_valid;
 }
-}
-}
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/guidance/assemble_overview.cpp b/src/engine/guidance/assemble_overview.cpp
index 8086ba1ee..75def77a0 100644
--- a/src/engine/guidance/assemble_overview.cpp
+++ b/src/engine/guidance/assemble_overview.cpp
@@ -39,7 +39,7 @@ unsigned calculateOverviewZoomLevel(const std::vector<LegGeometry> &leg_geometri
 
     return util::viewport::getFittedZoom(south_west, north_east);
 }
-}
+} // namespace
 
 std::vector<util::Coordinate> assembleOverview(const std::vector<LegGeometry> &leg_geometries,
                                                const bool use_simplification)
diff --git a/src/engine/guidance/assemble_steps.cpp b/src/engine/guidance/assemble_steps.cpp
index 68fa4dc11..1e5b87a3f 100644
--- a/src/engine/guidance/assemble_steps.cpp
+++ b/src/engine/guidance/assemble_steps.cpp
@@ -25,7 +25,8 @@ std::pair<short, short> getDepartBearings(const LegGeometry &leg_geometry,
     const auto turn_coordinate = leg_geometry.locations.front();
     const auto post_turn_coordinate = *(leg_geometry.locations.begin() + 1);
 
-    if (util::coordinate_calculation::haversineDistance(turn_coordinate, post_turn_coordinate) <= 1)
+    if (util::coordinate_calculation::greatCircleDistance(turn_coordinate, post_turn_coordinate) <=
+        1)
     {
         return std::make_pair<short, short>(0, source_node.GetBearing(traversed_in_reverse));
     }
@@ -41,14 +42,15 @@ std::pair<short, short> getArriveBearings(const LegGeometry &leg_geometry,
     BOOST_ASSERT(leg_geometry.locations.size() >= 2);
     const auto turn_coordinate = leg_geometry.locations.back();
     const auto pre_turn_coordinate = *(leg_geometry.locations.end() - 2);
-    if (util::coordinate_calculation::haversineDistance(turn_coordinate, pre_turn_coordinate) <= 1)
+    if (util::coordinate_calculation::greatCircleDistance(turn_coordinate, pre_turn_coordinate) <=
+        1)
     {
         return std::make_pair<short, short>(target_node.GetBearing(traversed_in_reverse), 0);
     }
     return std::make_pair<short, short>(
         std::round(util::coordinate_calculation::bearing(pre_turn_coordinate, turn_coordinate)), 0);
 }
-} // ns detail
-} // ns engine
-} // ns guidance
-} // ns detail
+} // namespace detail
+} // namespace guidance
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/guidance/collapse_scenario_detection.cpp b/src/engine/guidance/collapse_scenario_detection.cpp
index 27efe856d..ff29bb756 100644
--- a/src/engine/guidance/collapse_scenario_detection.cpp
+++ b/src/engine/guidance/collapse_scenario_detection.cpp
@@ -181,9 +181,10 @@ bool isUTurn(const RouteStepIterator step_prior_to_intersection,
     const auto only_allowed_turn = (numberOfAllowedTurns(*step_leaving_intersection) == 1) &&
                                    noIntermediaryIntersections(*step_entering_intersection);
 
-    return collapsable || isLinkRoad(*step_prior_to_intersection,
-                                     *step_entering_intersection,
-                                     *step_leaving_intersection) ||
+    return collapsable ||
+           isLinkRoad(*step_prior_to_intersection,
+                      *step_entering_intersection,
+                      *step_leaving_intersection) ||
            only_allowed_turn;
 }
 
diff --git a/src/engine/guidance/post_processing.cpp b/src/engine/guidance/post_processing.cpp
index 2a0546f64..f510e04b0 100644
--- a/src/engine/guidance/post_processing.cpp
+++ b/src/engine/guidance/post_processing.cpp
@@ -263,7 +263,7 @@ void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry)
     BOOST_ASSERT(geometry.locations.size() >= steps.size());
     // Look for distances under 1m
     const bool zero_length_step = steps.front().distance <= 1 && steps.size() > 2;
-    const bool duplicated_coordinate = util::coordinate_calculation::haversineDistance(
+    const bool duplicated_coordinate = util::coordinate_calculation::greatCircleDistance(
                                            geometry.locations[0], geometry.locations[1]) <= 1;
     if (zero_length_step || duplicated_coordinate)
     {
@@ -406,7 +406,7 @@ void trimShortSegments(std::vector<RouteStep> &steps, LegGeometry &geometry)
         next_to_last_step.mode = new_next_to_last.mode;
         // the geometry indices of the last step are already correct;
     }
-    else if (util::coordinate_calculation::haversineDistance(
+    else if (util::coordinate_calculation::greatCircleDistance(
                  geometry.locations[geometry.locations.size() - 2],
                  geometry.locations[geometry.locations.size() - 1]) <= 1)
     {
@@ -463,7 +463,7 @@ std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
     BOOST_ASSERT(steps.size() >= 2);
     BOOST_ASSERT(leg_geometry.locations.size() >= 2);
     const constexpr double MINIMAL_RELATIVE_DISTANCE = 5., MAXIMAL_RELATIVE_DISTANCE = 300.;
-    const auto distance_to_start = util::coordinate_calculation::haversineDistance(
+    const auto distance_to_start = util::coordinate_calculation::greatCircleDistance(
         source_node.input_location, leg_geometry.locations[0]);
     const auto initial_modifier =
         distance_to_start >= MINIMAL_RELATIVE_DISTANCE &&
@@ -474,7 +474,7 @@ std::vector<RouteStep> assignRelativeLocations(std::vector<RouteStep> steps,
 
     steps.front().maneuver.instruction.direction_modifier = initial_modifier;
 
-    const auto distance_from_end = util::coordinate_calculation::haversineDistance(
+    const auto distance_from_end = util::coordinate_calculation::greatCircleDistance(
         target_node.input_location, leg_geometry.locations.back());
     const auto final_modifier =
         distance_from_end >= MINIMAL_RELATIVE_DISTANCE &&
@@ -706,8 +706,9 @@ void applyOverrides(const datafacade::BaseDataFacade &facade,
                             << "    direction was "
                             << osrm::guidance::instructionModifierToString(
                                    step_to_update->maneuver.instruction.direction_modifier)
-                            << " now " << osrm::guidance::instructionModifierToString(
-                                              maneuver_relation.direction)
+                            << " now "
+                            << osrm::guidance::instructionModifierToString(
+                                   maneuver_relation.direction)
                             << std::endl;
                         step_to_update->maneuver.instruction.direction_modifier =
                             maneuver_relation.direction;
diff --git a/src/engine/guidance/verbosity_reduction.cpp b/src/engine/guidance/verbosity_reduction.cpp
index a021fd1a8..3351c853c 100644
--- a/src/engine/guidance/verbosity_reduction.cpp
+++ b/src/engine/guidance/verbosity_reduction.cpp
@@ -38,29 +38,30 @@ std::vector<RouteStep> suppressShortNameSegments(std::vector<RouteStep> steps)
 
     // suppresses name segments that announce already known names or announce a name that will be
     // only available for a very short time
-    const auto reduce_verbosity_if_possible = [suppress, can_be_extended_to](
-        RouteStepIterator &current_turn_itr, RouteStepIterator &previous_turn_itr) {
-        if (haveSameName(*previous_turn_itr, *current_turn_itr))
-            suppress(*previous_turn_itr, *current_turn_itr);
-        else
-        {
-            // remember the location of the name change so we can advance the previous turn
-            const auto location_of_name_change = current_turn_itr;
-            auto distance = current_turn_itr->distance;
-            // sum up all distances that can be relevant to the name change
-            while (can_be_extended_to(*(current_turn_itr + 1)) &&
-                   distance < NAME_SEGMENT_CUTOFF_LENGTH)
-            {
-                ++current_turn_itr;
-                distance += current_turn_itr->distance;
-            }
-
-            if (distance < NAME_SEGMENT_CUTOFF_LENGTH)
+    const auto reduce_verbosity_if_possible =
+        [suppress, can_be_extended_to](RouteStepIterator &current_turn_itr,
+                                       RouteStepIterator &previous_turn_itr) {
+            if (haveSameName(*previous_turn_itr, *current_turn_itr))
                 suppress(*previous_turn_itr, *current_turn_itr);
             else
-                previous_turn_itr = location_of_name_change;
-        }
-    };
+            {
+                // remember the location of the name change so we can advance the previous turn
+                const auto location_of_name_change = current_turn_itr;
+                auto distance = current_turn_itr->distance;
+                // sum up all distances that can be relevant to the name change
+                while (can_be_extended_to(*(current_turn_itr + 1)) &&
+                       distance < NAME_SEGMENT_CUTOFF_LENGTH)
+                {
+                    ++current_turn_itr;
+                    distance += current_turn_itr->distance;
+                }
+
+                if (distance < NAME_SEGMENT_CUTOFF_LENGTH)
+                    suppress(*previous_turn_itr, *current_turn_itr);
+                else
+                    previous_turn_itr = location_of_name_change;
+            }
+        };
 
     BOOST_ASSERT(!hasTurnType(steps.back()) && hasWaypointType(steps.back()));
     for (auto previous_turn_itr = steps.begin(), current_turn_itr = std::next(previous_turn_itr);
diff --git a/src/engine/hint.cpp b/src/engine/hint.cpp
index bdd782382..6bc246c9d 100644
--- a/src/engine/hint.cpp
+++ b/src/engine/hint.cpp
@@ -57,5 +57,5 @@ bool operator==(const Hint &lhs, const Hint &rhs)
 
 std::ostream &operator<<(std::ostream &out, const Hint &hint) { return out << hint.ToBase64(); }
 
-} // ns engine
-} // ns osrm
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/match.cpp b/src/engine/plugins/match.cpp
index 5650b6609..59d7fccda 100644
--- a/src/engine/plugins/match.cpp
+++ b/src/engine/plugins/match.cpp
@@ -207,7 +207,6 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                            {
                                return routing_algorithms::DEFAULT_GPS_PRECISION * RADIUS_MULTIPLIER;
                            }
-
                        });
     }
 
@@ -314,6 +313,6 @@ Status MatchPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/nearest.cpp b/src/engine/plugins/nearest.cpp
index 41f3742d8..b01d66dc8 100644
--- a/src/engine/plugins/nearest.cpp
+++ b/src/engine/plugins/nearest.cpp
@@ -60,6 +60,6 @@ Status NearestPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/table.cpp b/src/engine/plugins/table.cpp
index 5b517ac17..77760f71d 100644
--- a/src/engine/plugins/table.cpp
+++ b/src/engine/plugins/table.cpp
@@ -116,9 +116,9 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                     auto distance_estimate =
                         params.fallback_coordinate_type ==
                                 api::TableParameters::FallbackCoordinateType::Input
-                            ? util::coordinate_calculation::fccApproximateDistance(
+                            ? util::coordinate_calculation::greatCircleDistance(
                                   source.input_location, destination.input_location)
-                            : util::coordinate_calculation::fccApproximateDistance(
+                            : util::coordinate_calculation::greatCircleDistance(
                                   source.location, destination.location);
 
                     result_tables_pair.first[table_index] =
@@ -156,6 +156,6 @@ Status TablePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/tile.cpp b/src/engine/plugins/tile.cpp
index 9a46f1d0c..5a899edd4 100644
--- a/src/engine/plugins/tile.cpp
+++ b/src/engine/plugins/tile.cpp
@@ -1,6 +1,5 @@
 #include "guidance/turn_instruction.hpp"
 
-#include "engine/plugins/plugin_base.hpp"
 #include "engine/plugins/plugin_base.hpp"
 #include "engine/plugins/tile.hpp"
 
@@ -465,7 +464,7 @@ void encodeVectorTile(const DataFacadeBase &facade,
                     const auto b = facade.GetCoordinateOfNode(edge.v);
                     // Calculate the length in meters
                     const double length =
-                        osrm::util::coordinate_calculation::haversineDistance(a, b);
+                        osrm::util::coordinate_calculation::greatCircleDistance(a, b);
 
                     const auto forward_weight_range =
                         facade.GetUncompressedForwardWeights(geometry_id);
@@ -661,7 +660,7 @@ void encodeVectorTile(const DataFacadeBase &facade,
 
     tile.serialize(pbf_buffer);
 }
-}
+} // namespace
 
 Status TilePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
                                  const api::TileParameters &parameters,
@@ -697,6 +696,6 @@ Status TilePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/trip.cpp b/src/engine/plugins/trip.cpp
index 74a4452aa..d949fcb60 100644
--- a/src/engine/plugins/trip.cpp
+++ b/src/engine/plugins/trip.cpp
@@ -204,8 +204,9 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
     }
     BOOST_ASSERT(phantom_node_pairs.size() == number_of_locations);
 
-    if (fixed_start && fixed_end && (source_id >= parameters.coordinates.size() ||
-                                     destination_id >= parameters.coordinates.size()))
+    if (fixed_start && fixed_end &&
+        (source_id >= parameters.coordinates.size() ||
+         destination_id >= parameters.coordinates.size()))
     {
         return Error("InvalidValue", "Invalid source or destination value.", result);
     }
@@ -278,6 +279,6 @@ Status TripPlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithms,
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/plugins/viaroute.cpp b/src/engine/plugins/viaroute.cpp
index 9b0f3ebfc..a95d17810 100644
--- a/src/engine/plugins/viaroute.cpp
+++ b/src/engine/plugins/viaroute.cpp
@@ -183,6 +183,6 @@ Status ViaRoutePlugin::HandleRequest(const RoutingAlgorithmsInterface &algorithm
 
     return Status::Ok;
 }
-}
-}
-}
+} // namespace plugins
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/polyline_compressor.cpp b/src/engine/polyline_compressor.cpp
index eca177980..ca9a4f2a0 100644
--- a/src/engine/polyline_compressor.cpp
+++ b/src/engine/polyline_compressor.cpp
@@ -75,6 +75,6 @@ std::int32_t decode_polyline_integer(std::string::const_iterator &first,
     result = ((result & 1) == 1) ? ~(result >> 1) : (result >> 1);
     return static_cast<std::int32_t>(result);
 }
-}
-}
-}
+} // namespace detail
+} // namespace engine
+} // namespace osrm
diff --git a/src/engine/routing_algorithms/alternative_path_ch.cpp b/src/engine/routing_algorithms/alternative_path_ch.cpp
index 2efd6fe19..00be0794d 100644
--- a/src/engine/routing_algorithms/alternative_path_ch.cpp
+++ b/src/engine/routing_algorithms/alternative_path_ch.cpp
@@ -62,11 +62,12 @@ void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
     QueryHeap &forward_heap = DIRECTION == FORWARD_DIRECTION ? heap1 : heap2;
     QueryHeap &reverse_heap = DIRECTION == FORWARD_DIRECTION ? heap2 : heap1;
 
-    const NodeID node = forward_heap.DeleteMin();
-    const EdgeWeight weight = forward_heap.GetKey(node);
+    // Take a copy (no ref &) of the extracted node because otherwise could be modified later if
+    // toHeapNode is the same
+    const auto heapNode = forward_heap.DeleteMinGetHeapNode();
 
     const auto scaled_weight =
-        static_cast<EdgeWeight>((weight + min_edge_offset) / (1. + VIAPATH_EPSILON));
+        static_cast<EdgeWeight>((heapNode.weight + min_edge_offset) / (1. + VIAPATH_EPSILON));
     if ((INVALID_EDGE_WEIGHT != *upper_bound_to_shortest_path_weight) &&
         (scaled_weight > *upper_bound_to_shortest_path_weight))
     {
@@ -74,35 +75,36 @@ void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
         return;
     }
 
-    search_space.emplace_back(forward_heap.GetData(node).parent, node);
+    search_space.emplace_back(heapNode.data.parent, heapNode.node);
 
-    if (reverse_heap.WasInserted(node))
+    const auto reverseHeapNode = reverse_heap.GetHeapNodeIfWasInserted(heapNode.node);
+    if (reverseHeapNode)
     {
-        search_space_intersection.emplace_back(node);
-        const EdgeWeight new_weight = reverse_heap.GetKey(node) + weight;
+        search_space_intersection.emplace_back(heapNode.node);
+        const EdgeWeight new_weight = reverseHeapNode->weight + heapNode.weight;
         if (new_weight < *upper_bound_to_shortest_path_weight)
         {
             if (new_weight >= 0)
             {
-                *middle_node = node;
+                *middle_node = heapNode.node;
                 *upper_bound_to_shortest_path_weight = new_weight;
             }
             else
             {
                 // check whether there is a loop present at the node
-                const auto loop_weight = std::get<0>(getLoopWeight<false>(facade, node));
+                const auto loop_weight = std::get<0>(getLoopWeight<false>(facade, heapNode.node));
                 const EdgeWeight new_weight_with_loop = new_weight + loop_weight;
                 if (loop_weight != INVALID_EDGE_WEIGHT &&
                     new_weight_with_loop <= *upper_bound_to_shortest_path_weight)
                 {
-                    *middle_node = node;
+                    *middle_node = heapNode.node;
                     *upper_bound_to_shortest_path_weight = loop_weight;
                 }
             }
         }
     }
 
-    for (auto edge : facade.GetAdjacentEdgeRange(node))
+    for (auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
@@ -111,20 +113,22 @@ void alternativeRoutingStep(const DataFacade<Algorithm> &facade,
             const EdgeWeight edge_weight = data.weight;
 
             BOOST_ASSERT(edge_weight > 0);
-            const EdgeWeight to_weight = weight + edge_weight;
+            const EdgeWeight to_weight = heapNode.weight + edge_weight;
 
+            const auto toHeapNode = forward_heap.GetHeapNodeIfWasInserted(to);
             // New Node discovered -> Add to Heap + Node Info Storage
-            if (!forward_heap.WasInserted(to))
+            if (!toHeapNode)
             {
-                forward_heap.Insert(to, to_weight, node);
+                forward_heap.Insert(to, to_weight, heapNode.node);
             }
             // Found a shorter Path -> Update weight
-            else if (to_weight < forward_heap.GetKey(to))
+            else if (to_weight < toHeapNode->weight)
             {
                 // new parent
-                forward_heap.GetData(to).parent = node;
+                toHeapNode->data.parent = heapNode.node;
                 // decreased weight
-                forward_heap.DecreaseKey(to, to_weight);
+                toHeapNode->weight = to_weight;
+                forward_heap.DecreaseKey(*toHeapNode);
             }
         }
     }
@@ -558,7 +562,7 @@ bool viaNodeCandidatePassesTTest(SearchEngineData<Algorithm> &engine_working_dat
     }
     return (upper_bound <= t_test_path_weight);
 }
-} // anon. namespace
+} // namespace
 
 InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engine_working_data,
                                                const DataFacade<Algorithm> &facade,
@@ -853,4 +857,4 @@ InternalManyRoutesResult alternativePathSearch(SearchEngineData<Algorithm> &engi
 
 } // namespace routing_algorithms
 } // namespace engine
-} // namespace osrm}
+} // namespace osrm
diff --git a/src/engine/routing_algorithms/alternative_path_mld.cpp b/src/engine/routing_algorithms/alternative_path_mld.cpp
index 51688c825..96329c27f 100644
--- a/src/engine/routing_algorithms/alternative_path_mld.cpp
+++ b/src/engine/routing_algorithms/alternative_path_mld.cpp
@@ -137,7 +137,7 @@ Parameters parametersFromRequest(const PhantomNodes &phantom_node_pair)
 {
     Parameters parameters;
 
-    const auto distance = util::coordinate_calculation::haversineDistance(
+    const auto distance = util::coordinate_calculation::greatCircleDistance(
         phantom_node_pair.source_phantom.location, phantom_node_pair.target_phantom.location);
 
     // 10km
diff --git a/src/engine/routing_algorithms/many_to_many_ch.cpp b/src/engine/routing_algorithms/many_to_many_ch.cpp
index f9fa8e509..2d2108cb2 100644
--- a/src/engine/routing_algorithms/many_to_many_ch.cpp
+++ b/src/engine/routing_algorithms/many_to_many_ch.cpp
@@ -45,20 +45,18 @@ inline bool addLoopWeight(const DataFacade<ch::Algorithm> &facade,
 }
 
 template <bool DIRECTION>
-void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
-                        const NodeID node,
-                        const EdgeWeight weight,
-                        const EdgeDuration duration,
-                        const EdgeDistance distance,
-                        typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
-                        const PhantomNode &)
+void relaxOutgoingEdges(
+    const DataFacade<Algorithm> &facade,
+    const typename SearchEngineData<Algorithm>::ManyToManyQueryHeap::HeapNode &heapNode,
+    typename SearchEngineData<Algorithm>::ManyToManyQueryHeap &query_heap,
+    const PhantomNode &)
 {
-    if (stallAtNode<DIRECTION>(facade, node, weight, query_heap))
+    if (stallAtNode<DIRECTION>(facade, heapNode, query_heap))
     {
         return;
     }
 
-    for (auto edge : facade.GetAdjacentEdgeRange(node))
+    for (auto edge : facade.GetAdjacentEdgeRange(heapNode.node))
     {
         const auto &data = facade.GetEdgeData(edge);
         if (DIRECTION == FORWARD_DIRECTION ? data.forward : data.backward)
@@ -70,21 +68,23 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto edge_distance = data.distance;
 
             BOOST_ASSERT_MSG(edge_weight > 0, "edge_weight invalid");
-            const auto to_weight = weight + edge_weight;
-            const auto to_duration = duration + edge_duration;
-            const auto to_distance = distance + edge_distance;
+            const auto to_weight = heapNode.weight + edge_weight;
+            const auto to_duration = heapNode.data.duration + edge_duration;
+            const auto to_distance = heapNode.data.distance + edge_distance;
 
+            const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
             // New Node discovered -> Add to Heap + Node Info Storage
-            if (!query_heap.WasInserted(to))
+            if (!toHeapNode)
             {
-                query_heap.Insert(to, to_weight, {node, to_duration, to_distance});
+                query_heap.Insert(to, to_weight, {heapNode.node, to_duration, to_distance});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration) <
-                     std::tie(query_heap.GetKey(to), query_heap.GetData(to).duration))
+                     std::tie(toHeapNode->weight, toHeapNode->data.duration))
             {
-                query_heap.GetData(to) = {node, to_duration, to_distance};
-                query_heap.DecreaseKey(to, to_weight);
+                toHeapNode->data = {heapNode.node, to_duration, to_distance};
+                toHeapNode->weight = to_weight;
+                query_heap.DecreaseKey(*toHeapNode);
             }
         }
     }
@@ -101,15 +101,14 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
-    const auto node = query_heap.DeleteMin();
-    const auto source_weight = query_heap.GetKey(node);
-    const auto source_duration = query_heap.GetData(node).duration;
-    const auto source_distance = query_heap.GetData(node).distance;
+    // Take a copy of the extracted node because otherwise could be modified later if toHeapNode is
+    // the same
+    const auto heapNode = query_heap.DeleteMinGetHeapNode();
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
                                                search_space_with_buckets.end(),
-                                               node,
+                                               heapNode.node,
                                                NodeBucket::Compare());
     for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
     {
@@ -129,18 +128,18 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                                     : distances_table[row_index * number_of_targets + column_index];
 
         // Check if new weight is better
-        auto new_weight = source_weight + target_weight;
-        auto new_duration = source_duration + target_duration;
-        auto new_distance = source_distance + target_distance;
+        auto new_weight = heapNode.weight + target_weight;
+        auto new_duration = heapNode.data.duration + target_duration;
+        auto new_distance = heapNode.data.distance + target_distance;
 
         if (new_weight < 0)
         {
-            if (addLoopWeight(facade, node, new_weight, new_duration, new_distance))
+            if (addLoopWeight(facade, heapNode.node, new_weight, new_duration, new_distance))
             {
                 current_weight = std::min(current_weight, new_weight);
                 current_duration = std::min(current_duration, new_duration);
                 current_distance = std::min(current_distance, new_distance);
-                middle_nodes_table[row_index * number_of_targets + column_index] = node;
+                middle_nodes_table[row_index * number_of_targets + column_index] = heapNode.node;
             }
         }
         else if (std::tie(new_weight, new_duration) < std::tie(current_weight, current_duration))
@@ -148,12 +147,11 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
             current_weight = new_weight;
             current_duration = new_duration;
             current_distance = new_distance;
-            middle_nodes_table[row_index * number_of_targets + column_index] = node;
+            middle_nodes_table[row_index * number_of_targets + column_index] = heapNode.node;
         }
     }
 
-    relaxOutgoingEdges<FORWARD_DIRECTION>(
-        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
+    relaxOutgoingEdges<FORWARD_DIRECTION>(facade, heapNode, query_heap, phantom_node);
 }
 
 void backwardRoutingStep(const DataFacade<Algorithm> &facade,
@@ -162,18 +160,19 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
                          std::vector<NodeBucket> &search_space_with_buckets,
                          const PhantomNode &phantom_node)
 {
-    const auto node = query_heap.DeleteMin();
-    const auto target_weight = query_heap.GetKey(node);
-    const auto target_duration = query_heap.GetData(node).duration;
-    const auto target_distance = query_heap.GetData(node).distance;
-    const auto parent = query_heap.GetData(node).parent;
+    // Take a copy (no ref &) of the extracted node because otherwise could be modified later if
+    // toHeapNode is the same
+    const auto heapNode = query_heap.DeleteMinGetHeapNode();
 
     // Store settled nodes in search space bucket
-    search_space_with_buckets.emplace_back(
-        node, parent, column_index, target_weight, target_duration, target_distance);
+    search_space_with_buckets.emplace_back(heapNode.node,
+                                           heapNode.data.parent,
+                                           column_index,
+                                           heapNode.weight,
+                                           heapNode.data.duration,
+                                           heapNode.data.distance);
 
-    relaxOutgoingEdges<REVERSE_DIRECTION>(
-        facade, node, target_weight, target_duration, target_distance, query_heap, phantom_node);
+    relaxOutgoingEdges<REVERSE_DIRECTION>(facade, heapNode, query_heap, phantom_node);
 }
 
 } // namespace ch
@@ -249,7 +248,7 @@ manyToManySearch(SearchEngineData<ch::Algorithm> &engine_working_data,
         }
     }
 
-    return std::make_pair(durations_table, distances_table);
+    return std::make_pair(std::move(durations_table), std::move(distances_table));
 }
 
 } // namespace routing_algorithms
diff --git a/src/engine/routing_algorithms/many_to_many_mld.cpp b/src/engine/routing_algorithms/many_to_many_mld.cpp
index bd41f7aba..9607ccf09 100644
--- a/src/engine/routing_algorithms/many_to_many_mld.cpp
+++ b/src/engine/routing_algorithms/many_to_many_mld.cpp
@@ -71,38 +71,38 @@ void relaxBorderEdges(const DataFacade<mld::Algorithm> &facade,
             const auto to_distance = distance + node_distance;
 
             // New Node discovered -> Add to Heap + Node Info Storage
-            if (!query_heap.WasInserted(to))
+            const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
+            if (!toHeapNode)
             {
                 query_heap.Insert(to, to_weight, {node, false, to_duration, to_distance});
             }
             // Found a shorter Path -> Update weight and set new parent
             else if (std::tie(to_weight, to_duration, to_distance, node) <
-                     std::tie(query_heap.GetKey(to),
-                              query_heap.GetData(to).duration,
-                              query_heap.GetData(to).distance,
-                              query_heap.GetData(to).parent))
+                     std::tie(toHeapNode->weight,
+                              toHeapNode->data.duration,
+                              toHeapNode->data.distance,
+                              toHeapNode->data.parent))
             {
-                query_heap.GetData(to) = {node, false, to_duration, to_distance};
-                query_heap.DecreaseKey(to, to_weight);
+                toHeapNode->data = {node, false, to_duration, to_distance};
+                toHeapNode->weight = to_weight;
+                query_heap.DecreaseKey(*toHeapNode);
             }
         }
     }
 }
 
 template <bool DIRECTION, typename... Args>
-void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
-                        const NodeID node,
-                        const EdgeWeight weight,
-                        const EdgeDuration duration,
-                        const EdgeDistance distance,
-                        typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
-                        Args... args)
+void relaxOutgoingEdges(
+    const DataFacade<mld::Algorithm> &facade,
+    const typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap::HeapNode &heapNode,
+    typename SearchEngineData<mld::Algorithm>::ManyToManyQueryHeap &query_heap,
+    Args... args)
 {
-    BOOST_ASSERT(!facade.ExcludeNode(node));
+    BOOST_ASSERT(!facade.ExcludeNode(heapNode.node));
 
     const auto &partition = facade.GetMultiLevelPartition();
 
-    const auto level = getNodeQueryLevel(partition, node, args...);
+    const auto level = getNodeQueryLevel(partition, heapNode.node, args...);
 
     // Break outgoing edges relaxation if node at the restricted level
     if (level == INVALID_LEVEL_ID)
@@ -110,40 +110,42 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
 
     const auto &cells = facade.GetCellStorage();
     const auto &metric = facade.GetCellMetric();
-    const auto &node_data = query_heap.GetData(node);
 
-    if (level >= 1 && !node_data.from_clique_arc)
+    if (level >= 1 && !heapNode.data.from_clique_arc)
     {
-        const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, node));
+        const auto &cell = cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
         if (DIRECTION == FORWARD_DIRECTION)
         { // Shortcuts in forward direction
             auto destination = cell.GetDestinationNodes().begin();
-            auto shortcut_durations = cell.GetOutDuration(node);
-            auto shortcut_distances = cell.GetOutDistance(node);
-            for (auto shortcut_weight : cell.GetOutWeight(node))
+            auto shortcut_durations = cell.GetOutDuration(heapNode.node);
+            auto shortcut_distances = cell.GetOutDistance(heapNode.node);
+            for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
                 BOOST_ASSERT(!shortcut_durations.empty());
                 BOOST_ASSERT(!shortcut_distances.empty());
                 const NodeID to = *destination;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const auto to_weight = weight + shortcut_weight;
-                    const auto to_duration = duration + shortcut_durations.front();
-                    const auto to_distance = distance + shortcut_distances.front();
-                    if (!query_heap.WasInserted(to))
+                    const auto to_weight = heapNode.weight + shortcut_weight;
+                    const auto to_duration = heapNode.data.duration + shortcut_durations.front();
+                    const auto to_distance = heapNode.data.distance + shortcut_distances.front();
+                    const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, to_distance});
+                        query_heap.Insert(
+                            to, to_weight, {heapNode.node, true, to_duration, to_distance});
                     }
-                    else if (std::tie(to_weight, to_duration, to_distance, node) <
-                             std::tie(query_heap.GetKey(to),
-                                      query_heap.GetData(to).duration,
-                                      query_heap.GetData(to).distance,
-                                      query_heap.GetData(to).parent))
+                    else if (std::tie(to_weight, to_duration, to_distance, heapNode.node) <
+                             std::tie(toHeapNode->weight,
+                                      toHeapNode->data.duration,
+                                      toHeapNode->data.distance,
+                                      toHeapNode->data.parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, to_distance};
-                        query_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->data = {heapNode.node, true, to_duration, to_distance};
+                        toHeapNode->weight = to_weight;
+                        query_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++destination;
@@ -156,32 +158,35 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
         else
         { // Shortcuts in backward direction
             auto source = cell.GetSourceNodes().begin();
-            auto shortcut_durations = cell.GetInDuration(node);
-            auto shortcut_distances = cell.GetInDistance(node);
-            for (auto shortcut_weight : cell.GetInWeight(node))
+            auto shortcut_durations = cell.GetInDuration(heapNode.node);
+            auto shortcut_distances = cell.GetInDistance(heapNode.node);
+            for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
                 BOOST_ASSERT(!shortcut_durations.empty());
                 BOOST_ASSERT(!shortcut_distances.empty());
                 const NodeID to = *source;
 
-                if (shortcut_weight != INVALID_EDGE_WEIGHT && node != to)
+                if (shortcut_weight != INVALID_EDGE_WEIGHT && heapNode.node != to)
                 {
-                    const auto to_weight = weight + shortcut_weight;
-                    const auto to_duration = duration + shortcut_durations.front();
-                    const auto to_distance = distance + shortcut_distances.front();
-                    if (!query_heap.WasInserted(to))
+                    const auto to_weight = heapNode.weight + shortcut_weight;
+                    const auto to_duration = heapNode.data.duration + shortcut_durations.front();
+                    const auto to_distance = heapNode.data.distance + shortcut_distances.front();
+                    const auto toHeapNode = query_heap.GetHeapNodeIfWasInserted(to);
+                    if (!toHeapNode)
                     {
-                        query_heap.Insert(to, to_weight, {node, true, to_duration, to_distance});
+                        query_heap.Insert(
+                            to, to_weight, {heapNode.node, true, to_duration, to_distance});
                     }
-                    else if (std::tie(to_weight, to_duration, to_distance, node) <
-                             std::tie(query_heap.GetKey(to),
-                                      query_heap.GetData(to).duration,
-                                      query_heap.GetData(to).distance,
-                                      query_heap.GetData(to).parent))
+                    else if (std::tie(to_weight, to_duration, to_distance, heapNode.node) <
+                             std::tie(toHeapNode->weight,
+                                      toHeapNode->data.duration,
+                                      toHeapNode->data.distance,
+                                      toHeapNode->data.parent))
                     {
-                        query_heap.GetData(to) = {node, true, to_duration, to_distance};
-                        query_heap.DecreaseKey(to, to_weight);
+                        toHeapNode->data = {heapNode.node, true, to_duration, to_distance};
+                        toHeapNode->weight = to_weight;
+                        query_heap.DecreaseKey(*toHeapNode);
                     }
                 }
                 ++source;
@@ -193,7 +198,13 @@ void relaxOutgoingEdges(const DataFacade<mld::Algorithm> &facade,
         }
     }
 
-    relaxBorderEdges<DIRECTION>(facade, node, weight, duration, distance, query_heap, level);
+    relaxBorderEdges<DIRECTION>(facade,
+                                heapNode.node,
+                                heapNode.weight,
+                                heapNode.data.duration,
+                                heapNode.data.distance,
+                                query_heap,
+                                level);
 }
 
 //
@@ -208,8 +219,8 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                 const std::vector<std::size_t> &phantom_indices,
                 const bool calculate_distance)
 {
-    std::vector<EdgeWeight> weights(phantom_indices.size(), INVALID_EDGE_WEIGHT);
-    std::vector<EdgeDuration> durations(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
+    std::vector<EdgeWeight> weights_table(phantom_indices.size(), INVALID_EDGE_WEIGHT);
+    std::vector<EdgeDuration> durations_table(phantom_indices.size(), MAXIMAL_EDGE_DURATION);
     std::vector<EdgeDistance> distances_table(calculate_distance ? phantom_indices.size() : 0,
                                               MAXIMAL_EDGE_DISTANCE);
     std::vector<NodeID> middle_nodes_table(phantom_indices.size(), SPECIAL_NODEID);
@@ -287,10 +298,10 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
                         distances_table.empty() ? nulldistance : distances_table[index];
 
                     if (std::tie(path_weight, path_duration, path_distance) <
-                        std::tie(weights[index], durations[index], current_distance))
+                        std::tie(weights_table[index], durations_table[index], current_distance))
                     {
-                        weights[index] = path_weight;
-                        durations[index] = path_duration;
+                        weights_table[index] = path_weight;
+                        durations_table[index] = path_duration;
                         current_distance = path_distance;
                         middle_nodes_table[index] = node;
                     }
@@ -368,28 +379,20 @@ oneToManySearch(SearchEngineData<Algorithm> &engine_working_data,
 
     while (!query_heap.Empty() && !target_nodes_index.empty())
     {
-        // Extract node from the heap
-        const auto node = query_heap.DeleteMin();
-        const auto weight = query_heap.GetKey(node);
-        const auto duration = query_heap.GetData(node).duration;
-        const auto distance = query_heap.GetData(node).distance;
+        // Extract node from the heap. Take a copy (no ref) because otherwise can be modified later
+        // if toHeapNode is the same
+        const auto heapNode = query_heap.DeleteMinGetHeapNode();
 
         // Update values
-        update_values(node, weight, duration, distance);
+        update_values(
+            heapNode.node, heapNode.weight, heapNode.data.duration, heapNode.data.distance);
 
         // Relax outgoing edges
-        relaxOutgoingEdges<DIRECTION>(facade,
-                                      node,
-                                      weight,
-                                      duration,
-                                      distance,
-                                      query_heap,
-                                      phantom_nodes,
-                                      phantom_index,
-                                      phantom_indices);
+        relaxOutgoingEdges<DIRECTION>(
+            facade, heapNode, query_heap, phantom_nodes, phantom_index, phantom_indices);
     }
 
-    return std::make_pair(durations, distances_table);
+    return std::make_pair(std::move(durations_table), std::move(distances_table));
 }
 
 //
@@ -408,15 +411,14 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
                         std::vector<NodeID> &middle_nodes_table,
                         const PhantomNode &phantom_node)
 {
-    const auto node = query_heap.DeleteMin();
-    const auto source_weight = query_heap.GetKey(node);
-    const auto source_duration = query_heap.GetData(node).duration;
-    const auto source_distance = query_heap.GetData(node).distance;
+    // Take a copy of the extracted node because otherwise could be modified later if toHeapNode is
+    // the same
+    const auto heapNode = query_heap.DeleteMinGetHeapNode();
 
     // Check if each encountered node has an entry
     const auto &bucket_list = std::equal_range(search_space_with_buckets.begin(),
                                                search_space_with_buckets.end(),
-                                               node,
+                                               heapNode.node,
                                                NodeBucket::Compare());
     for (const auto &current_bucket : boost::make_iterator_range(bucket_list))
     {
@@ -439,23 +441,21 @@ void forwardRoutingStep(const DataFacade<Algorithm> &facade,
         auto &current_distance = distances_table.empty() ? nulldistance : distances_table[location];
 
         // Check if new weight is better
-        auto new_weight = source_weight + target_weight;
-        auto new_duration = source_duration + target_duration;
-        auto new_distance = source_distance + target_distance;
+        auto new_weight = heapNode.weight + target_weight;
+        auto new_duration = heapNode.data.duration + target_duration;
+        auto new_distance = heapNode.data.distance + target_distance;
 
-        if (new_weight >= 0 &&
-            std::tie(new_weight, new_duration, new_distance) <
-                std::tie(current_weight, current_duration, current_distance))
+        if (new_weight >= 0 && std::tie(new_weight, new_duration, new_distance) <
+                                   std::tie(current_weight, current_duration, current_distance))
         {
             current_weight = new_weight;
             current_duration = new_duration;
             current_distance = new_distance;
-            middle_nodes_table[location] = node;
+            middle_nodes_table[location] = heapNode.node;
         }
     }
 
-    relaxOutgoingEdges<DIRECTION>(
-        facade, node, source_weight, source_duration, source_distance, query_heap, phantom_node);
+    relaxOutgoingEdges<DIRECTION>(facade, heapNode, query_heap, phantom_node);
 }
 
 template <bool DIRECTION>
@@ -465,28 +465,23 @@ void backwardRoutingStep(const DataFacade<Algorithm> &facade,
                          std::vector<NodeBucket> &search_space_with_buckets,
                          const PhantomNode &phantom_node)
 {
-    const auto node = query_heap.DeleteMin();
-    const auto target_weight = query_heap.GetKey(node);
-    const auto target_duration = query_heap.GetData(node).duration;
-    const auto target_distance = query_heap.GetData(node).distance;
-    const auto parent = query_heap.GetData(node).parent;
-    const auto from_clique_arc = query_heap.GetData(node).from_clique_arc;
+    // Take a copy of the extracted node because otherwise could be modified later if toHeapNode is
+    // the same
+    const auto heapNode = query_heap.DeleteMinGetHeapNode();
 
     // Store settled nodes in search space bucket
-    search_space_with_buckets.emplace_back(
-        node, parent, from_clique_arc, column_idx, target_weight, target_duration, target_distance);
+    search_space_with_buckets.emplace_back(heapNode.node,
+                                           heapNode.data.parent,
+                                           heapNode.data.from_clique_arc,
+                                           column_idx,
+                                           heapNode.weight,
+                                           heapNode.data.duration,
+                                           heapNode.data.distance);
 
     const auto &partition = facade.GetMultiLevelPartition();
     const auto maximal_level = partition.GetNumberOfLevels() - 1;
 
-    relaxOutgoingEdges<!DIRECTION>(facade,
-                                   node,
-                                   target_weight,
-                                   target_duration,
-                                   target_distance,
-                                   query_heap,
-                                   phantom_node,
-                                   maximal_level);
+    relaxOutgoingEdges<!DIRECTION>(facade, heapNode, query_heap, phantom_node, maximal_level);
 }
 
 template <bool DIRECTION>
@@ -606,7 +601,7 @@ manyToManySearch(SearchEngineData<Algorithm> &engine_working_data,
         }
     }
 
-    return std::make_pair(durations_table, distances_table);
+    return std::make_pair(std::move(durations_table), std::move(distances_table));
 }
 
 } // namespace mld
diff --git a/src/engine/routing_algorithms/map_matching.cpp b/src/engine/routing_algorithms/map_matching.cpp
index 7d1b75901..f5fbea093 100644
--- a/src/engine/routing_algorithms/map_matching.cpp
+++ b/src/engine/routing_algorithms/map_matching.cpp
@@ -65,7 +65,7 @@ inline void initializeHeap<mld::Algorithm>(SearchEngineData<mld::Algorithm> &eng
     const auto border_nodes_number = facade.GetMaxBorderNodeID() + 1;
     engine_working_data.InitializeOrClearFirstThreadLocalStorage(nodes_number, border_nodes_number);
 }
-}
+} // namespace
 
 template <typename Algorithm>
 SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
@@ -214,7 +214,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
             const auto &current_timestamps_list = candidates_list[t];
             const auto &current_coordinate = trace_coordinates[t];
 
-            const auto haversine_distance = util::coordinate_calculation::haversineDistance(
+            const auto haversine_distance = util::coordinate_calculation::greatCircleDistance(
                 prev_coordinate, current_coordinate);
             // assumes minumum of 4 m/s
             const EdgeWeight weight_upper_bound =
@@ -424,7 +424,7 @@ SubMatchingList mapMatching(SearchEngineData<Algorithm> &engine_working_data,
             reconstructed_indices,
             [&trace_distance, &trace_coordinates](const std::pair<std::size_t, std::size_t> &prev,
                                                   const std::pair<std::size_t, std::size_t> &curr) {
-                trace_distance += util::coordinate_calculation::haversineDistance(
+                trace_distance += util::coordinate_calculation::greatCircleDistance(
                     trace_coordinates[prev.first], trace_coordinates[curr.first]);
             });
 
diff --git a/src/engine/search_engine_data.cpp b/src/engine/search_engine_data.cpp
index 53912d7a1..fc35adbff 100644
--- a/src/engine/search_engine_data.cpp
+++ b/src/engine/search_engine_data.cpp
@@ -130,5 +130,5 @@ void SearchEngineData<MLD>::InitializeOrClearManyToManyThreadLocalStorage(
         many_to_many_heap.reset(new ManyToManyQueryHeap(number_of_nodes, number_of_boundary_nodes));
     }
 }
-}
-}
+} // namespace engine
+} // namespace osrm
diff --git a/src/extractor/compressed_edge_container.cpp b/src/extractor/compressed_edge_container.cpp
index 348afc5de..7510f85b0 100644
--- a/src/extractor/compressed_edge_container.cpp
+++ b/src/extractor/compressed_edge_container.cpp
@@ -396,5 +396,5 @@ std::unique_ptr<SegmentDataContainer> CompressedEdgeContainer::ToSegmentData()
 
     return std::move(segment_data);
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/edge_based_graph_factory.cpp b/src/extractor/edge_based_graph_factory.cpp
index 12e4ce0ec..edef3d589 100644
--- a/src/extractor/edge_based_graph_factory.cpp
+++ b/src/extractor/edge_based_graph_factory.cpp
@@ -51,10 +51,7 @@ template <> struct hash<std::pair<NodeID, NodeID>>
         return seed;
     }
 };
-}
-
-// Buffer size of turn_indexes_write_buffer to reduce number of write(v) syscals
-const constexpr int TURN_INDEX_WRITE_BUFFER_SIZE = 1000;
+} // namespace std
 
 namespace osrm
 {
@@ -242,7 +239,7 @@ void EdgeBasedGraphFactory::Run(
     const std::string &cnbg_ebg_mapping_path,
     const std::string &conditional_penalties_filename,
     const std::string &maneuver_overrides_filename,
-    const RestrictionMap &node_restriction_map,
+    const RestrictionMap &unconditional_node_restriction_map,
     const ConditionalRestrictionMap &conditional_node_restriction_map,
     const WayRestrictionMap &way_restriction_map,
     const std::vector<UnresolvedManeuverOverride> &unresolved_maneuver_overrides)
@@ -271,7 +268,7 @@ void EdgeBasedGraphFactory::Run(
                               turn_penalties_index_filename,
                               conditional_penalties_filename,
                               maneuver_overrides_filename,
-                              node_restriction_map,
+                              unconditional_node_restriction_map,
                               conditional_node_restriction_map,
                               way_restriction_map,
                               unresolved_maneuver_overrides);
@@ -377,17 +374,17 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
     // Add copies of the nodes
     {
         util::UnbufferedLog log;
-        const auto via_ways = way_restriction_map.DuplicatedNodeRepresentatives();
-        util::Percent progress(log, via_ways.size());
+        const auto via_edges = way_restriction_map.DuplicatedViaEdges();
+        util::Percent progress(log, via_edges.size());
 
         NodeID edge_based_node_id =
             NodeID(m_number_of_edge_based_nodes - way_restriction_map.NumberOfDuplicatedNodes());
         std::size_t progress_counter = 0;
         // allocate enough space for the mapping
-        for (const auto way : via_ways)
+        for (const auto edge : via_edges)
         {
-            const auto node_u = way.from;
-            const auto node_v = way.to;
+            const auto node_u = edge.from;
+            const auto node_v = edge.to;
             // we know that the edge exists as non-reversed edge
             const auto eid = m_node_based_graph.FindEdge(node_u, node_v);
 
@@ -415,6 +412,13 @@ EdgeBasedGraphFactory::GenerateEdgeExpandedNodes(const WayRestrictionMap &way_re
             m_edge_based_node_distances.push_back(
                 m_edge_based_node_distances[nbe_to_ebn_mapping[eid]]);
 
+            // Include duplicate nodes in cnbg to ebg mapping. This means a
+            // compressed node pair (u,v) can appear multiple times in this list.
+            // This is needed by the MLD partition step to ensure duplicate nodes
+            // are also assigned to partitions (the MLD partitioner is currently
+            // the only consumer of this mapping).
+            mapping.push_back(NBGToEBG{node_u, node_v, edge_based_node_id, SPECIAL_NODEID});
+
             edge_based_node_id++;
             progress.PrintStatus(progress_counter++);
         }
@@ -440,8 +444,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     const std::string &turn_penalties_index_filename,
     const std::string &conditional_penalties_filename,
     const std::string &maneuver_overrides_filename,
-    const RestrictionMap &node_restriction_map,
-    const ConditionalRestrictionMap &conditional_restriction_map,
+    const RestrictionMap &unconditional_node_restriction_map,
+    const ConditionalRestrictionMap &conditional_node_restriction_map,
     const WayRestrictionMap &way_restriction_map,
     const std::vector<UnresolvedManeuverOverride> &unresolved_maneuver_overrides)
 {
@@ -449,17 +453,13 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
     std::size_t node_based_edge_counter = 0;
 
-    storage::tar::FileWriter turn_penalties_index_file(
-        turn_penalties_index_filename, storage::tar::FileWriter::GenerateFingerprint);
-    turn_penalties_index_file.WriteFrom("/extractor/turn_index", (char *)nullptr, 0);
-
     SuffixTable street_name_suffix_table(scripting_environment);
     const auto &turn_lanes_data = transformTurnLaneMapIntoArrays(lane_description_map);
     intersection::MergableRoadDetector mergable_road_detector(m_node_based_graph,
                                                               m_edge_based_node_container,
                                                               m_coordinates,
                                                               m_compressed_edge_container,
-                                                              node_restriction_map,
+                                                              unconditional_node_restriction_map,
                                                               m_barrier_nodes,
                                                               turn_lanes_data,
                                                               name_table,
@@ -468,6 +468,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     // FIXME these need to be tuned in pre-allocated size
     std::vector<TurnPenalty> turn_weight_penalties;
     std::vector<TurnPenalty> turn_duration_penalties;
+    std::vector<lookup::TurnIndexBlock> turn_penalties_index;
 
     // Now, renumber all our maneuver overrides to use edge-based-nodes
     std::vector<StorageManeuverOverride> storage_maneuver_overrides;
@@ -487,14 +488,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
     {
         const NodeID node_count = m_node_based_graph.GetNumberOfNodes();
 
-        // Because we write TurnIndexBlock data as we go, we'll
-        // buffer them into groups of 1000 to reduce the syscall
-        // count by 1000x.  This doesn't need much memory, but
-        // greatly reduces the syscall overhead of writing lots
-        // of small objects
-        std::vector<lookup::TurnIndexBlock> turn_indexes_write_buffer;
-        turn_indexes_write_buffer.reserve(TURN_INDEX_WRITE_BUFFER_SIZE);
-
         // This struct is the buffered output of the `processor_stage`.  This data is
         // appended to the various output arrays/files by the `output_stage`.
         // same as IntersectionData, but grouped with edge to allow sorting after creating.
@@ -510,7 +503,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             m_edge_based_edge_list.push_back(edge_with_data.edge);
             turn_weight_penalties.push_back(edge_with_data.turn_weight_penalty);
             turn_duration_penalties.push_back(edge_with_data.turn_duration_penalty);
-            turn_indexes_write_buffer.push_back(edge_with_data.turn_index);
+            turn_penalties_index.push_back(edge_with_data.turn_index);
         };
 
         struct EdgesPipelineBuffer
@@ -558,44 +551,22 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             });
 
         // Generate edges for either artificial nodes or the main graph
-        const auto generate_edge = [this,
-                                    &scripting_environment,
-                                    weight_multiplier,
-                                    &conditional_restriction_map](
-            // what nodes will be used? In most cases this will be the id
-            // stored in the edge_data. In case of duplicated nodes (e.g.
-            // due to via-way restrictions), one/both of these might
-            // refer to a newly added edge based node
-            const auto edge_based_node_from,
-            const auto edge_based_node_to,
-            // the situation of the turn
-            const auto node_along_road_entering,
-            const auto node_based_edge_from,
-            const auto intersection_node,
-            const auto node_based_edge_to,
-            const auto &turn_angle,
-            const auto &road_legs_on_the_right,
-            const auto &road_legs_on_the_left,
-            const auto &edge_geometries) {
-
-            const auto node_restricted =
-                isRestricted(node_along_road_entering,
-                             intersection_node,
-                             m_node_based_graph.GetTarget(node_based_edge_to),
-                             conditional_restriction_map);
-
-            boost::optional<Conditional> conditional = boost::none;
-            if (node_restricted.first)
-            {
-                auto const &conditions = node_restricted.second->condition;
-                // get conditions of the restriction limiting the node
-                conditional = {{edge_based_node_from,
-                                edge_based_node_to,
-                                {static_cast<std::uint64_t>(-1),
-                                 m_coordinates[intersection_node],
-                                 conditions}}};
-            }
-
+        const auto generate_edge = [this, &scripting_environment, weight_multiplier](
+                                       // what nodes will be used? In most cases this will be the id
+                                       // stored in the edge_data. In case of duplicated nodes (e.g.
+                                       // due to via-way restrictions), one/both of these might
+                                       // refer to a newly added edge based node
+                                       const auto edge_based_node_from,
+                                       const auto edge_based_node_to,
+                                       // the situation of the turn
+                                       const auto node_along_road_entering,
+                                       const auto node_based_edge_from,
+                                       const auto intersection_node,
+                                       const auto node_based_edge_to,
+                                       const auto &turn_angle,
+                                       const auto &road_legs_on_the_right,
+                                       const auto &road_legs_on_the_left,
+                                       const auto &edge_geometries) {
             const auto &edge_data1 = m_node_based_graph.GetEdgeData(node_based_edge_from);
             const auto &edge_data2 = m_node_based_graph.GetEdgeData(node_based_edge_to);
 
@@ -691,9 +662,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
             lookup::TurnIndexBlock turn_index_block = {from_node, intersection_node, to_node};
 
             // insert data into the designated buffer
-            return std::make_pair(
-                EdgeWithData{edge_based_edge, turn_index_block, weight_penalty, duration_penalty},
-                conditional);
+            return EdgeWithData{
+                edge_based_edge, turn_index_block, weight_penalty, duration_penalty};
         };
 
         //
@@ -701,7 +671,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         //
         tbb::filter_t<tbb::blocked_range<NodeID>, EdgesPipelineBufferPtr> processor_stage(
             tbb::filter::parallel, [&](const tbb::blocked_range<NodeID> &intersection_node_range) {
-
                 auto buffer = std::make_shared<EdgesPipelineBuffer>();
                 buffer->nodes_processed = intersection_node_range.size();
 
@@ -752,27 +721,27 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                     {
                         ++node_based_edge_counter;
 
-                        const auto intersection_view =
-                            convertToIntersectionView(m_node_based_graph,
-                                                      m_edge_based_node_container,
-                                                      node_restriction_map,
-                                                      m_barrier_nodes,
-                                                      edge_geometries,
-                                                      turn_lanes_data,
-                                                      incoming_edge,
-                                                      outgoing_edges,
-                                                      merged_edge_ids);
+                        const auto connected_roads =
+                            extractor::intersection::getConnectedRoadsForEdgeGeometries(
+                                m_node_based_graph,
+                                m_edge_based_node_container,
+                                unconditional_node_restriction_map,
+                                m_barrier_nodes,
+                                turn_lanes_data,
+                                incoming_edge,
+                                edge_geometries,
+                                merged_edge_ids);
 
-                        // check if we are turning off a via way
-                        const auto turning_off_via_way =
-                            way_restriction_map.IsViaWay(incoming_edge.node, intersection_node);
+                        // check if this edge is part of a restriction via-way
+                        const auto is_restriction_via_edge =
+                            way_restriction_map.IsViaWayEdge(incoming_edge.node, intersection_node);
 
                         for (const auto &outgoing_edge : outgoing_edges)
                         {
                             auto is_turn_allowed =
                                 intersection::isTurnAllowed(m_node_based_graph,
                                                             m_edge_based_node_container,
-                                                            node_restriction_map,
+                                                            unconditional_node_restriction_map,
                                                             m_barrier_nodes,
                                                             edge_geometries,
                                                             turn_lanes_data,
@@ -784,12 +753,12 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                 continue;
 
                             const auto turn =
-                                std::find_if(intersection_view.begin(),
-                                             intersection_view.end(),
+                                std::find_if(connected_roads.begin(),
+                                             connected_roads.end(),
                                              [edge = outgoing_edge.edge](const auto &road) {
                                                  return road.eid == edge;
                                              });
-                            OSRM_ASSERT(turn != intersection_view.end(),
+                            OSRM_ASSERT(turn != connected_roads.end(),
                                         m_coordinates[intersection_node]);
 
                             std::vector<ExtractionTurnLeg> road_legs_on_the_right;
@@ -798,6 +767,37 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                             auto get_connected_road_info = [&](const auto &connected_edge) {
                                 const auto &edge_data =
                                     m_node_based_graph.GetEdgeData(connected_edge.eid);
+
+                                bool is_incoming, is_outgoing;
+                                if (edge_data.reversed)
+                                {
+                                    // If getConnectedRoads adds reversed edge it means
+                                    // this edge is incoming-only
+                                    is_incoming = true;
+                                    is_outgoing = false;
+                                }
+                                else
+                                {
+                                    // It does not add incoming edge if there is outgoing so we
+                                    // should find it ourselves
+                                    is_incoming = false;
+                                    auto reversed_edge = m_node_based_graph.FindEdge(
+                                        m_node_based_graph.GetTarget(connected_edge.eid),
+                                        intersection_node);
+                                    if (reversed_edge != SPECIAL_EDGEID)
+                                    {
+                                        const auto &reversed_edge_data =
+                                            m_node_based_graph.GetEdgeData(reversed_edge);
+
+                                        if (!reversed_edge_data.reversed)
+                                        {
+                                            is_incoming = true;
+                                        }
+                                    }
+
+                                    is_outgoing = true;
+                                }
+
                                 return ExtractionTurnLeg(
                                     edge_data.flags.restricted,
                                     edge_data.flags.road_classification.IsMotorwayClass(),
@@ -810,10 +810,8 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                      edge_data.duration) *
                                         36,
                                     edge_data.flags.road_classification.GetPriority(),
-                                    !connected_edge.entry_allowed ||
-                                        (edge_data.flags.forward &&
-                                         edge_data.flags.backward), // is incoming
-                                    connected_edge.entry_allowed);
+                                    is_incoming,
+                                    is_outgoing);
                             };
 
                             // all connected roads on the right of a u turn
@@ -821,35 +819,35 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                   guidance::DirectionModifier::UTurn;
                             if (is_uturn)
                             {
-                                if (turn != intersection_view.begin())
+                                if (turn != connected_roads.begin())
                                 {
-                                    std::transform(intersection_view.begin() + 1,
+                                    std::transform(connected_roads.begin() + 1,
                                                    turn,
                                                    std::back_inserter(road_legs_on_the_right),
                                                    get_connected_road_info);
                                 }
 
                                 std::transform(turn + 1,
-                                               intersection_view.end(),
+                                               connected_roads.end(),
                                                std::back_inserter(road_legs_on_the_right),
                                                get_connected_road_info);
                             }
                             else
                             {
-                                if (intersection_view.begin() != turn)
+                                if (connected_roads.begin() != turn)
                                 {
-                                    std::transform(intersection_view.begin() + 1,
+                                    std::transform(connected_roads.begin() + 1,
                                                    turn,
                                                    std::back_inserter(road_legs_on_the_right),
                                                    get_connected_road_info);
                                 }
                                 std::transform(turn + 1,
-                                               intersection_view.end(),
+                                               connected_roads.end(),
                                                std::back_inserter(road_legs_on_the_left),
                                                get_connected_road_info);
                             }
 
-                            if (is_uturn && turn != intersection_view.begin())
+                            if (is_uturn && turn != connected_roads.begin())
                             {
                                 util::Log(logWARNING)
                                     << "Turn is a u turn but not turning to the first connected "
@@ -857,7 +855,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                     << intersection_node << ", OSM link: "
                                     << toOSMLink(m_coordinates[intersection_node]);
                             }
-                            else if (turn == intersection_view.begin() && !is_uturn)
+                            else if (turn == connected_roads.begin() && !is_uturn)
                             {
                                 util::Log(logWARNING)
                                     << "Turn is a u turn but not classified as a u turn. Node ID: "
@@ -866,7 +864,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                             }
 
                             // In case a way restriction starts at a given location, add a turn onto
-                            // every artificial node eminating here.
+                            // every artificial node emanating here.
                             //
                             //     e - f
                             //     |
@@ -877,14 +875,14 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                             // ab via bc to cd
                             // ab via be to ef
                             //
-                            // has two artifical nodes (be/bc) with restrictions starting at `ab`.
+                            // has two artificial nodes (be/bc) with restrictions starting at `ab`.
                             // Since every restriction group (abc | abe) refers to the same
                             // artificial node, we simply have to find a single representative for
                             // the turn. Here we check whether the turn in question is the start of
                             // a via way restriction. If that should be the case, we switch the id
                             // of the edge-based-node for the target to the ID of the duplicated
                             // node associated with the turn. (e.g. ab via bc switches bc to bc_dup)
-                            auto const target_id = way_restriction_map.RemapIfRestricted(
+                            auto const target_id = way_restriction_map.RemapIfRestrictionStart(
                                 nbe_to_ebn_mapping[outgoing_edge.edge],
                                 incoming_edge.node,
                                 outgoing_edge.node,
@@ -893,18 +891,19 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
                             /***************************/
 
-                            const auto edgetarget =
+                            const auto outgoing_edge_target =
                                 m_node_based_graph.GetTarget(outgoing_edge.edge);
 
                             // TODO: this loop is not optimized - once we have a few
                             //       overrides available, we should index this for faster
                             //       lookups
-                            for (auto & override : unresolved_maneuver_overrides)
+                            for (auto &override : unresolved_maneuver_overrides)
                             {
                                 for (auto &turn : override.turn_sequence)
                                 {
                                     if (turn.from == incoming_edge.node &&
-                                        turn.via == intersection_node && turn.to == edgetarget)
+                                        turn.via == intersection_node &&
+                                        turn.to == outgoing_edge_target)
                                     {
                                         const auto &ebn_from =
                                             nbe_to_ebn_mapping[incoming_edge.edge];
@@ -916,7 +915,7 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                             }
 
                             { // scope to forget edge_with_data after
-                                const auto edge_with_data_and_condition =
+                                const auto edge_with_data =
                                     generate_edge(nbe_to_ebn_mapping[incoming_edge.edge],
                                                   target_id,
                                                   incoming_edge.node,
@@ -928,20 +927,30 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                   road_legs_on_the_left,
                                                   edge_geometries);
 
-                                buffer->continuous_data.push_back(
-                                    edge_with_data_and_condition.first);
-                                if (edge_with_data_and_condition.second)
+                                buffer->continuous_data.push_back(edge_with_data);
+
+                                // get conditional restrictions that apply to this turn
+                                const auto &restrictions =
+                                    conditional_node_restriction_map.Restrictions(
+                                        incoming_edge.node,
+                                        outgoing_edge.node,
+                                        outgoing_edge_target);
+                                for (const auto &restriction : restrictions)
                                 {
                                     buffer->conditionals.push_back(
-                                        *edge_with_data_and_condition.second);
+                                        {nbe_to_ebn_mapping[incoming_edge.edge],
+                                         target_id,
+                                         {static_cast<std::uint64_t>(-1),
+                                          m_coordinates[intersection_node],
+                                          restriction->condition}});
                                 }
                             }
 
-                            // when turning off a a via-way turn restriction, we need to not only
+                            // When on the edge of a via-way turn restriction, we need to not only
                             // handle the normal edges for the way, but also add turns for every
                             // duplicated node. This process is integrated here to avoid doing the
                             // turn analysis multiple times.
-                            if (turning_off_via_way)
+                            if (is_restriction_via_edge)
                             {
                                 const auto duplicated_nodes = way_restriction_map.DuplicatedNodeIDs(
                                     incoming_edge.node, intersection_node);
@@ -959,71 +968,91 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                     auto const node_at_end_of_turn =
                                         m_node_based_graph.GetTarget(outgoing_edge.edge);
 
-                                    const auto is_way_restricted = way_restriction_map.IsRestricted(
+                                    const auto is_restricted = way_restriction_map.IsRestricted(
                                         duplicated_node_id, node_at_end_of_turn);
 
-                                    if (is_way_restricted)
+                                    if (is_restricted)
                                     {
-                                        auto const restriction = way_restriction_map.GetRestriction(
-                                            duplicated_node_id, node_at_end_of_turn);
+                                        auto const &restrictions =
+                                            way_restriction_map.GetRestrictions(
+                                                duplicated_node_id, node_at_end_of_turn);
 
-                                        if (restriction.condition.empty())
+                                        auto const has_unconditional =
+                                            std::any_of(restrictions.begin(),
+                                                        restrictions.end(),
+                                                        [](const auto &restriction) {
+                                                            return restriction->IsUnconditional();
+                                                        });
+                                        if (has_unconditional)
                                             continue;
 
-                                        // add into delayed data
-                                        auto edge_with_data_and_condition =
-                                            generate_edge(from_id,
-                                                          nbe_to_ebn_mapping[outgoing_edge.edge],
-                                                          incoming_edge.node,
-                                                          incoming_edge.edge,
-                                                          outgoing_edge.node,
-                                                          outgoing_edge.edge,
-                                                          turn->angle,
-                                                          road_legs_on_the_right,
-                                                          road_legs_on_the_left,
-                                                          edge_geometries);
+                                        // From this via way, the outgoing edge will either:
+                                        // a) take a conditional turn transferring to a via
+                                        // path of an overlapping restriction.
+                                        // b) take a conditional turn to exit the restriction.
+                                        // If a) is applicable here, we change the target to be
+                                        // the duplicate restriction node.
+                                        auto const via_target_id =
+                                            way_restriction_map.RemapIfRestrictionVia(
+                                                nbe_to_ebn_mapping[outgoing_edge.edge],
+                                                from_id,
+                                                m_node_based_graph.GetTarget(outgoing_edge.edge),
+                                                m_number_of_edge_based_nodes);
 
-                                        buffer->delayed_data.push_back(
-                                            edge_with_data_and_condition.first);
-                                        if (edge_with_data_and_condition.second)
-                                        {
-                                            buffer->conditionals.push_back(
-                                                *edge_with_data_and_condition.second);
-                                        }
+                                        // add into delayed data
+                                        auto edge_with_data = generate_edge(from_id,
+                                                                            via_target_id,
+                                                                            incoming_edge.node,
+                                                                            incoming_edge.edge,
+                                                                            outgoing_edge.node,
+                                                                            outgoing_edge.edge,
+                                                                            turn->angle,
+                                                                            road_legs_on_the_right,
+                                                                            road_legs_on_the_left,
+                                                                            edge_geometries);
+
+                                        buffer->delayed_data.push_back(edge_with_data);
 
                                         // also add the conditions for the way
-                                        if (is_way_restricted && !restriction.condition.empty())
+                                        for (const auto &restriction : restrictions)
                                         {
-                                            // add a new conditional for the edge we just created
+                                            // add a new conditional for the edge we just
+                                            // created
                                             buffer->conditionals.push_back(
                                                 {from_id,
-                                                 nbe_to_ebn_mapping[outgoing_edge.edge],
+                                                 via_target_id,
                                                  {static_cast<std::uint64_t>(-1),
                                                   m_coordinates[intersection_node],
-                                                  restriction.condition}});
+                                                  restriction->condition}});
                                         }
                                     }
                                     else
                                     {
-                                        auto edge_with_data_and_condition =
-                                            generate_edge(from_id,
-                                                          nbe_to_ebn_mapping[outgoing_edge.edge],
-                                                          incoming_edge.node,
-                                                          incoming_edge.edge,
-                                                          outgoing_edge.node,
-                                                          outgoing_edge.edge,
-                                                          turn->angle,
-                                                          road_legs_on_the_right,
-                                                          road_legs_on_the_left,
-                                                          edge_geometries);
+                                        // From this via way, the outgoing edge will either:
+                                        // a) continue along the current via path
+                                        // b) transfer to a via path of an overlapping restriction.
+                                        // c) exit the restriction
+                                        // If a) or b) are applicable here, we change the target to
+                                        // be the duplicate restriction node.
+                                        auto const via_target_id =
+                                            way_restriction_map.RemapIfRestrictionVia(
+                                                nbe_to_ebn_mapping[outgoing_edge.edge],
+                                                from_id,
+                                                m_node_based_graph.GetTarget(outgoing_edge.edge),
+                                                m_number_of_edge_based_nodes);
 
-                                        buffer->delayed_data.push_back(
-                                            edge_with_data_and_condition.first);
-                                        if (edge_with_data_and_condition.second)
-                                        {
-                                            buffer->conditionals.push_back(
-                                                *edge_with_data_and_condition.second);
-                                        }
+                                        auto edge_with_data = generate_edge(from_id,
+                                                                            via_target_id,
+                                                                            incoming_edge.node,
+                                                                            incoming_edge.edge,
+                                                                            outgoing_edge.node,
+                                                                            outgoing_edge.edge,
+                                                                            turn->angle,
+                                                                            road_legs_on_the_right,
+                                                                            road_legs_on_the_left,
+                                                                            edge_geometries);
+
+                                        buffer->delayed_data.push_back(edge_with_data);
                                     }
                                 }
                             }
@@ -1040,7 +1069,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
         std::vector<EdgeWithData> delayed_data;
         tbb::filter_t<EdgesPipelineBufferPtr, void> output_stage(
             tbb::filter::serial_in_order, [&](auto buffer) {
-
                 routing_progress.PrintAddition(buffer->nodes_processed);
 
                 m_connectivity_checksum = buffer->checksum.update_checksum(m_connectivity_checksum);
@@ -1054,15 +1082,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                 // NOTE: potential overflow here if we hit 2^32 routable edges
                 BOOST_ASSERT(m_edge_based_edge_list.size() <= std::numeric_limits<NodeID>::max());
 
-                // Buffer writes to reduce syscall count
-                if (turn_indexes_write_buffer.size() >= TURN_INDEX_WRITE_BUFFER_SIZE)
-                {
-                    turn_penalties_index_file.ContinueFrom("/extractor/turn_index",
-                                                           turn_indexes_write_buffer.data(),
-                                                           turn_indexes_write_buffer.size());
-                    turn_indexes_write_buffer.clear();
-                }
-
                 // Copy via-way restrictions delayed data
                 delayed_data.insert(
                     delayed_data.end(), buffer->delayed_data.begin(), buffer->delayed_data.end());
@@ -1118,15 +1137,6 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
 
             storage_maneuver_overrides.push_back(storage_override);
         }
-
-        // Flush the turn_indexes_write_buffer if it's not empty
-        if (!turn_indexes_write_buffer.empty())
-        {
-            turn_penalties_index_file.ContinueFrom("/extractor/turn_index",
-                                                   turn_indexes_write_buffer.data(),
-                                                   turn_indexes_write_buffer.size());
-            turn_indexes_write_buffer.clear();
-        }
     }
     {
         util::Log() << "Sorting and writing " << storage_maneuver_overrides.size()
@@ -1162,9 +1172,11 @@ void EdgeBasedGraphFactory::GenerateEdgeExpandedEdges(
                                                    indexed_conditionals);
 
     // write weight penalties per turn
-    BOOST_ASSERT(turn_weight_penalties.size() == turn_duration_penalties.size());
+    BOOST_ASSERT(turn_weight_penalties.size() == turn_duration_penalties.size() &&
+                 turn_weight_penalties.size() == turn_penalties_index.size());
     files::writeTurnWeightPenalty(turn_weight_penalties_filename, turn_weight_penalties);
     files::writeTurnDurationPenalty(turn_duration_penalties_filename, turn_duration_penalties);
+    files::writeTurnPenaltiesIndex(turn_penalties_index_filename, turn_penalties_index);
 
     util::Log() << "Generated " << m_edge_based_node_segments.size() << " edge based node segments";
     util::Log() << "Node-based graph contains " << node_based_edge_counter << " edges";
diff --git a/src/extractor/extraction_containers.cpp b/src/extractor/extraction_containers.cpp
index be4264825..24d7b5e76 100644
--- a/src/extractor/extraction_containers.cpp
+++ b/src/extractor/extraction_containers.cpp
@@ -10,17 +10,12 @@
 
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
-#include "util/fingerprint.hpp"
+#include "util/for_each_indexed.hpp"
 #include "util/log.hpp"
 #include "util/timing_util.hpp"
 
-#include "storage/io.hpp"
-
 #include <boost/assert.hpp>
-#include <boost/filesystem.hpp>
-#include <boost/filesystem/fstream.hpp>
 #include <boost/numeric/conversion/cast.hpp>
-#include <boost/ref.hpp>
 
 #include <tbb/parallel_sort.h>
 
@@ -99,7 +94,65 @@ inline NodeID mapExternalToInternalNodeID(Iter first, Iter last, const OSMNodeID
     return (it == last || value < *it) ? SPECIAL_NODEID
                                        : static_cast<NodeID>(std::distance(first, it));
 }
+
+/**
+ *   Here's what these properties represent on the node-based-graph
+ *       way "ABCD"                         way "AB"
+ *  -----------------------------------------------------------------
+ *     ⬇   A  first_segment_source_id
+ *     ⬇   |
+ *     ⬇︎   B  first_segment_target_id      A  first_segment_source_id
+ *     ⬇︎   |                            ⬇ |  last_segment_source_id
+ *     ⬇︎   |                            ⬇ |
+ *     ⬇︎   |                               B  first_segment_target_id
+ *     ⬇︎   C  last_segment_source_id          last_segment_target_id
+ *     ⬇︎   |
+ *     ⬇︎   D  last_segment_target_id
+ *
+ * Finds the point where two ways connect at the end, and returns the 3
+ * node-based nodes that describe the turn (the node just before, the
+ * node at the turn, and the next node after the turn)
+ **/
+std::tuple<OSMNodeID, OSMNodeID, OSMNodeID> find_turn_nodes(const oe::NodesOfWay &from,
+                                                            const oe::NodesOfWay &via,
+                                                            const OSMNodeID &intersection_node)
+{
+    // connection node needed to choose orientation if from and via are the same way. E.g. u-turns
+    if (intersection_node == SPECIAL_OSM_NODEID ||
+        intersection_node == from.first_segment_source_id())
+    {
+        if (from.first_segment_source_id() == via.first_segment_source_id())
+        {
+            return std::make_tuple(from.first_segment_target_id(),
+                                   via.first_segment_source_id(),
+                                   via.first_segment_target_id());
+        }
+        if (from.first_segment_source_id() == via.last_segment_target_id())
+        {
+            return std::make_tuple(from.first_segment_target_id(),
+                                   via.last_segment_target_id(),
+                                   via.last_segment_source_id());
+        }
+    }
+    if (intersection_node == SPECIAL_OSM_NODEID ||
+        intersection_node == from.last_segment_target_id())
+    {
+        if (from.last_segment_target_id() == via.first_segment_source_id())
+        {
+            return std::make_tuple(from.last_segment_source_id(),
+                                   via.first_segment_source_id(),
+                                   via.first_segment_target_id());
+        }
+        if (from.last_segment_target_id() == via.last_segment_target_id())
+        {
+            return std::make_tuple(from.last_segment_source_id(),
+                                   via.last_segment_target_id(),
+                                   via.last_segment_source_id());
+        }
+    }
+    return std::make_tuple(SPECIAL_OSM_NODEID, SPECIAL_OSM_NODEID, SPECIAL_OSM_NODEID);
 }
+} // namespace
 
 namespace osrm
 {
@@ -116,6 +169,8 @@ ExtractionContainers::ExtractionContainers()
     name_offsets.push_back(0);
     // Insert the total length sentinel (corresponds to the next name string offset)
     name_offsets.push_back(0);
+    // Sentinel for offset into used_nodes
+    way_node_id_offsets.push_back(0);
 }
 
 /**
@@ -134,6 +189,9 @@ void ExtractionContainers::PrepareData(ScriptingEnvironment &scripting_environme
 {
     storage::tar::FileWriter writer(osrm_path, storage::tar::FileWriter::GenerateFingerprint);
 
+    const auto restriction_ways = IdentifyRestrictionWays();
+    const auto maneuver_override_ways = IdentifyManeuverOverrideWays();
+
     PrepareNodes();
     WriteNodes(writer);
     PrepareEdges(scripting_environment);
@@ -142,20 +200,8 @@ void ExtractionContainers::PrepareData(ScriptingEnvironment &scripting_environme
     WriteEdges(writer);
     WriteMetadata(writer);
 
-    /* Sort these so that searching is a bit faster later on */
-    {
-        util::UnbufferedLog log;
-        log << "Sorting used ways         ... ";
-        TIMER_START(sort_ways);
-        tbb::parallel_sort(way_start_end_id_list.begin(),
-                           way_start_end_id_list.end(),
-                           FirstAndLastSegmentOfWayCompare());
-        TIMER_STOP(sort_ways);
-        log << "ok, after " << TIMER_SEC(sort_ways) << "s";
-    }
-
-    PrepareManeuverOverrides();
-    PrepareRestrictions();
+    PrepareManeuverOverrides(maneuver_override_ways);
+    PrepareRestrictions(restriction_ways);
     WriteCharData(name_file_name);
 }
 
@@ -277,8 +323,8 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
         {
             if (edge_iterator->result.osm_source_id < node_iterator->node_id)
             {
-                util::Log(logDEBUG) << "Found invalid node reference "
-                                    << edge_iterator->result.source;
+                util::Log(logDEBUG)
+                    << "Found invalid node reference " << edge_iterator->result.source;
                 edge_iterator->result.source = SPECIAL_NODEID;
                 ++edge_iterator;
                 continue;
@@ -388,7 +434,7 @@ void ExtractionContainers::PrepareEdges(ScriptingEnvironment &scripting_environm
             const auto duration = edge_iterator->duration_data(distance);
 
             const auto accurate_distance =
-                util::coordinate_calculation::fccApproximateDistance(source_coord, target_coord);
+                util::coordinate_calculation::greatCircleDistance(source_coord, target_coord);
 
             ExtractionSegment segment(source_coord, target_coord, distance, weight, duration);
             scripting_environment.ProcessSegment(segment);
@@ -665,47 +711,52 @@ void ExtractionContainers::WriteNodes(storage::tar::FileWriter &writer) const
     util::Log() << "Processed " << max_internal_node_id << " nodes";
 }
 
-void ExtractionContainers::PrepareManeuverOverrides()
+ExtractionContainers::ReferencedWays ExtractionContainers::IdentifyManeuverOverrideWays()
 {
-    std::unordered_map<OSMWayID, FirstAndLastSegmentOfWay> referenced_ways;
+    ReferencedWays maneuver_override_ways;
 
     // prepare for extracting source/destination nodes for all maneuvers
-    {
-        util::UnbufferedLog log;
-        log << "Collecting start/end information on " << external_maneuver_overrides_list.size()
-            << " maneuver overrides...";
-        TIMER_START(prepare_maneuver_overrides);
+    util::UnbufferedLog log;
+    log << "Collecting way information on " << external_maneuver_overrides_list.size()
+        << " maneuver overrides...";
+    TIMER_START(identify_maneuver_override_ways);
 
-        const auto mark_ids = [&](auto const &external_maneuver_override) {
-            FirstAndLastSegmentOfWay dummy_segment{
-                MAX_OSM_WAYID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID};
-            std::for_each(external_maneuver_override.via_ways.begin(),
-                          external_maneuver_override.via_ways.end(),
-                          [&referenced_ways, dummy_segment](const auto &element) {
-                              referenced_ways[element] = dummy_segment;
-                          });
-        };
+    const auto mark_ids = [&](auto const &external_maneuver_override) {
+        NodesOfWay dummy_segment{MAX_OSM_WAYID, {MAX_OSM_NODEID, MAX_OSM_NODEID}};
+        std::for_each(external_maneuver_override.via_ways.begin(),
+                      external_maneuver_override.via_ways.end(),
+                      [&maneuver_override_ways, dummy_segment](const auto &element) {
+                          maneuver_override_ways[element] = dummy_segment;
+                      });
+    };
 
-        // First, make an empty hashtable keyed by the ways referenced
-        // by the maneuver overrides
-        std::for_each(external_maneuver_overrides_list.begin(),
-                      external_maneuver_overrides_list.end(),
-                      mark_ids);
+    // First, make an empty hashtable keyed by the ways referenced
+    // by the maneuver overrides
+    std::for_each(
+        external_maneuver_overrides_list.begin(), external_maneuver_overrides_list.end(), mark_ids);
 
-        const auto set_ids = [&](auto const &start_end) {
-            auto itr = referenced_ways.find(start_end.way_id);
-            if (itr != referenced_ways.end())
-                itr->second = start_end;
-        };
+    const auto set_ids = [&](size_t way_list_idx, auto const &way_id) {
+        auto itr = maneuver_override_ways.find(way_id);
+        if (itr != maneuver_override_ways.end())
+        {
+            auto node_start_itr = used_node_id_list.begin() + way_node_id_offsets[way_list_idx];
+            auto node_end_itr = used_node_id_list.begin() + way_node_id_offsets[way_list_idx + 1];
+            itr->second = NodesOfWay(way_id, std::vector<OSMNodeID>(node_start_itr, node_end_itr));
+        }
+    };
 
-        // Then, populate the values in that hashtable for only the ways
-        // referenced
-        std::for_each(way_start_end_id_list.cbegin(), way_start_end_id_list.cend(), set_ids);
+    // Then, populate the values in that hashtable for only the ways
+    // referenced
+    util::for_each_indexed(ways_list, set_ids);
 
-        TIMER_STOP(prepare_maneuver_overrides);
-        log << "ok, after " << TIMER_SEC(prepare_maneuver_overrides) << "s";
-    }
+    TIMER_STOP(identify_maneuver_override_ways);
+    log << "ok, after " << TIMER_SEC(identify_maneuver_override_ways) << "s";
 
+    return maneuver_override_ways;
+}
+
+void ExtractionContainers::PrepareManeuverOverrides(const ReferencedWays &maneuver_override_ways)
+{
     auto const osm_node_to_internal_nbn = [&](auto const osm_node) {
         auto internal = mapExternalToInternalNodeID(
             used_node_id_list.begin(), used_node_id_list.end(), osm_node);
@@ -716,83 +767,34 @@ void ExtractionContainers::PrepareManeuverOverrides()
         return internal;
     };
 
-    // Given
-    // a -- b - ????????? - c -- d as via segment
-    // and either
-    // d -- e - ????????? - f -- g or
-    // h -- i - ????????? - j -- a
-    // return
-    // (d,e) or (j,a) as entry-segment
-
-    /**
-     *   Here's what these properties represent on the node-based-graph
-     *       way "ABCD"                         way "AB"
-     *  -----------------------------------------------------------------
-     *     ⬇   A  first_segment_source_id
-     *     ⬇   |
-     *     ⬇︎   B  first_segment_target_id      A  first_segment_source_id
-     *     ⬇︎   |                            ⬇ |  last_segment_source_id
-     *     ⬇︎   |                            ⬇ |
-     *     ⬇︎   |                               B  first_segment_target_id
-     *     ⬇︎   C  last_segment_source_id          last_segment_target_id
-     *     ⬇︎   |
-     *     ⬇︎   D  last_segment_target_id
-     *
-     * Finds the point where two ways connect at the end, and returns the 3
-     * node-based nodes that describe the turn (the node just before, the
-     * node at the turn, and the next node after the turn)
-     **/
-    auto const find_turn_from_way_tofrom_nodes = [&](auto const &from_segment,
-                                                     auto const &to_segment) {
-
-        if (from_segment.first_segment_source_id == to_segment.first_segment_source_id)
-        {
-            return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.first_segment_target_id),
-                                 osm_node_to_internal_nbn(from_segment.first_segment_source_id),
-                                 osm_node_to_internal_nbn(to_segment.first_segment_target_id)};
-        }
-        else if (from_segment.first_segment_source_id == to_segment.last_segment_target_id)
-        {
-            return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.first_segment_target_id),
-                                 osm_node_to_internal_nbn(from_segment.first_segment_source_id),
-                                 osm_node_to_internal_nbn(to_segment.last_segment_source_id)};
-        }
-        else if (from_segment.last_segment_target_id == to_segment.first_segment_source_id)
-        {
-            return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.last_segment_source_id),
-                                 osm_node_to_internal_nbn(from_segment.last_segment_target_id),
-                                 osm_node_to_internal_nbn(to_segment.first_segment_target_id)};
-        }
-        else if (from_segment.last_segment_target_id == to_segment.last_segment_target_id)
-        {
-            return NodeBasedTurn{osm_node_to_internal_nbn(from_segment.last_segment_source_id),
-                                 osm_node_to_internal_nbn(from_segment.last_segment_target_id),
-                                 osm_node_to_internal_nbn(to_segment.last_segment_source_id)};
-        }
-        util::Log(logDEBUG) << "Maneuver override ways " << from_segment.way_id << " and "
-                            << to_segment.way_id << " are not connected";
-        return NodeBasedTurn{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
-    };
-
     auto const get_turn_from_way_pair = [&](const OSMWayID &from_id, const OSMWayID &to_id) {
-        auto const from_segment_itr = referenced_ways.find(from_id);
+        auto const from_segment_itr = maneuver_override_ways.find(from_id);
         if (from_segment_itr->second.way_id != from_id)
         {
             util::Log(logDEBUG) << "Override references invalid way: " << from_id;
             return NodeBasedTurn{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
         }
 
-        auto const to_segment_itr = referenced_ways.find(to_id);
+        auto const to_segment_itr = maneuver_override_ways.find(to_id);
         if (to_segment_itr->second.way_id != to_id)
         {
             util::Log(logDEBUG) << "Override references invalid way: " << to_id;
             return NodeBasedTurn{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
         }
 
-        auto result =
-            find_turn_from_way_tofrom_nodes(from_segment_itr->second, to_segment_itr->second);
-
-        return result;
+        OSMNodeID from, via, to;
+        std::tie(from, via, to) =
+            find_turn_nodes(from_segment_itr->second, to_segment_itr->second, SPECIAL_OSM_NODEID);
+        if (via == SPECIAL_OSM_NODEID)
+        {
+            // unconnected
+            util::Log(logDEBUG) << "Maneuver override ways " << from_segment_itr->second.way_id
+                                << " and " << to_segment_itr->second.way_id << " are not connected";
+            return NodeBasedTurn{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
+        }
+        return NodeBasedTurn{osm_node_to_internal_nbn(from),
+                             osm_node_to_internal_nbn(via),
+                             osm_node_to_internal_nbn(to)};
     };
 
     const auto strings_to_turn_type_and_direction = [](const std::string &turn_string,
@@ -861,7 +863,6 @@ void ExtractionContainers::PrepareManeuverOverrides()
     // Later, the UnresolvedManeuverOverride will be converted into a final ManeuverOverride
     // once the edge-based-node IDs are generated by the edge-based-graph-factory
     const auto transform = [&](const auto &external, auto &internal) {
-
         // Create a stub override
         auto maneuver_override =
             UnresolvedManeuverOverride{{},
@@ -911,7 +912,7 @@ void ExtractionContainers::PrepareManeuverOverrides()
     // Transforming the overrides into the dedicated internal types
     {
         util::UnbufferedLog log;
-        log << "Collecting start/end information on " << external_maneuver_overrides_list.size()
+        log << "Collecting node information on " << external_maneuver_overrides_list.size()
             << " maneuver overrides...";
         TIMER_START(transform);
         std::for_each(external_maneuver_overrides_list.begin(),
@@ -922,54 +923,64 @@ void ExtractionContainers::PrepareManeuverOverrides()
     }
 }
 
-void ExtractionContainers::PrepareRestrictions()
+ExtractionContainers::ReferencedWays ExtractionContainers::IdentifyRestrictionWays()
 {
+    // Contains the nodes of each way that is part of an restriction
+    ReferencedWays restriction_ways;
 
-    // contain the start/end nodes of each way that is part of an restriction
-    std::unordered_map<OSMWayID, FirstAndLastSegmentOfWay> referenced_ways;
+    // Prepare for extracting nodes for all restrictions
+    util::UnbufferedLog log;
+    log << "Collecting way information on " << restrictions_list.size() << " restrictions...";
+    TIMER_START(identify_restriction_ways);
 
-    // prepare for extracting source/destination nodes for all restrictions
-    {
-        util::UnbufferedLog log;
-        log << "Collecting start/end information on " << restrictions_list.size()
-            << " restrictions...";
-        TIMER_START(prepare_restrictions);
-
-        const auto mark_ids = [&](auto const &turn_restriction) {
-            FirstAndLastSegmentOfWay dummy_segment{
-                MAX_OSM_WAYID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID, MAX_OSM_NODEID};
-            if (turn_restriction.Type() == RestrictionType::WAY_RESTRICTION)
+    // Enter invalid IDs into the map to indicate that we want to find out about
+    // nodes of these ways.
+    const auto mark_ids = [&](auto const &turn_restriction) {
+        NodesOfWay dummy_segment{MAX_OSM_WAYID, {MAX_OSM_NODEID, MAX_OSM_NODEID}};
+        if (turn_restriction.Type() == RestrictionType::WAY_RESTRICTION)
+        {
+            const auto &way = turn_restriction.AsWayRestriction();
+            restriction_ways[way.from] = dummy_segment;
+            restriction_ways[way.to] = dummy_segment;
+            for (const auto &v : way.via)
             {
-                const auto &way = turn_restriction.AsWayRestriction();
-                referenced_ways[way.from] = dummy_segment;
-                referenced_ways[way.to] = dummy_segment;
-                referenced_ways[way.via] = dummy_segment;
+                restriction_ways[v] = dummy_segment;
             }
-            else
-            {
-                BOOST_ASSERT(turn_restriction.Type() == RestrictionType::NODE_RESTRICTION);
-                const auto &node = turn_restriction.AsNodeRestriction();
-                referenced_ways[node.from] = dummy_segment;
-                referenced_ways[node.to] = dummy_segment;
-            }
-        };
+        }
+        else
+        {
+            BOOST_ASSERT(turn_restriction.Type() == RestrictionType::NODE_RESTRICTION);
+            const auto &node = turn_restriction.AsNodeRestriction();
+            restriction_ways[node.from] = dummy_segment;
+            restriction_ways[node.to] = dummy_segment;
+        }
+    };
 
-        std::for_each(restrictions_list.begin(), restrictions_list.end(), mark_ids);
+    std::for_each(restrictions_list.begin(), restrictions_list.end(), mark_ids);
 
-        // enter invalid IDs into the above maps to indicate that we want to find out about
-        // start/end
-        // nodes of these ways
-        // update the values for all edges already sporting SPECIAL_NODEID
-        const auto set_ids = [&](auto const &start_end) {
-            auto itr = referenced_ways.find(start_end.way_id);
-            if (itr != referenced_ways.end())
-                itr->second = start_end;
-        };
+    // Update the values for all ways already sporting SPECIAL_NODEID
+    const auto set_ids = [&](const size_t way_list_idx, auto const &way_id) {
+        auto itr = restriction_ways.find(way_id);
+        if (itr != restriction_ways.end())
+        {
+            const auto node_start_offset =
+                used_node_id_list.begin() + way_node_id_offsets[way_list_idx];
+            const auto node_end_offset =
+                used_node_id_list.begin() + way_node_id_offsets[way_list_idx + 1];
+            itr->second =
+                NodesOfWay(way_id, std::vector<OSMNodeID>(node_start_offset, node_end_offset));
+        }
+    };
 
-        std::for_each(way_start_end_id_list.cbegin(), way_start_end_id_list.cend(), set_ids);
-        TIMER_STOP(prepare_restrictions);
-        log << "ok, after " << TIMER_SEC(prepare_restrictions) << "s";
-    }
+    util::for_each_indexed(ways_list, set_ids);
+    TIMER_STOP(identify_restriction_ways);
+    log << "ok, after " << TIMER_SEC(identify_restriction_ways) << "s";
+
+    return restriction_ways;
+}
+
+void ExtractionContainers::PrepareRestrictions(const ReferencedWays &restriction_ways)
+{
 
     auto const to_internal = [&](auto const osm_node) {
         auto internal = mapExternalToInternalNodeID(
@@ -981,166 +992,242 @@ void ExtractionContainers::PrepareRestrictions()
         return internal;
     };
 
-    // Given
-    // a -- b - ????????? - c -- d as via segment
-    // and either
-    // d -- e - ????????? - f -- g or
-    // h -- i - ????????? - j -- a
-    // (d,e) or (j,a) as entry-segment
-    auto const find_node_restriction =
-        [&](auto const &segment, auto const &via_segment, auto const via_node) {
-            // In case of way-restrictions, via-node will be set to MAX_OSM_NODEID to signal
-            // that
-            // the node is not present.
-            // connected at the front of the segment
-            // Turn restrictions are described as a restriction between the two segments closest
-            // to
-            // the shared via-node on the from and to ways. Graph compression will later
-            // renumber
-            // the from and to internal node IDs as nodes are plucked out of the node-based
-            // graph.
-            if (via_node == MAX_OSM_NODEID || segment.first_segment_source_id == via_node)
+    // Way restrictions are comprised of:
+    // 1. The segment in the from way that intersects with the via path
+    // 2. All segments that make up the via path
+    // 3. The segment in the to way that intersects with the via path.
+    //
+    // from: [a, b, c, d, e]
+    // via: [[f, g, h, i, j], [k, l], [m, n, o]]
+    // to: [p, q, r, s]
+    //
+    // First establish the orientation of the from/via intersection by finding which end
+    // nodes both ways share. From this we can select the from segment.
+    //
+    // intersect | from segment | next_connection
+    //    a=f    |      b,a     |        f
+    //    a=j    |      b,a     |        j
+    //    e=f    |      e,d     |        f
+    //    e=j    |      e,d     |        j
+    //
+    // Use the next connection to inform the orientation of the first via
+    // way and the intersection between first and second via ways.
+    //
+    // next_connection | intersect | via result  | next_next_connection
+    //       f         |    j=k    | [f,g,h,i,j] |      k
+    //       f         |    j=l    | [f,g,h,i,j] |      l
+    //       j         |    f=k    | [j,i,h,g,f] |      k
+    //       j         |    f=l    | [j,i,h,g,f] |      l
+    //
+    // This is continued for the remaining via ways, appending to the via result
+    //
+    // The final via/to intersection also uses the next_connection information in a similar fashion.
+    //
+    // next_connection | intersect | to_segment
+    //       m         |    o=p    |    p,q
+    //       m         |    o=s    |    s,r
+    //       o         |    m=p    |    p,q
+    //       o         |    m=s    |    s,r
+    //
+    // The final result is a list of nodes that represent a valid from->via->to path through the
+    // ways.
+    //
+    // E.g. if intersection nodes are a=j, f=l, k=o, m=s
+    // the result will be {e [d,c,b,a,i,h,g,f,k,n,m] r}
+    auto const find_way_restriction = [&](const NodesOfWay &from_way,
+                                          const std::vector<NodesOfWay> &via_ways,
+                                          const NodesOfWay &to_way) {
+        BOOST_ASSERT(!via_ways.empty());
+
+        WayRestriction restriction;
+
+        // Find the orientation of the connected ways starting with the from-via intersection.
+        OSMNodeID from, via;
+        std::tie(from, via, std::ignore) =
+            find_turn_nodes(from_way, via_ways.front(), SPECIAL_OSM_NODEID);
+        if (via == SPECIAL_OSM_NODEID)
+        {
+            util::Log(logDEBUG) << "Restriction has unconnected from and via ways: "
+                                << from_way.way_id << ", " << via_ways.front().way_id;
+            return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
+        }
+        restriction.from = to_internal(from);
+        restriction.via.push_back(to_internal(via));
+
+        // Use the connection node from the previous intersection to inform our conversion of
+        // via ways into internal nodes.
+        OSMNodeID next_connection = via;
+        for (const auto &via_way : via_ways)
+        {
+            if (next_connection == via_way.first_segment_source_id())
             {
-                if (segment.first_segment_source_id == via_segment.first_segment_source_id)
-                {
-                    return NodeRestriction{to_internal(segment.first_segment_target_id),
-                                           to_internal(segment.first_segment_source_id),
-                                           to_internal(via_segment.first_segment_target_id)};
-                }
-                else if (segment.first_segment_source_id == via_segment.last_segment_target_id)
-                {
-                    return NodeRestriction{to_internal(segment.first_segment_target_id),
-                                           to_internal(segment.first_segment_source_id),
-                                           to_internal(via_segment.last_segment_source_id)};
-                }
+                std::transform(std::next(via_way.node_ids.begin()),
+                               via_way.node_ids.end(),
+                               std::back_inserter(restriction.via),
+                               to_internal);
+                next_connection = via_way.last_segment_target_id();
+            }
+            else if (next_connection == via_way.last_segment_target_id())
+            {
+                std::transform(std::next(via_way.node_ids.rbegin()),
+                               via_way.node_ids.rend(),
+                               std::back_inserter(restriction.via),
+                               to_internal);
+                next_connection = via_way.first_segment_source_id();
+            }
+            else
+            {
+                util::Log(logDEBUG) << "Restriction has unconnected via way: " << via_way.way_id
+                                    << " to node " << next_connection;
+                return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
+            }
+        }
+
+        // Add the final to node after the via-to intersection.
+        if (next_connection == to_way.first_segment_source_id())
+        {
+            restriction.to = to_internal(to_way.first_segment_target_id());
+        }
+        else if (next_connection == to_way.last_segment_target_id())
+        {
+            restriction.to = to_internal(to_way.last_segment_source_id());
+        }
+        else
+        {
+            util::Log(logDEBUG) << "Restriction has unconnected via and to ways: "
+                                << via_ways.back().way_id << ", " << to_way.way_id;
+            return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
+        }
+        return restriction;
+    };
+
+    // Check if we were able to resolve all the involved OSM elements before translating to an
+    // internal restriction
+    auto const get_way_restriction_from_OSM_ids =
+        [&](auto const from_id, auto const to_id, const std::vector<OSMWayID> &via_ids) {
+            auto const from_way_itr = restriction_ways.find(from_id);
+            if (from_way_itr->second.way_id != from_id)
+            {
+                util::Log(logDEBUG) << "Restriction references invalid from way: " << from_id;
+                return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
             }
 
-            // connected at the end of the segment
-            if (via_node == MAX_OSM_NODEID || segment.last_segment_target_id == via_node)
+            std::vector<NodesOfWay> via_ways;
+            for (const auto &via_id : via_ids)
             {
-                if (segment.last_segment_target_id == via_segment.first_segment_source_id)
+                auto const via_segment_itr = restriction_ways.find(via_id);
+                if (via_segment_itr->second.way_id != via_id)
                 {
-                    return NodeRestriction{to_internal(segment.last_segment_source_id),
-                                           to_internal(segment.last_segment_target_id),
-                                           to_internal(via_segment.first_segment_target_id)};
-                }
-                else if (segment.last_segment_target_id == via_segment.last_segment_target_id)
-                {
-                    return NodeRestriction{to_internal(segment.last_segment_source_id),
-                                           to_internal(segment.last_segment_target_id),
-                                           to_internal(via_segment.last_segment_source_id)};
+                    util::Log(logDEBUG) << "Restriction references invalid via way: " << via_id;
+                    return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
                 }
+                via_ways.push_back(via_segment_itr->second);
             }
 
-            // unconnected
-            util::Log(logDEBUG) << "Restriction references unconnected way: " << segment.way_id;
-            return NodeRestriction{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
+            auto const to_way_itr = restriction_ways.find(to_id);
+            if (to_way_itr->second.way_id != to_id)
+            {
+                util::Log(logDEBUG) << "Restriction references invalid to way: " << to_id;
+                return WayRestriction{SPECIAL_NODEID, {}, SPECIAL_NODEID};
+            }
+
+            return find_way_restriction(from_way_itr->second, via_ways, to_way_itr->second);
         };
 
-    // translate the turn from one segment onto another into a node restriction (the ways can
-    // only
-    // be connected at a single location)
-    auto const get_node_restriction_from_OSM_ids = [&](
-        auto const from_id, auto const to_id, const OSMNodeID via_node) {
-        auto const from_segment_itr = referenced_ways.find(from_id);
+    // Node restrictions are described as a restriction between the two segments closest
+    // to the shared via-node on the from and to ways.
+    // from: [a, b, c, d, e]
+    // to: [f, g, h, i, j]
+    //
+    // The via node establishes the orientation of the from/to intersection when choosing the
+    // segments.
+    //   via    |  node restriction
+    //   a=f    |     b,a,g
+    //   a=j    |     b,a,i
+    //   e=f    |     d,e,g
+    //   e=j    |     d,e,i
+    auto const find_node_restriction =
+        [&](auto const &from_segment, auto const &to_segment, auto const via_node) {
+            OSMNodeID from, via, to;
+            std::tie(from, via, to) = find_turn_nodes(from_segment, to_segment, via_node);
+            if (via == SPECIAL_OSM_NODEID)
+            {
+                // unconnected
+                util::Log(logDEBUG)
+                    << "Restriction references unconnected way: " << from_segment.way_id;
+                return NodeRestriction{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
+            }
+            return NodeRestriction{to_internal(from), to_internal(via), to_internal(to)};
+        };
+
+    // Check if we were able to resolve all the involved OSM elements before translating to an
+    // internal restriction
+    auto const get_node_restriction_from_OSM_ids = [&](auto const from_id,
+                                                       auto const to_id,
+                                                       const OSMNodeID via_node) {
+        auto const from_segment_itr = restriction_ways.find(from_id);
+
         if (from_segment_itr->second.way_id != from_id)
         {
             util::Log(logDEBUG) << "Restriction references invalid way: " << from_id;
             return NodeRestriction{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
         }
 
-        auto const to_segment_itr = referenced_ways.find(to_id);
+        auto const to_segment_itr = restriction_ways.find(to_id);
         if (to_segment_itr->second.way_id != to_id)
         {
             util::Log(logDEBUG) << "Restriction references invalid way: " << to_id;
             return NodeRestriction{SPECIAL_NODEID, SPECIAL_NODEID, SPECIAL_NODEID};
         }
+
         return find_node_restriction(from_segment_itr->second, to_segment_itr->second, via_node);
     };
 
     // Transform an OSMRestriction (based on WayIDs) into an OSRM restriction (base on NodeIDs).
     // Returns true on successful transformation, false in case of invalid references.
-    // Based on the auto type deduction, this transfor handles both conditional and
-    // unconditional
-    // turn restrictions.
     const auto transform = [&](const auto &external_type, auto &internal_type) {
         if (external_type.Type() == RestrictionType::WAY_RESTRICTION)
         {
             auto const &external = external_type.AsWayRestriction();
-            // check if we were able to resolve all the involved ways
-            auto const from_restriction =
-                get_node_restriction_from_OSM_ids(external.from, external.via, MAX_OSM_NODEID);
-            auto const to_restriction =
-                get_node_restriction_from_OSM_ids(external.via, external.to, MAX_OSM_NODEID);
+            auto const restriction =
+                get_way_restriction_from_OSM_ids(external.from, external.to, external.via);
 
-            // failed to translate either of the involved nodes?
-            if (!from_restriction.Valid() || !to_restriction.Valid())
+            if (!restriction.Valid())
                 return false;
 
-            // point located at both via and segment is alway on `second`, to FSSF is the order
-            // we
-            // need
-            WayRestriction way_restriction{from_restriction, to_restriction};
-            internal_type.node_or_way = std::move(way_restriction);
+            internal_type.node_or_way = restriction;
             return true;
         }
         else
         {
             BOOST_ASSERT(external_type.Type() == RestrictionType::NODE_RESTRICTION);
             auto const &external = external_type.AsNodeRestriction();
-            auto const via_node = to_internal(external.via);
 
-            // check if we were able to resolve all the involved ways
             auto restriction =
                 get_node_restriction_from_OSM_ids(external.from, external.to, external.via);
 
             if (!restriction.Valid())
-            {
                 return false;
-            }
 
-            if (restriction.via != via_node)
-            {
-                util::Log(logDEBUG) << "Restriction references invalid way: " << external.via;
-                return false;
-            }
-
-            internal_type.node_or_way = std::move(restriction);
+            internal_type.node_or_way = restriction;
             return true;
         }
     };
 
-    // wrapper function to handle distinction between conditional and unconditional turn
-    // restrictions
-    const auto transform_into_internal_types =
-        [&](const InputConditionalTurnRestriction &external_restriction) {
-            // unconditional restriction
-            if (external_restriction.condition.empty() &&
-                external_restriction.Type() == RestrictionType::NODE_RESTRICTION)
-            {
-                TurnRestriction restriction;
-                restriction.is_only = external_restriction.is_only;
-                if (transform(external_restriction, restriction))
-                    unconditional_turn_restrictions.push_back(std::move(restriction));
-            }
-            // conditional turn restriction
-            else
-            {
-                ConditionalTurnRestriction restriction;
-                restriction.is_only = external_restriction.is_only;
-                restriction.condition = std::move(external_restriction.condition);
-                if (transform(external_restriction, restriction))
-                {
-                    conditional_turn_restrictions.push_back(std::move(restriction));
-                }
-            }
-        };
+    const auto transform_into_internal_types = [&](InputTurnRestriction &external_restriction) {
+        TurnRestriction restriction;
+        if (transform(external_restriction, restriction))
+        {
+            restriction.is_only = external_restriction.is_only;
+            restriction.condition = std::move(external_restriction.condition);
+            turn_restrictions.push_back(std::move(restriction));
+        }
+    };
 
     // Transforming the restrictions into the dedicated internal types
     {
         util::UnbufferedLog log;
-        log << "Collecting start/end information on " << restrictions_list.size()
-            << " restrictions...";
+        log << "Collecting node information on " << restrictions_list.size() << " restrictions...";
         TIMER_START(transform);
         std::for_each(
             restrictions_list.begin(), restrictions_list.end(), transform_into_internal_types);
diff --git a/src/extractor/extractor.cpp b/src/extractor/extractor.cpp
index 3fb5ff1f0..d3fa345c7 100644
--- a/src/extractor/extractor.cpp
+++ b/src/extractor/extractor.cpp
@@ -12,8 +12,9 @@
 #include "extractor/maneuver_override_relation_parser.hpp"
 #include "extractor/name_table.hpp"
 #include "extractor/node_based_graph_factory.hpp"
+#include "extractor/node_restriction_map.hpp"
 #include "extractor/restriction_filter.hpp"
-#include "extractor/restriction_index.hpp"
+#include "extractor/restriction_graph.hpp"
 #include "extractor/restriction_parser.hpp"
 #include "extractor/scripting_environment.hpp"
 #include "extractor/tarjan_scc.hpp"
@@ -215,12 +216,8 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
 
     LaneDescriptionMap turn_lane_map;
     std::vector<TurnRestriction> turn_restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_turn_restrictions;
     std::vector<UnresolvedManeuverOverride> unresolved_maneuver_overrides;
-    std::tie(turn_lane_map,
-             turn_restrictions,
-             conditional_turn_restrictions,
-             unresolved_maneuver_overrides) =
+    std::tie(turn_lane_map, turn_restrictions, unresolved_maneuver_overrides) =
         ParseOSMData(scripting_environment, number_of_threads);
 
     // Transform the node-based graph that OSM is based on into an edge-based graph
@@ -242,7 +239,6 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     NodeBasedGraphFactory node_based_graph_factory(config.GetPath(".osrm"),
                                                    scripting_environment,
                                                    turn_restrictions,
-                                                   conditional_turn_restrictions,
                                                    unresolved_maneuver_overrides);
 
     NameTable name_table;
@@ -283,8 +279,8 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     edge_based_nodes_container =
         EdgeBasedNodeDataContainer({}, std::move(node_based_graph_factory.GetAnnotationData()));
 
-    conditional_turn_restrictions =
-        removeInvalidRestrictions(std::move(conditional_turn_restrictions), node_based_graph);
+    turn_restrictions = removeInvalidRestrictions(std::move(turn_restrictions), node_based_graph);
+    auto restriction_graph = constructRestrictionGraph(turn_restrictions);
 
     const auto number_of_node_based_nodes = node_based_graph.GetNumberOfNodes();
 
@@ -294,8 +290,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
                                node_based_graph_factory.GetCompressedEdges(),
                                barrier_nodes,
                                traffic_signals,
-                               turn_restrictions,
-                               conditional_turn_restrictions,
+                               restriction_graph,
                                segregated_edges,
                                name_table,
                                unresolved_maneuver_overrides,
@@ -314,8 +309,7 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
                          coordinates,
                          node_based_graph_factory.GetCompressedEdges(),
                          barrier_nodes,
-                         turn_restrictions,
-                         conditional_turn_restrictions,
+                         restriction_graph,
                          name_table,
                          std::move(turn_lane_map),
                          scripting_environment);
@@ -374,12 +368,10 @@ int Extractor::run(ScriptingEnvironment &scripting_environment)
     return 0;
 }
 
-std::tuple<LaneDescriptionMap,
-           std::vector<TurnRestriction>,
-           std::vector<ConditionalTurnRestriction>,
-           std::vector<UnresolvedManeuverOverride>>
-Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
-                        const unsigned number_of_threads)
+std::
+    tuple<LaneDescriptionMap, std::vector<TurnRestriction>, std::vector<UnresolvedManeuverOverride>>
+    Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
+                            const unsigned number_of_threads)
 {
     TIMER_START(extracting);
 
@@ -455,7 +447,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
         std::vector<std::pair<const osmium::Node &, ExtractionNode>> resulting_nodes;
         std::vector<std::pair<const osmium::Way &, ExtractionWay>> resulting_ways;
         std::vector<std::pair<const osmium::Relation &, ExtractionRelation>> resulting_relations;
-        std::vector<InputConditionalTurnRestriction> resulting_restrictions;
+        std::vector<InputTurnRestriction> resulting_restrictions;
         std::vector<InputManeuverOverride> resulting_maneuver_overrides;
     };
 
@@ -492,7 +484,9 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
 
     // OSM elements Lua parser
     tbb::filter_t<SharedBuffer, ParsedBuffer> buffer_transformer(
-        tbb::filter::parallel, [&](const SharedBuffer buffer) {
+        tbb::filter::parallel,
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
+        [&](const SharedBuffer buffer) {
             ParsedBuffer parsed_buffer;
             parsed_buffer.buffer = buffer;
             scripting_environment.ProcessElements(*buffer,
@@ -539,7 +533,9 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
         });
 
     tbb::filter_t<SharedBuffer, std::shared_ptr<ExtractionRelationContainer>> buffer_relation_cache(
-        tbb::filter::parallel, [&](const SharedBuffer buffer) {
+        tbb::filter::parallel,
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
+        [&](const SharedBuffer buffer) {
             if (!buffer)
                 return std::shared_ptr<ExtractionRelationContainer>{};
 
@@ -552,9 +548,9 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
                 const auto &rel = static_cast<const osmium::Relation &>(*entity);
 
                 const char *rel_type = rel.get_value_by_key("type");
-                if (!rel_type ||
-                    !std::binary_search(
-                        relation_types.begin(), relation_types.end(), std::string(rel_type)))
+                if (!rel_type || !std::binary_search(relation_types.begin(),
+                                                     relation_types.end(),
+                                                     std::string(rel_type)))
                     continue;
 
                 ExtractionRelation extracted_rel({rel.id(), osmium::item_type::relation});
@@ -576,6 +572,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
     unsigned number_of_relations = 0;
     tbb::filter_t<std::shared_ptr<ExtractionRelationContainer>, void> buffer_storage_relation(
         tbb::filter::serial_in_order,
+        // NOLINTNEXTLINE(performance-unnecessary-value-param)
         [&](const std::shared_ptr<ExtractionRelationContainer> parsed_relations) {
             number_of_relations += parsed_relations->GetRelationsNum();
             relations.Merge(std::move(*parsed_relations));
@@ -638,8 +635,7 @@ Extractor::ParseOSMData(ScriptingEnvironment &scripting_environment,
     util::Log() << "extraction finished after " << TIMER_SEC(extracting) << "s";
 
     return std::make_tuple(std::move(turn_lane_map),
-                           std::move(extraction_containers.unconditional_turn_restrictions),
-                           std::move(extraction_containers.conditional_turn_restrictions),
+                           std::move(extraction_containers.turn_restrictions),
                            std::move(extraction_containers.internal_maneuver_overrides));
 }
 
@@ -712,8 +708,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
     const CompressedEdgeContainer &compressed_edge_container,
     const std::unordered_set<NodeID> &barrier_nodes,
     const std::unordered_set<NodeID> &traffic_signals,
-    const std::vector<TurnRestriction> &turn_restrictions,
-    const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
+    const RestrictionGraph &restriction_graph,
     const std::unordered_set<EdgeID> &segregated_edges,
     const NameTable &name_table,
     const std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
@@ -740,21 +735,10 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
                                                    turn_lane_map);
 
     const auto create_edge_based_edges = [&]() {
-        // scoped to relase intermediate datastructures right after the call
-        std::vector<TurnRestriction> node_restrictions;
-        for (auto const &t : turn_restrictions)
-            if (t.Type() == RestrictionType::NODE_RESTRICTION)
-                node_restrictions.push_back(t);
-
-        std::vector<ConditionalTurnRestriction> conditional_node_restrictions;
-        for (auto const &t : conditional_turn_restrictions)
-            if (t.Type() == RestrictionType::NODE_RESTRICTION)
-                conditional_node_restrictions.push_back(t);
-
-        RestrictionMap via_node_restriction_map(node_restrictions, IndexNodeByFromAndVia());
-        WayRestrictionMap via_way_restriction_map(conditional_turn_restrictions);
-        ConditionalRestrictionMap conditional_node_restriction_map(conditional_node_restrictions,
-                                                                   IndexNodeByFromAndVia());
+        // scoped to release intermediate data structures right after the call
+        RestrictionMap unconditional_node_restriction_map(restriction_graph);
+        ConditionalRestrictionMap conditional_node_restriction_map(restriction_graph);
+        WayRestrictionMap via_way_restriction_map(restriction_graph);
         edge_based_graph_factory.Run(scripting_environment,
                                      config.GetPath(".osrm.turn_weight_penalties").string(),
                                      config.GetPath(".osrm.turn_duration_penalties").string(),
@@ -762,7 +746,7 @@ EdgeID Extractor::BuildEdgeExpandedGraph(
                                      config.GetPath(".osrm.cnbg_to_ebg").string(),
                                      config.GetPath(".osrm.restrictions").string(),
                                      config.GetPath(".osrm.maneuver_overrides").string(),
-                                     via_node_restriction_map,
+                                     unconditional_node_restriction_map,
                                      conditional_node_restriction_map,
                                      via_way_restriction_map,
                                      maneuver_overrides);
@@ -833,8 +817,7 @@ void Extractor::ProcessGuidanceTurns(
     const std::vector<util::Coordinate> &node_coordinates,
     const CompressedEdgeContainer &compressed_edge_container,
     const std::unordered_set<NodeID> &barrier_nodes,
-    const std::vector<TurnRestriction> &turn_restrictions,
-    const std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
+    const RestrictionGraph &restriction_graph,
     const NameTable &name_table,
     LaneDescriptionMap lane_description_map,
     ScriptingEnvironment &scripting_environment)
@@ -853,20 +836,15 @@ void Extractor::ProcessGuidanceTurns(
         SuffixTable street_name_suffix_table(scripting_environment);
         const auto &turn_lanes_data = transformTurnLaneMapIntoArrays(lane_description_map);
 
-        std::vector<TurnRestriction> node_restrictions;
-        for (auto const &t : turn_restrictions)
-            if (t.Type() == RestrictionType::NODE_RESTRICTION)
-                node_restrictions.push_back(t);
-
-        RestrictionMap node_restriction_map(node_restrictions, IndexNodeByFromAndVia());
-        WayRestrictionMap way_restriction_map(conditional_turn_restrictions);
+        RestrictionMap unconditional_node_restriction_map(restriction_graph);
+        WayRestrictionMap way_restriction_map(restriction_graph);
 
         osrm::guidance::annotateTurns(node_based_graph,
                                       edge_based_node_container,
                                       node_coordinates,
                                       compressed_edge_container,
                                       barrier_nodes,
-                                      node_restriction_map,
+                                      unconditional_node_restriction_map,
                                       way_restriction_map,
                                       name_table,
                                       street_name_suffix_table,
diff --git a/src/extractor/extractor_callbacks.cpp b/src/extractor/extractor_callbacks.cpp
index cfe983106..9ac6db0c6 100644
--- a/src/extractor/extractor_callbacks.cpp
+++ b/src/extractor/extractor_callbacks.cpp
@@ -11,7 +11,6 @@
 #include "util/guidance/turn_lanes.hpp"
 #include "util/log.hpp"
 
-#include <boost/numeric/conversion/cast.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/tokenizer.hpp>
 
@@ -19,12 +18,28 @@
 
 #include "osrm/coordinate.hpp"
 
-#include <cstring>
-#include <iterator>
 #include <limits>
 #include <string>
 #include <vector>
 
+#ifdef _MSC_VER
+#if (_MSC_VER >= 1928)
+#ifdef _DEBUG
+namespace osrm
+{
+namespace extractor
+{
+namespace detail
+{
+const ByEdgeOrByMeterValue::ValueByEdge ByEdgeOrByMeterValue::by_edge;
+const ByEdgeOrByMeterValue::ValueByMeter ByEdgeOrByMeterValue::by_meter;
+} // namespace detail
+} // namespace extractor
+} // namespace osrm
+#endif
+#endif
+#endif
+
 namespace osrm
 {
 namespace extractor
@@ -69,13 +84,12 @@ void ExtractorCallbacks::ProcessNode(const osmium::Node &input_node,
     }
 }
 
-void ExtractorCallbacks::ProcessRestriction(const InputConditionalTurnRestriction &restriction)
+void ExtractorCallbacks::ProcessRestriction(const InputTurnRestriction &restriction)
 {
     external_memory.restrictions_list.push_back(restriction);
-    // util::Log() << restriction.toString();
 }
 
-void ExtractorCallbacks::ProcessManeuverOverride(const InputManeuverOverride & override)
+void ExtractorCallbacks::ProcessManeuverOverride(const InputManeuverOverride &override)
 {
     external_memory.external_maneuver_overrides_list.push_back(override);
 }
@@ -407,9 +421,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                                                                   parsed_way.forward_travel_mode,
                                                                   parsed_way.is_left_hand_driving});
         util::for_each_pair(
-            nodes.cbegin(),
-            nodes.cend(),
-            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
+            nodes, [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
                 NodeBasedEdgeWithOSM edge = {
                     OSMNodeID{static_cast<std::uint64_t>(first_node.ref())},
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
@@ -443,9 +455,7 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                                                                   parsed_way.backward_travel_mode,
                                                                   parsed_way.is_left_hand_driving});
         util::for_each_pair(
-            nodes.cbegin(),
-            nodes.cend(),
-            [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
+            nodes, [&](const osmium::NodeRef &first_node, const osmium::NodeRef &last_node) {
                 NodeBasedEdgeWithOSM edge = {
                     OSMNodeID{static_cast<std::uint64_t>(first_node.ref())},
                     OSMNodeID{static_cast<std::uint64_t>(last_node.ref())},
@@ -477,12 +487,9 @@ void ExtractorCallbacks::ProcessWay(const osmium::Way &input_way, const Extracti
                        return OSMNodeID{static_cast<std::uint64_t>(ref.ref())};
                    });
 
-    external_memory.way_start_end_id_list.push_back(
-        {OSMWayID{static_cast<std::uint32_t>(input_way.id())},
-         OSMNodeID{static_cast<std::uint64_t>(nodes[0].ref())},
-         OSMNodeID{static_cast<std::uint64_t>(nodes[1].ref())},
-         OSMNodeID{static_cast<std::uint64_t>(nodes[nodes.size() - 2].ref())},
-         OSMNodeID{static_cast<std::uint64_t>(nodes.back().ref())}});
+    auto way_id = OSMWayID{static_cast<std::uint64_t>(input_way.id())};
+    external_memory.ways_list.push_back(way_id);
+    external_memory.way_node_id_offsets.push_back(external_memory.used_node_id_list.size());
 }
 
 } // namespace extractor
diff --git a/src/extractor/graph_compressor.cpp b/src/extractor/graph_compressor.cpp
index 9371aeb9c..30ef5d593 100644
--- a/src/extractor/graph_compressor.cpp
+++ b/src/extractor/graph_compressor.cpp
@@ -20,46 +20,40 @@ namespace osrm
 namespace extractor
 {
 
-void GraphCompressor::Compress(
-    const std::unordered_set<NodeID> &barrier_nodes,
-    const std::unordered_set<NodeID> &traffic_signals,
-    ScriptingEnvironment &scripting_environment,
-    std::vector<TurnRestriction> &turn_restrictions,
-    std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
-    std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
-    util::NodeBasedDynamicGraph &graph,
-    const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
-    CompressedEdgeContainer &geometry_compressor)
+void GraphCompressor::Compress(const std::unordered_set<NodeID> &barrier_nodes,
+                               const std::unordered_set<NodeID> &traffic_signals,
+                               ScriptingEnvironment &scripting_environment,
+                               std::vector<TurnRestriction> &turn_restrictions,
+                               std::vector<UnresolvedManeuverOverride> &maneuver_overrides,
+                               util::NodeBasedDynamicGraph &graph,
+                               const std::vector<NodeBasedEdgeAnnotation> &node_data_container,
+                               CompressedEdgeContainer &geometry_compressor)
 {
     const unsigned original_number_of_nodes = graph.GetNumberOfNodes();
     const unsigned original_number_of_edges = graph.GetNumberOfEdges();
 
-    RestrictionCompressor restriction_compressor(
-        turn_restrictions, conditional_turn_restrictions, maneuver_overrides);
+    RestrictionCompressor restriction_compressor(turn_restrictions, maneuver_overrides);
 
-    // we do not compress turn restrictions on degree two nodes. These nodes are usually used to
-    // indicated `directed` barriers
+    // Some degree two nodes are not compressed if they act as entry/exit points into a
+    // restriction path.
     std::unordered_set<NodeID> restriction_via_nodes;
 
     const auto remember_via_nodes = [&](const auto &restriction) {
         if (restriction.Type() == RestrictionType::NODE_RESTRICTION)
         {
-            const auto &node = restriction.AsNodeRestriction();
-            restriction_via_nodes.insert(node.via);
+            restriction_via_nodes.insert(restriction.AsNodeRestriction().via);
         }
         else
         {
             BOOST_ASSERT(restriction.Type() == RestrictionType::WAY_RESTRICTION);
-            const auto &way = restriction.AsWayRestriction();
-            restriction_via_nodes.insert(way.in_restriction.via);
-            restriction_via_nodes.insert(way.out_restriction.via);
+            const auto &way_restriction = restriction.AsWayRestriction();
+            // We do not compress the first and last via nodes so that we know how to enter/exit
+            // a restriction path and apply the restrictions correctly.
+            restriction_via_nodes.insert(way_restriction.via.front());
+            restriction_via_nodes.insert(way_restriction.via.back());
         }
     };
     std::for_each(turn_restrictions.begin(), turn_restrictions.end(), remember_via_nodes);
-    std::for_each(conditional_turn_restrictions.begin(),
-                  conditional_turn_restrictions.end(),
-                  remember_via_nodes);
-
     {
         const auto weight_multiplier =
             scripting_environment.GetProfileProperties().GetWeightMultiplier();
@@ -82,8 +76,8 @@ void GraphCompressor::Compress(
                 continue;
             }
 
-            // check if v is a via node for a turn restriction, i.e. a 'directed' barrier node
-            if (restriction_via_nodes.count(node_v))
+            // check if v is an entry/exit via node for a turn restriction
+            if (restriction_via_nodes.count(node_v) > 0)
             {
                 continue;
             }
@@ -181,21 +175,22 @@ void GraphCompressor::Compress(
                  * reasonable, since the announcements have to come early anyhow. So there is a
                  * potential danger in here, but it saves us from adding a lot of additional edges
                  * for
-                 * turn-lanes. Without this,we would have to treat any turn-lane beginning/ending
+                 * turn-lanes. Without this, we would have to treat any turn-lane beginning/ending
                  * just
                  * like a barrier.
                  */
-                const auto selectAnnotation = [&node_data_container](
-                    const AnnotationID front_annotation, const AnnotationID back_annotation) {
-                    // A lane has tags: u - (front) - v - (back) - w
-                    // During contraction, we keep only one of the tags. Usually the one closer
-                    // to the intersection is preferred. If its empty, however, we keep the
-                    // non-empty one
-                    if (node_data_container[back_annotation].lane_description_id ==
-                        INVALID_LANE_DESCRIPTIONID)
-                        return front_annotation;
-                    return back_annotation;
-                };
+                const auto selectAnnotation =
+                    [&node_data_container](const AnnotationID front_annotation,
+                                           const AnnotationID back_annotation) {
+                        // A lane has tags: u - (front) - v - (back) - w
+                        // During contraction, we keep only one of the tags. Usually the one closer
+                        // to the intersection is preferred. If its empty, however, we keep the
+                        // non-empty one
+                        if (node_data_container[back_annotation].lane_description_id ==
+                            INVALID_LANE_DESCRIPTIONID)
+                            return front_annotation;
+                        return back_annotation;
+                    };
 
                 graph.GetEdgeData(forward_e1).annotation_data = selectAnnotation(
                     fwd_edge_data1.annotation_data, fwd_edge_data2.annotation_data);
@@ -371,5 +366,5 @@ void GraphCompressor::PrintStatistics(unsigned original_number_of_nodes,
     util::Log() << "Node compression ratio: " << new_node_count / (double)original_number_of_nodes;
     util::Log() << "Edge compression ratio: " << new_edge_count / (double)original_number_of_edges;
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/intersection/coordinate_extractor.cpp b/src/extractor/intersection/coordinate_extractor.cpp
index d4551e253..18199a79d 100644
--- a/src/extractor/intersection/coordinate_extractor.cpp
+++ b/src/extractor/intersection/coordinate_extractor.cpp
@@ -55,7 +55,7 @@ double GetOffsetCorrectionFactor(const RoadClassification &road_classification)
         return 1.0;
     };
 }
-}
+} // namespace
 
 CoordinateExtractor::CoordinateExtractor(
     const util::NodeBasedDynamicGraph &node_based_graph,
@@ -146,13 +146,12 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
         // do the best of what we can.
         coordinates =
             TrimCoordinatesToLength(std::move(coordinates), LOOKAHEAD_DISTANCE_WITHOUT_LANES);
-        if (coordinates.size() > 2 &&
-            util::coordinate_calculation::haversineDistance(turn_coordinate, coordinates[1]) <
-                ASSUMED_LANE_WIDTH)
+        if (coordinates.size() > 2 && util::coordinate_calculation::greatCircleDistance(
+                                          turn_coordinate, coordinates[1]) < ASSUMED_LANE_WIDTH)
         {
             const auto initial_distance =
-                util::coordinate_calculation::haversineDistance(turn_coordinate, coordinates[1]);
-            const auto total_distance = util::coordinate_calculation::haversineDistance(
+                util::coordinate_calculation::greatCircleDistance(turn_coordinate, coordinates[1]);
+            const auto total_distance = util::coordinate_calculation::greatCircleDistance(
                 turn_coordinate, coordinates.back());
 
             if (initial_distance > ASSUMED_LANE_WIDTH && total_distance > initial_distance)
@@ -170,7 +169,7 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
     }
 
     const auto first_distance =
-        util::coordinate_calculation::haversineDistance(coordinates[0], coordinates[1]);
+        util::coordinate_calculation::greatCircleDistance(coordinates[0], coordinates[1]);
 
     // the lane count might not always be set. We need to assume a positive number, though. Here we
     // select the number of lanes to operate on
@@ -370,7 +369,7 @@ util::Coordinate CoordinateExtractor::ExtractRepresentativeCoordinate(
             std::move(coordinates), 3 * skipping_inaccuracies_distance, segment_distances);
         BOOST_ASSERT(coordinates.size() >= 2);
         segment_distances.resize(coordinates.size());
-        segment_distances.back() = util::coordinate_calculation::haversineDistance(
+        segment_distances.back() = util::coordinate_calculation::greatCircleDistance(
             *(coordinates.end() - 2), coordinates.back());
         const auto vector_head = coordinates.back();
         coordinates = TrimCoordinatesToLength(
@@ -442,7 +441,7 @@ CoordinateExtractor::ExtractCoordinateAtLength(const double distance,
     auto length_cache_itr = length_cache.begin() + 1;
     // find the end of the segment containing the coordinate which is at least distance away
     const auto find_coordinate_at_distance = [distance, &accumulated_distance, &length_cache_itr](
-        const util::Coordinate /*coordinate*/) mutable {
+                                                 const util::Coordinate /*coordinate*/) mutable {
         const auto result = (accumulated_distance + *length_cache_itr) >= distance;
         if (!result)
         {
@@ -474,20 +473,19 @@ util::Coordinate CoordinateExtractor::ExtractCoordinateAtLength(
     double accumulated_distance = 0.;
     // checks (via its state) for an accumulated distance
     const auto coordinate_at_distance =
-        [ distance, &accumulated_distance, last_coordinate = coordinates.front() ](
-            const util::Coordinate coordinate) mutable
-    {
-        const double segment_distance =
-            util::coordinate_calculation::haversineDistance(last_coordinate, coordinate);
-        const auto result = (accumulated_distance + segment_distance) >= distance;
-        if (!result)
-        {
-            accumulated_distance += segment_distance;
-            last_coordinate = coordinate;
-        }
+        [distance, &accumulated_distance, last_coordinate = coordinates.front()](
+            const util::Coordinate coordinate) mutable {
+            const double segment_distance =
+                util::coordinate_calculation::greatCircleDistance(last_coordinate, coordinate);
+            const auto result = (accumulated_distance + segment_distance) >= distance;
+            if (!result)
+            {
+                accumulated_distance += segment_distance;
+                last_coordinate = coordinate;
+            }
 
-        return result;
-    };
+            return result;
+        };
 
     // find the begin of the segment containing the coordinate
     const auto coordinate_after =
@@ -499,7 +497,7 @@ util::Coordinate CoordinateExtractor::ExtractCoordinateAtLength(
     const auto interpolation_factor =
         ComputeInterpolationFactor(distance - accumulated_distance,
                                    0,
-                                   util::coordinate_calculation::haversineDistance(
+                                   util::coordinate_calculation::greatCircleDistance(
                                        *std::prev(coordinate_after), *coordinate_after));
 
     return util::coordinate_calculation::interpolateLinear(
@@ -532,11 +530,12 @@ util::Coordinate CoordinateExtractor::GetCoordinateCloseToTurn(const NodeID from
         // OSM data has a tendency to include repeated nodes with identical coordinates. To skip
         // over these, we search for the first coordinate along the path that is at least a meter
         // away from the first entry
-        const auto far_enough_away = [start_coordinate, compressedGeometryToCoordinate](
-            const CompressedEdgeContainer::OnewayCompressedEdge &compressed_edge) {
-            return util::coordinate_calculation::haversineDistance(
-                       compressedGeometryToCoordinate(compressed_edge), start_coordinate) > 1;
-        };
+        const auto far_enough_away =
+            [start_coordinate, compressedGeometryToCoordinate](
+                const CompressedEdgeContainer::OnewayCompressedEdge &compressed_edge) {
+                return util::coordinate_calculation::greatCircleDistance(
+                           compressedGeometryToCoordinate(compressed_edge), start_coordinate) > 1;
+            };
 
         // find the first coordinate, that is at least unequal to the begin of the edge
         if (traversed_in_reverse)
@@ -628,7 +627,7 @@ CoordinateExtractor::GetMaxDeviation(std::vector<util::Coordinate>::const_iterat
                                  .second;
         // and calculate the distance between the intermediate coordinate and the coordinate
         // on the osrm-way
-        return util::coordinate_calculation::haversineDistance(coord_between, coordinate);
+        return util::coordinate_calculation::greatCircleDistance(coord_between, coordinate);
     };
 
     // note: we don't accumulate here but rather compute the maximum. The functor passed here is not
@@ -672,7 +671,7 @@ bool CoordinateExtractor::IsCurve(const std::vector<util::Coordinate> &coordinat
         auto coord_between =
             util::coordinate_calculation::projectPointOnSegment(line_start, line_end, point).second;
         // and calculate the distance between the intermediate coordinate and the coordinate
-        return util::coordinate_calculation::haversineDistance(coord_between, point);
+        return util::coordinate_calculation::greatCircleDistance(coord_between, point);
     };
 
     // a curve needs to be on one side of the coordinate array
@@ -893,19 +892,20 @@ CoordinateExtractor::PrepareLengthCache(const std::vector<util::Coordinate> &coo
     segment_distances.reserve(coordinates.size());
     segment_distances.push_back(0);
     // sentinel
-    std::find_if(std::next(std::begin(coordinates)), std::end(coordinates), [
-        last_coordinate = coordinates.front(),
-        limit,
-        &segment_distances,
-        accumulated_distance = 0.
-    ](const util::Coordinate current_coordinate) mutable {
-        const auto distance =
-            util::coordinate_calculation::haversineDistance(last_coordinate, current_coordinate);
-        accumulated_distance += distance;
-        last_coordinate = current_coordinate;
-        segment_distances.push_back(distance);
-        return accumulated_distance >= limit;
-    });
+    // NOLINTNEXTLINE(bugprone-unused-return-value)
+    std::find_if(std::next(std::begin(coordinates)),
+                 std::end(coordinates),
+                 [last_coordinate = coordinates.front(),
+                  limit,
+                  &segment_distances,
+                  accumulated_distance = 0.](const util::Coordinate current_coordinate) mutable {
+                     const auto distance = util::coordinate_calculation::greatCircleDistance(
+                         last_coordinate, current_coordinate);
+                     accumulated_distance += distance;
+                     last_coordinate = current_coordinate;
+                     segment_distances.push_back(distance);
+                     return accumulated_distance >= limit;
+                 });
     return segment_distances;
 }
 
@@ -924,8 +924,8 @@ CoordinateExtractor::TrimCoordinatesToLength(std::vector<util::Coordinate> coord
         [&coordinate_index, &distance_to_current_coordinate, &coordinates]() {
             const auto new_distance =
                 distance_to_current_coordinate +
-                util::coordinate_calculation::haversineDistance(coordinates[coordinate_index - 1],
-                                                                coordinates[coordinate_index]);
+                util::coordinate_calculation::greatCircleDistance(coordinates[coordinate_index - 1],
+                                                                  coordinates[coordinate_index]);
             return new_distance;
         };
 
@@ -941,8 +941,8 @@ CoordinateExtractor::TrimCoordinatesToLength(std::vector<util::Coordinate> coord
             coordinates.erase(coordinates.begin() + length_cache.size(), coordinates.end());
 
         const auto distance_between_last_coordinates =
-            util::coordinate_calculation::haversineDistance(*(coordinates.end() - 2),
-                                                            *(coordinates.end() - 1));
+            util::coordinate_calculation::greatCircleDistance(*(coordinates.end() - 2),
+                                                              *(coordinates.end() - 1));
 
         if (distance_between_last_coordinates > 0)
         {
@@ -991,7 +991,7 @@ CoordinateExtractor::GetCorrectedCoordinate(const util::Coordinate fixpoint,
 {
     // if the coordinates are close together, we were not able to look far ahead, so
     // we can use the end-coordinate
-    if (util::coordinate_calculation::haversineDistance(vector_base, vector_head) <
+    if (util::coordinate_calculation::greatCircleDistance(vector_base, vector_head) <
         DESIRED_COORDINATE_DIFFERENCE)
     {
         return vector_head;
@@ -1054,7 +1054,7 @@ CoordinateExtractor::SampleCoordinates(const std::vector<util::Coordinate> &coor
         if (total_length > max_sample_length)
             return true;
 
-        const auto distance_between = util::coordinate_calculation::haversineDistance(
+        const auto distance_between = util::coordinate_calculation::greatCircleDistance(
             previous_coordinate, current_coordinate);
 
         if (carry_length + distance_between >= rate)
@@ -1123,7 +1123,7 @@ CoordinateExtractor::TrimCoordinatesByLengthFront(std::vector<util::Coordinate>
     for (std::size_t next_index = 1; next_index < coordinates.size(); ++next_index)
     {
         const double next_distance =
-            distance_to_index + util::coordinate_calculation::haversineDistance(
+            distance_to_index + util::coordinate_calculation::greatCircleDistance(
                                     coordinates[index], coordinates[next_index]);
         if (next_distance >= desired_length)
         {
diff --git a/src/extractor/intersection/have_identical_names.cpp b/src/extractor/intersection/have_identical_names.cpp
index 0dffc12fe..3714598ec 100644
--- a/src/extractor/intersection/have_identical_names.cpp
+++ b/src/extractor/intersection/have_identical_names.cpp
@@ -25,6 +25,6 @@ bool HaveIdenticalNames(const NameID lhs,
            !util::guidance::requiresNameAnnounced(rhs, lhs, name_table, street_name_suffix_table);
 }
 
-} // namespace guidance
+} // namespace intersection
 } // namespace extractor
 } // namespace osrm
diff --git a/src/extractor/intersection/intersection.cpp b/src/extractor/intersection/intersection.cpp
index f7cc789fe..530252a4c 100644
--- a/src/extractor/intersection/intersection.cpp
+++ b/src/extractor/intersection/intersection.cpp
@@ -5,8 +5,6 @@
 
 #include <boost/range/adaptors.hpp>
 
-using osrm::util::angularDeviation;
-
 namespace osrm
 {
 namespace extractor
@@ -21,8 +19,8 @@ bool IntersectionViewData::CompareByAngle(const IntersectionViewData &other) con
 
 std::string toString(const IntersectionEdgeGeometry &shape)
 {
-    std::string result = "[shape] " + std::to_string(shape.eid) + " bearing: " +
-                         std::to_string(shape.perceived_bearing);
+    std::string result = "[shape] " + std::to_string(shape.eid) +
+                         " bearing: " + std::to_string(shape.perceived_bearing);
     return result;
 }
 
diff --git a/src/extractor/intersection/intersection_analysis.cpp b/src/extractor/intersection/intersection_analysis.cpp
index bf09b8f57..542bbaafa 100644
--- a/src/extractor/intersection/intersection_analysis.cpp
+++ b/src/extractor/intersection/intersection_analysis.cpp
@@ -237,7 +237,7 @@ getIntersectionOutgoingGeometries(const util::NodeBasedDynamicGraph &graph,
             util::coordinate_calculation::bearing(geometry[0], representative_coordinate);
 
         const auto edge_length = util::coordinate_calculation::getLength(
-            geometry.begin(), geometry.end(), util::coordinate_calculation::haversineDistance);
+            geometry.begin(), geometry.end(), util::coordinate_calculation::greatCircleDistance);
 
         edge_geometries.push_back({outgoing_edge, initial_bearing, perceived_bearing, edge_length});
     }
@@ -248,7 +248,7 @@ getIntersectionOutgoingGeometries(const util::NodeBasedDynamicGraph &graph,
     });
     return edge_geometries;
 }
-}
+} // namespace
 
 std::pair<IntersectionEdgeGeometries, std::unordered_set<EdgeID>>
 getIntersectionGeometries(const util::NodeBasedDynamicGraph &graph,
@@ -428,24 +428,10 @@ double findEdgeLength(const IntersectionEdgeGeometries &geometries, const EdgeID
 template <typename RestrictionsRange>
 bool isTurnRestricted(const RestrictionsRange &restrictions, const NodeID to)
 {
-    // Check turn restrictions to find a node that is the only allowed target when coming from a
-    // node to an intersection
-    //     d
-    //     |
-    // a - b - c  and `only_straight_on ab | bc would return `c` for `a,b`
-    const auto is_only = std::find_if(restrictions.first,
-                                      restrictions.second,
-                                      [](const auto &pair) { return pair.second->is_only; });
-    if (is_only != restrictions.second)
-        return is_only->second->AsNodeRestriction().to != to;
-
-    // Check if explicitly forbidden
-    const auto no_turn =
-        std::find_if(restrictions.first, restrictions.second, [&to](const auto &restriction) {
-            return restriction.second->AsNodeRestriction().to == to;
-        });
-
-    return no_turn != restrictions.second;
+    // Check if any of the restrictions would prevent a turn to 'to'
+    return std::any_of(restrictions.begin(), restrictions.end(), [&to](const auto &restriction) {
+        return restriction->IsTurnRestricted(to);
+    });
 }
 
 bool isTurnAllowed(const util::NodeBasedDynamicGraph &graph,
@@ -755,36 +741,61 @@ IntersectionView getConnectedRoads(const util::NodeBasedDynamicGraph &graph,
                                    const IntersectionEdge &incoming_edge)
 {
     const auto intersection_node = graph.GetTarget(incoming_edge.edge);
-    const auto &outgoing_edges = intersection::getOutgoingEdges(graph, intersection_node);
     auto edge_geometries = getIntersectionOutgoingGeometries<USE_CLOSE_COORDINATE>(
         graph, compressed_geometries, node_coordinates, intersection_node);
+    auto merged_edge_ids = std::unordered_set<EdgeID>();
+
+    return getConnectedRoadsForEdgeGeometries(graph,
+                                              node_data_container,
+                                              node_restriction_map,
+                                              barrier_nodes,
+                                              turn_lanes_data,
+                                              incoming_edge,
+                                              edge_geometries,
+                                              merged_edge_ids);
+}
+
+IntersectionView
+getConnectedRoadsForEdgeGeometries(const util::NodeBasedDynamicGraph &graph,
+                                   const EdgeBasedNodeDataContainer &node_data_container,
+                                   const RestrictionMap &node_restriction_map,
+                                   const std::unordered_set<NodeID> &barrier_nodes,
+                                   const TurnLanesIndexedArray &turn_lanes_data,
+                                   const IntersectionEdge &incoming_edge,
+                                   const IntersectionEdgeGeometries &edge_geometries,
+                                   const std::unordered_set<EdgeID> &merged_edge_ids)
+{
+    const auto intersection_node = graph.GetTarget(incoming_edge.edge);
+    const auto &outgoing_edges = intersection::getOutgoingEdges(graph, intersection_node);
 
     // Add incoming edges with reversed bearings
-    const auto edges_number = edge_geometries.size();
-    edge_geometries.resize(2 * edges_number);
+    auto processed_edge_geometries = IntersectionEdgeGeometries(edge_geometries);
+    const auto edges_number = processed_edge_geometries.size();
+    processed_edge_geometries.resize(2 * edges_number);
     for (std::size_t index = 0; index < edges_number; ++index)
     {
-        const auto &geometry = edge_geometries[index];
+        const auto &geometry = processed_edge_geometries[index];
         const auto remote_node = graph.GetTarget(geometry.eid);
         const auto incoming_edge = graph.FindEdge(remote_node, intersection_node);
-        edge_geometries[edges_number + index] = {incoming_edge,
-                                                 util::bearing::reverse(geometry.initial_bearing),
-                                                 util::bearing::reverse(geometry.perceived_bearing),
-                                                 geometry.segment_length};
+        processed_edge_geometries[edges_number + index] = {
+            incoming_edge,
+            util::bearing::reverse(geometry.initial_bearing),
+            util::bearing::reverse(geometry.perceived_bearing),
+            geometry.segment_length};
     }
 
     // Enforce ordering of edges by IDs
-    std::sort(edge_geometries.begin(), edge_geometries.end());
+    std::sort(processed_edge_geometries.begin(), processed_edge_geometries.end());
 
     return convertToIntersectionView(graph,
                                      node_data_container,
                                      node_restriction_map,
                                      barrier_nodes,
-                                     edge_geometries,
+                                     processed_edge_geometries,
                                      turn_lanes_data,
                                      incoming_edge,
                                      outgoing_edges,
-                                     std::unordered_set<EdgeID>());
+                                     merged_edge_ids);
 }
 
 template IntersectionView
@@ -827,6 +838,6 @@ IntersectionEdge skipDegreeTwoNodes(const util::NodeBasedDynamicGraph &graph, In
 
     return road;
 }
-}
-}
-}
+} // namespace intersection
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/intersection/mergable_road_detector.cpp b/src/extractor/intersection/mergable_road_detector.cpp
index bbc5a8d93..a1c95054c 100644
--- a/src/extractor/intersection/mergable_road_detector.cpp
+++ b/src/extractor/intersection/mergable_road_detector.cpp
@@ -31,7 +31,7 @@ inline auto makeCheckRoadForName(const NameID name_id,
                                  const SuffixTable &suffix_table)
 {
     return [name_id, &node_based_graph, &node_data_container, &name_table, &suffix_table](
-        const MergableRoadDetector::MergableRoadData &road) {
+               const MergableRoadDetector::MergableRoadData &road) {
         // since we filter here, we don't want any other name than the one we are looking for
         const auto road_name_id =
             node_data_container
@@ -49,7 +49,7 @@ inline auto makeCheckRoadForName(const NameID name_id,
         return requires_announcement;
     };
 }
-}
+} // namespace
 
 MergableRoadDetector::MergableRoadDetector(
     const util::NodeBasedDynamicGraph &node_based_graph,
@@ -225,7 +225,7 @@ bool MergableRoadDetector::IsNarrowTriangle(const NodeID intersection_node,
             left_accumulator,
             selector);
     }
-    const auto distance_to_triangle = util::coordinate_calculation::haversineDistance(
+    const auto distance_to_triangle = util::coordinate_calculation::greatCircleDistance(
         node_coordinates[intersection_node],
         node_coordinates[node_based_graph.GetTarget(left_accumulator.via_edge_id)]);
 
@@ -274,9 +274,10 @@ bool MergableRoadDetector::IsNarrowTriangle(const NodeID intersection_node,
     // the width we can bridge at the intersection
     const auto assumed_road_width = (num_lanes(lhs) + num_lanes(rhs)) * ASSUMED_LANE_WIDTH;
     const constexpr auto MAXIMAL_ALLOWED_TRAFFIC_ISLAND_WIDTH = 10;
-    const auto distance_between_triangle_corners = util::coordinate_calculation::haversineDistance(
-        node_coordinates[node_based_graph.GetTarget(left_accumulator.via_edge_id)],
-        node_coordinates[node_based_graph.GetTarget(right_accumulator.via_edge_id)]);
+    const auto distance_between_triangle_corners =
+        util::coordinate_calculation::greatCircleDistance(
+            node_coordinates[node_based_graph.GetTarget(left_accumulator.via_edge_id)],
+            node_coordinates[node_based_graph.GetTarget(right_accumulator.via_edge_id)]);
     if (distance_between_triangle_corners >
         (assumed_road_width + MAXIMAL_ALLOWED_TRAFFIC_ISLAND_WIDTH))
         return false;
@@ -419,10 +420,10 @@ bool MergableRoadDetector::HaveSameDirection(const NodeID intersection_node,
     // sampling to correctly weight longer segments in regression calculations
     const auto constexpr SAMPLE_INTERVAL = 5;
     coordinates_to_the_left = coordinate_extractor.SampleCoordinates(
-        std::move(coordinates_to_the_left), distance_to_extract, SAMPLE_INTERVAL);
+        coordinates_to_the_left, distance_to_extract, SAMPLE_INTERVAL);
 
     coordinates_to_the_right = coordinate_extractor.SampleCoordinates(
-        std::move(coordinates_to_the_right), distance_to_extract, SAMPLE_INTERVAL);
+        coordinates_to_the_right, distance_to_extract, SAMPLE_INTERVAL);
 
     /* extract the number of lanes for a road
      * restricts a vector to the last two thirds of the length
@@ -540,7 +541,7 @@ bool MergableRoadDetector::IsTrafficIsland(const NodeID intersection_node,
     if (!degree_three_connect_in && !degree_three_connect_out)
         return false;
 
-    const auto distance_between_candidates = util::coordinate_calculation::haversineDistance(
+    const auto distance_between_candidates = util::coordinate_calculation::greatCircleDistance(
         node_coordinates[intersection_node], node_coordinates[left_candidate]);
 
     const auto both_split_join = degree_three_connect_in && degree_three_connect_out;
diff --git a/src/extractor/intersection/node_based_graph_walker.cpp b/src/extractor/intersection/node_based_graph_walker.cpp
index 23c33559e..308a467b2 100644
--- a/src/extractor/intersection/node_based_graph_walker.cpp
+++ b/src/extractor/intersection/node_based_graph_walker.cpp
@@ -50,7 +50,7 @@ void LengthLimitedCoordinateAccumulator::update(const NodeID from_node,
     const auto length =
         util::coordinate_calculation::getLength(current_coordinates.begin(),
                                                 current_coordinates.end(),
-                                                util::coordinate_calculation::haversineDistance);
+                                                util::coordinate_calculation::greatCircleDistance);
 
     // in case we get too many coordinates, we limit them to our desired length
     if (length + accumulated_length > max_length)
@@ -70,12 +70,12 @@ SelectRoadByNameOnlyChoiceAndStraightness::SelectRoadByNameOnlyChoiceAndStraight
 {
 }
 
-boost::optional<EdgeID> SelectRoadByNameOnlyChoiceAndStraightness::
-operator()(const NodeID /*nid*/,
-           const EdgeID /*via_edge_id*/,
-           const IntersectionView &intersection,
-           const util::NodeBasedDynamicGraph &node_based_graph,
-           const EdgeBasedNodeDataContainer &node_data_container) const
+boost::optional<EdgeID> SelectRoadByNameOnlyChoiceAndStraightness::operator()(
+    const NodeID /*nid*/,
+    const EdgeID /*via_edge_id*/,
+    const IntersectionView &intersection,
+    const util::NodeBasedDynamicGraph &node_based_graph,
+    const EdgeBasedNodeDataContainer &node_data_container) const
 {
     BOOST_ASSERT(!intersection.empty());
     const auto comparator = [&](const IntersectionViewData &lhs, const IntersectionViewData &rhs) {
@@ -120,12 +120,12 @@ SelectStraightmostRoadByNameAndOnlyChoice::SelectStraightmostRoadByNameAndOnlyCh
 {
 }
 
-boost::optional<EdgeID> SelectStraightmostRoadByNameAndOnlyChoice::
-operator()(const NodeID /*nid*/,
-           const EdgeID /*via_edge_id*/,
-           const IntersectionView &intersection,
-           const util::NodeBasedDynamicGraph &node_based_graph,
-           const EdgeBasedNodeDataContainer &node_data_container) const
+boost::optional<EdgeID> SelectStraightmostRoadByNameAndOnlyChoice::operator()(
+    const NodeID /*nid*/,
+    const EdgeID /*via_edge_id*/,
+    const IntersectionView &intersection,
+    const util::NodeBasedDynamicGraph &node_based_graph,
+    const EdgeBasedNodeDataContainer &node_data_container) const
 {
     BOOST_ASSERT(!intersection.empty());
     if (intersection.size() == 1)
diff --git a/src/extractor/location_dependent_data.cpp b/src/extractor/location_dependent_data.cpp
index 3140ee2f4..60186c2d6 100644
--- a/src/extractor/location_dependent_data.cpp
+++ b/src/extractor/location_dependent_data.cpp
@@ -218,7 +218,6 @@ std::vector<std::size_t> LocationDependentData::GetPropertyIndexes(const point_t
     // Search the R-tree and collect a Lua table of tags that correspond to the location
     rtree.query(boost::geometry::index::intersects(point) &&
                     boost::geometry::index::satisfies([this, &point](const rtree_t::value_type &v) {
-
                         // Simple point-in-polygon algorithm adapted from
                         // https://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
 
@@ -276,5 +275,5 @@ std::vector<std::size_t> LocationDependentData::GetPropertyIndexes(const point_t
 
     return result;
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/maneuver_override_relation_parser.cpp b/src/extractor/maneuver_override_relation_parser.cpp
index 94542eafb..5a48adfb4 100644
--- a/src/extractor/maneuver_override_relation_parser.cpp
+++ b/src/extractor/maneuver_override_relation_parser.cpp
@@ -1,14 +1,8 @@
 #include "extractor/maneuver_override_relation_parser.hpp"
 #include "extractor/maneuver_override.hpp"
 
-#include "util/log.hpp"
-
-#include <boost/algorithm/string.hpp>
-#include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/regex.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/ref.hpp>
-#include <boost/regex.hpp>
 
 #include <osmium/osm.hpp>
 #include <osmium/tags/filter.hpp>
@@ -136,5 +130,5 @@ ManeuverOverrideRelationParser::TryParse(const osmium::Relation &relation) const
     }
     return maneuver_override;
 }
-}
-}
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/node_based_graph_factory.cpp b/src/extractor/node_based_graph_factory.cpp
index e40436820..51473797d 100644
--- a/src/extractor/node_based_graph_factory.cpp
+++ b/src/extractor/node_based_graph_factory.cpp
@@ -19,14 +19,10 @@ NodeBasedGraphFactory::NodeBasedGraphFactory(
     const boost::filesystem::path &input_file,
     ScriptingEnvironment &scripting_environment,
     std::vector<TurnRestriction> &turn_restrictions,
-    std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
     std::vector<UnresolvedManeuverOverride> &maneuver_overrides)
 {
     LoadDataFromFile(input_file);
-    Compress(scripting_environment,
-             turn_restrictions,
-             conditional_turn_restrictions,
-             maneuver_overrides);
+    Compress(scripting_environment, turn_restrictions, maneuver_overrides);
     CompressGeometry();
     CompressAnnotationData();
 }
@@ -82,18 +78,15 @@ void NodeBasedGraphFactory::LoadDataFromFile(const boost::filesystem::path &inpu
     }());
 }
 
-void NodeBasedGraphFactory::Compress(
-    ScriptingEnvironment &scripting_environment,
-    std::vector<TurnRestriction> &turn_restrictions,
-    std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
-    std::vector<UnresolvedManeuverOverride> &maneuver_overrides)
+void NodeBasedGraphFactory::Compress(ScriptingEnvironment &scripting_environment,
+                                     std::vector<TurnRestriction> &turn_restrictions,
+                                     std::vector<UnresolvedManeuverOverride> &maneuver_overrides)
 {
     GraphCompressor graph_compressor;
     graph_compressor.Compress(barriers,
                               traffic_signals,
                               scripting_environment,
                               turn_restrictions,
-                              conditional_turn_restrictions,
                               maneuver_overrides,
                               compressed_output_graph,
                               annotation_data,
diff --git a/src/extractor/raster_source.cpp b/src/extractor/raster_source.cpp
index 10b517ef7..08a6bd324 100644
--- a/src/extractor/raster_source.cpp
+++ b/src/extractor/raster_source.cpp
@@ -169,5 +169,5 @@ RasterContainer::GetRasterInterpolateFromSource(unsigned int source_id, double l
 }
 
 RasterCache *RasterCache::g_instance = NULL;
-}
-}
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/restriction_compressor.cpp b/src/extractor/restriction_compressor.cpp
index 506fd1ed4..21fdd7f86 100644
--- a/src/extractor/restriction_compressor.cpp
+++ b/src/extractor/restriction_compressor.cpp
@@ -3,7 +3,6 @@
 
 #include <algorithm>
 #include <boost/assert.hpp>
-#include <utility>
 
 namespace osrm
 {
@@ -12,41 +11,35 @@ namespace extractor
 
 RestrictionCompressor::RestrictionCompressor(
     std::vector<TurnRestriction> &restrictions,
-    std::vector<ConditionalTurnRestriction> &conditional_turn_restrictions,
     std::vector<UnresolvedManeuverOverride> &maneuver_overrides)
 {
-    // add a node restriction ptr to the starts/ends maps, needs to be a reference!
+    // add a turn restriction ptr to the starts/ends maps, needs to be a reference!
     auto index = [&](auto &element) {
-        starts.insert(std::make_pair(element.from, &element));
-        ends.insert(std::make_pair(element.to, &element));
+        starts.insert({element.From(), &element});
+        ends.insert({element.To(), &element});
+        if (element.Type() == RestrictionType::WAY_RESTRICTION)
+        {
+            const auto &way_via = element.AsWayRestriction().via;
+            BOOST_ASSERT(way_via.size() >= 2);
+            // No need to track the first and last via nodes as they will not be compressed.
+            for (const auto &via_node :
+                 boost::make_iterator_range(way_via.begin() + 1, way_via.end() - 1))
+            {
+                vias.insert({via_node, &element});
+            }
+        }
     };
     // !needs to be reference, so we can get the correct address
-    const auto index_starts_and_ends = [&](auto &restriction) {
-        if (restriction.Type() == RestrictionType::WAY_RESTRICTION)
-        {
-            auto &way_restriction = restriction.AsWayRestriction();
-            index(way_restriction.in_restriction);
-            index(way_restriction.out_restriction);
-        }
-        else
-        {
-            BOOST_ASSERT(restriction.Type() == RestrictionType::NODE_RESTRICTION);
-            auto &node_restriction = restriction.AsNodeRestriction();
-            index(node_restriction);
-        }
-    };
+    const auto index_starts_ends_vias = [&](auto &restriction) { index(restriction); };
 
-    // add all restrictions as their respective startend pointers
-    std::for_each(restrictions.begin(), restrictions.end(), index_starts_and_ends);
-    std::for_each(conditional_turn_restrictions.begin(),
-                  conditional_turn_restrictions.end(),
-                  index_starts_and_ends);
+    // add all restrictions as their respective start/via/end pointers
+    std::for_each(restrictions.begin(), restrictions.end(), index_starts_ends_vias);
 
     auto index_maneuver = [&](auto &maneuver) {
         for (auto &turn : maneuver.turn_sequence)
         {
-            maneuver_starts.insert(std::make_pair(turn.from, &turn));
-            maneuver_ends.insert(std::make_pair(turn.to, &turn));
+            maneuver_starts.insert({turn.from, &turn});
+            maneuver_ends.insert({turn.to, &turn});
         }
     };
     // !needs to be reference, so we can get the correct address
@@ -58,26 +51,48 @@ RestrictionCompressor::RestrictionCompressor(
 void RestrictionCompressor::Compress(const NodeID from, const NodeID via, const NodeID to)
 {
     // handle turn restrictions
-    // extract all startptrs and move them from via to from.
+    // extract all start ptrs and move them from via to from.
     auto all_starts_range = starts.equal_range(via);
-    std::vector<NodeRestriction *> start_ptrs;
+    std::vector<TurnRestriction *> start_ptrs;
     std::transform(all_starts_range.first,
                    all_starts_range.second,
                    std::back_inserter(start_ptrs),
                    [](const auto pair) { return pair.second; });
 
     const auto update_start = [&](auto ptr) {
-        // ____ | from - p.from | via - p.via | to - p.to | ____
-        BOOST_ASSERT(ptr->from == via);
-        if (ptr->via == to)
+        if (ptr->Type() == RestrictionType::NODE_RESTRICTION)
         {
-            ptr->from = from;
+
+            // ____ | from - p.from | via - p.via | to - p.to | ____
+            auto &node_ptr = ptr->AsNodeRestriction();
+            BOOST_ASSERT(node_ptr.from == via);
+            if (node_ptr.via == to)
+            {
+                node_ptr.from = from;
+            }
+            // ____ | to - p.from | via - p.via | from - p.to | ____
+            else
+            {
+                BOOST_ASSERT(node_ptr.via == from);
+                node_ptr.from = to;
+            }
         }
-        // ____ | to - p.from | via - p.via | from - p.to | ____
         else
         {
-            BOOST_ASSERT(ptr->via == from);
-            ptr->from = to;
+            BOOST_ASSERT(ptr->Type() == RestrictionType::WAY_RESTRICTION);
+            auto &way_ptr = ptr->AsWayRestriction();
+            // ____ | from - p.from | via - p.via[0] | to - p[1..],p.to | ____
+            BOOST_ASSERT(way_ptr.from == via);
+            if (way_ptr.via.front() == to)
+            {
+                way_ptr.from = from;
+            }
+            // ____ | to - p.from | via - p.via[0] | from - p[1,..],p.to | ____
+            else
+            {
+                BOOST_ASSERT(way_ptr.via.front() == from);
+                way_ptr.from = to;
+            }
         }
     };
 
@@ -86,29 +101,52 @@ void RestrictionCompressor::Compress(const NodeID from, const NodeID via, const
     // update the ptrs in our mapping
     starts.erase(via);
 
-    const auto reinsert_start = [&](auto ptr) { starts.insert(std::make_pair(ptr->from, ptr)); };
+    const auto reinsert_start = [&](auto ptr) { starts.insert({ptr->From(), ptr}); };
     std::for_each(start_ptrs.begin(), start_ptrs.end(), reinsert_start);
 
     // extract all end ptrs and move them from via to to
     auto all_ends_range = ends.equal_range(via);
-    std::vector<NodeRestriction *> end_ptrs;
+    std::vector<TurnRestriction *> end_ptrs;
     std::transform(all_ends_range.first,
                    all_ends_range.second,
                    std::back_inserter(end_ptrs),
                    [](const auto pair) { return pair.second; });
 
     const auto update_end = [&](auto ptr) {
-        BOOST_ASSERT(ptr->to == via);
-        // p.from | ____ - p.via | from - p.to | via - ____ | to
-        if (ptr->via == from)
+        if (ptr->Type() == RestrictionType::NODE_RESTRICTION)
         {
-            ptr->to = to;
+            auto &node_ptr = ptr->AsNodeRestriction();
+
+            BOOST_ASSERT(node_ptr.to == via);
+            // p.from | ____ - p.via | from - p.to | via - ____ | to
+            if (node_ptr.via == from)
+            {
+                node_ptr.to = to;
+            }
+            // p.from | ____ - p.via | to - p.to | via - ____ | from
+            else
+            {
+                BOOST_ASSERT(node_ptr.via == to);
+                node_ptr.to = from;
+            }
         }
-        // p.from | ____ - p.via | to - p.to | via - ____ | from
         else
         {
-            BOOST_ASSERT(ptr->via == to);
-            ptr->to = from;
+            BOOST_ASSERT(ptr->Type() == RestrictionType::WAY_RESTRICTION);
+            auto &way_ptr = ptr->AsWayRestriction();
+
+            BOOST_ASSERT(way_ptr.to == via);
+            // p.from,p.via[..,n-1] | ____ - p.via[n] | from - p.to | via - ____ | to
+            if (way_ptr.via.back() == from)
+            {
+                way_ptr.to = to;
+            }
+            // p.from,p.via[..,n-1] | ____ - p.via[n] | to - p.to | via - ____ | from
+            else
+            {
+                BOOST_ASSERT(way_ptr.via.back() == to);
+                way_ptr.to = from;
+            }
         }
     };
     std::for_each(end_ptrs.begin(), end_ptrs.end(), update_end);
@@ -116,9 +154,24 @@ void RestrictionCompressor::Compress(const NodeID from, const NodeID via, const
     // update end ptrs in mapping
     ends.erase(via);
 
-    const auto reinsert_end = [&](auto ptr) { ends.insert(std::make_pair(ptr->to, ptr)); };
+    const auto reinsert_end = [&](auto ptr) { ends.insert({ptr->To(), ptr}); };
     std::for_each(end_ptrs.begin(), end_ptrs.end(), reinsert_end);
 
+    // remove compressed node from all via paths
+    auto all_vias_range = vias.equal_range(via);
+
+    const auto update_via = [&](auto restriction_pair) {
+        BOOST_ASSERT(restriction_pair.second->Type() == RestrictionType::WAY_RESTRICTION);
+        auto &way_ptr = restriction_pair.second->AsWayRestriction();
+        BOOST_ASSERT(std::find(way_ptr.via.begin(), way_ptr.via.end(), via) != way_ptr.via.end());
+        way_ptr.via.erase(std::remove(way_ptr.via.begin(), way_ptr.via.end(), via),
+                          way_ptr.via.end());
+    };
+    std::for_each(all_vias_range.first, all_vias_range.second, update_via);
+
+    // update via ptrs in mapping
+    vias.erase(via);
+
     /**********************************************************************************************/
 
     // handle maneuver overrides from nodes
@@ -149,9 +202,7 @@ void RestrictionCompressor::Compress(const NodeID from, const NodeID via, const
 
     // update the ptrs in our mapping
     maneuver_starts.erase(via);
-    const auto reinsert_start_mnv = [&](auto ptr) {
-        maneuver_starts.insert(std::make_pair(ptr->from, ptr));
-    };
+    const auto reinsert_start_mnv = [&](auto ptr) { maneuver_starts.insert({ptr->from, ptr}); };
     std::for_each(mnv_start_ptrs.begin(), mnv_start_ptrs.end(), reinsert_start_mnv);
 
     /**********************************************************************************************/
@@ -183,9 +234,7 @@ void RestrictionCompressor::Compress(const NodeID from, const NodeID via, const
     // update end ptrs in mapping
     maneuver_ends.erase(via);
 
-    const auto reinsert_end_mnvs = [&](auto ptr) {
-        maneuver_ends.insert(std::make_pair(ptr->to, ptr));
-    };
+    const auto reinsert_end_mnvs = [&](auto ptr) { maneuver_ends.insert({ptr->to, ptr}); };
     std::for_each(mnv_end_ptrs.begin(), mnv_end_ptrs.end(), reinsert_end_mnvs);
 }
 
diff --git a/src/extractor/restriction_filter.cpp b/src/extractor/restriction_filter.cpp
index ff14ece13..cc5484e06 100644
--- a/src/extractor/restriction_filter.cpp
+++ b/src/extractor/restriction_filter.cpp
@@ -1,5 +1,6 @@
 #include "extractor/restriction_filter.hpp"
 #include "util/node_based_graph.hpp"
+#include "util/timing_util.hpp"
 #include "util/typedefs.hpp"
 
 #include <algorithm>
@@ -10,60 +11,48 @@ namespace osrm
 namespace extractor
 {
 
-std::vector<ConditionalTurnRestriction>
-removeInvalidRestrictions(std::vector<ConditionalTurnRestriction> restrictions,
+std::vector<TurnRestriction>
+removeInvalidRestrictions(std::vector<TurnRestriction> restrictions,
                           const util::NodeBasedDynamicGraph &node_based_graph)
 {
-    // definition of what we presume to be a valid via-node restriction
-    const auto is_valid_node = [&node_based_graph](const auto &node_restriction) {
-        // a valid restriction needs to be connected to both its from and to locations
-        bool found_from = false, found_to = false;
-        for (auto eid : node_based_graph.GetAdjacentEdgeRange(node_restriction.via))
+    util::UnbufferedLog log;
+    log << "Removing invalid restrictions...";
+    TIMER_START(remove_invalid_restrictions);
+
+    const auto is_valid_edge = [&node_based_graph](const auto from, const auto to) {
+        const auto eid = node_based_graph.FindEdge(from, to);
+        if (eid == SPECIAL_EDGEID)
         {
-            const auto target = node_based_graph.GetTarget(eid);
-            if (target == node_restriction.from)
-                found_from = true;
-            if (target == node_restriction.to)
-                found_to = true;
+            util::Log(logDEBUG) << "Restriction has invalid edge: " << from << ", " << to;
+            return false;
         }
 
-        if (!found_from || !found_to)
+        const auto &edge_data = node_based_graph.GetEdgeData(eid);
+        if (edge_data.reversed)
+        {
+            util::Log(logDEBUG) << "Restriction has non-traversable edge: " << from << ", " << to;
             return false;
-
+        }
         return true;
     };
 
-    // definition of what we presume to be a valid via-way restriction
-    const auto is_valid_way = [&node_based_graph, is_valid_node](const auto &way_restriction) {
-        const auto eid = node_based_graph.FindEdge(way_restriction.in_restriction.via,
-                                                   way_restriction.out_restriction.via);
+    const auto is_valid_node = [is_valid_edge](const auto &node_restriction) {
+        return is_valid_edge(node_restriction.from, node_restriction.via) &&
+               is_valid_edge(node_restriction.via, node_restriction.to);
+    };
 
-        // ability filter, we currently cannot handle restrictions that do not match up in geometry:
-        // restrictions cannot be interrupted by traffic signals or other similar entities that
-        // cause node penalties
-        if ((way_restriction.in_restriction.via != way_restriction.out_restriction.from) ||
-            (way_restriction.out_restriction.via != way_restriction.in_restriction.to))
+    const auto is_valid_way = [is_valid_edge](const auto &way_restriction) {
+        if (!is_valid_edge(way_restriction.from, way_restriction.via.front()))
             return false;
 
-        // the edge needs to exit (we cannot handle intermediate stuff, so far)
-        if (eid == SPECIAL_EDGEID)
+        const auto invalid_it = std::adjacent_find(
+            way_restriction.via.begin(),
+            way_restriction.via.end(),
+            [&](auto via_from, auto via_to) { return !is_valid_edge(via_from, via_to); });
+        if (invalid_it != way_restriction.via.end())
             return false;
 
-        const auto &data = node_based_graph.GetEdgeData(eid);
-
-        // edge needs to be traversable for a valid restrction
-        if (data.reversed)
-            return false;
-
-        // is the in restriction referencing the correct nodes
-        if (!is_valid_node(way_restriction.in_restriction))
-            return false;
-
-        // is the out restriction referencing the correct nodes
-        if (!is_valid_node(way_restriction.out_restriction))
-            return false;
-
-        return true;
+        return is_valid_edge(way_restriction.via.back(), way_restriction.to);
     };
 
     const auto is_invalid = [is_valid_way, is_valid_node](const auto &restriction) {
@@ -80,8 +69,13 @@ removeInvalidRestrictions(std::vector<ConditionalTurnRestriction> restrictions,
 
     const auto end_valid_restrictions =
         std::remove_if(restrictions.begin(), restrictions.end(), is_invalid);
+    const auto num_removed = std::distance(end_valid_restrictions, restrictions.end());
     restrictions.erase(end_valid_restrictions, restrictions.end());
 
+    TIMER_STOP(remove_invalid_restrictions);
+    log << "removed " << num_removed << " invalid restrictions, after "
+        << TIMER_SEC(remove_invalid_restrictions) << "s";
+
     return restrictions;
 }
 
diff --git a/src/extractor/restriction_graph.cpp b/src/extractor/restriction_graph.cpp
new file mode 100644
index 000000000..376b56b0e
--- /dev/null
+++ b/src/extractor/restriction_graph.cpp
@@ -0,0 +1,287 @@
+#include "extractor/restriction_graph.hpp"
+#include "util/node_based_graph.hpp"
+#include "util/timing_util.hpp"
+#include <util/for_each_pair.hpp>
+
+#include <boost/assign.hpp>
+#include <boost/range/algorithm/copy.hpp>
+
+namespace osrm
+{
+namespace extractor
+{
+
+namespace restriction_graph_details
+{
+
+void insertEdge(RestrictionGraph &rg, const RestrictionID id, const RestrictionEdge &edge)
+{
+    const auto range = rg.GetEdges(id);
+    auto &node = rg.nodes[id];
+    if (node.edges_begin_idx + range.size() != rg.edges.size())
+    {
+        // Most nodes will only have one edge, so this copy will be infrequent
+        node.edges_begin_idx = rg.edges.size();
+        std::copy(range.begin(), range.end(), std::back_inserter(rg.edges));
+    }
+    rg.edges.push_back(edge);
+    node.num_edges += 1;
+}
+
+void insertRestriction(RestrictionGraph &rg,
+                       const RestrictionID id,
+                       const TurnRestriction *restriction)
+{
+    const auto range = rg.GetRestrictions(id);
+    auto &node = rg.nodes[id];
+    if (node.restrictions_begin_idx + range.size() != rg.restrictions.size())
+    {
+        // Most nodes will only have zero or one restriction, so this copy will be infrequent
+        node.restrictions_begin_idx = rg.restrictions.size();
+        std::copy(range.begin(), range.end(), std::back_inserter(rg.restrictions));
+    }
+    rg.restrictions.push_back(restriction);
+    node.num_restrictions += 1;
+}
+
+RestrictionID getOrInsertStartNode(RestrictionGraph &rg, NodeID from, NodeID to)
+{
+    auto start_edge = std::make_pair(from, to);
+    auto start_node_idx_itr = rg.start_edge_to_node.find(start_edge);
+    if (start_node_idx_itr == rg.start_edge_to_node.end())
+    {
+        // First time we have seen a restriction start from this edge.
+        auto start_node_idx = rg.nodes.size();
+        rg.nodes.push_back(RestrictionNode{rg.restrictions.size(), 0, rg.edges.size(), 0});
+        start_node_idx_itr = rg.start_edge_to_node.insert({start_edge, start_node_idx}).first;
+    }
+    return start_node_idx_itr->second;
+}
+
+RestrictionID insertViaNode(RestrictionGraph &rg, NodeID from, NodeID to)
+{
+    auto new_via_node_idx = rg.nodes.size();
+    rg.nodes.push_back(RestrictionNode{rg.restrictions.size(), 0, rg.edges.size(), 0});
+    rg.via_edge_to_node.insert({{from, to}, new_via_node_idx});
+    return new_via_node_idx;
+}
+
+// pathBuilder builds the prefix tree structure that is used to first insert turn restrictions
+// into the graph.
+struct pathBuilder
+{
+    RestrictionGraph &rg;
+    RestrictionID cur_node;
+
+    pathBuilder(RestrictionGraph &rg_) : rg(rg_) { cur_node = SPECIAL_RESTRICTIONID; }
+
+    static std::string name() { return "path builder"; };
+
+    void start(NodeID from, NodeID to) { cur_node = getOrInsertStartNode(rg, from, to); }
+
+    void next(NodeID from, NodeID to)
+    {
+        const auto &edge_range = rg.GetEdges(cur_node);
+        auto edge_to_itr = std::find_if(edge_range.begin(),
+                                        edge_range.end(),
+                                        [&](const auto &edge) { return edge.node_based_to == to; });
+        if (edge_to_itr != edge_range.end())
+        {
+            cur_node = edge_to_itr->target;
+            return;
+        }
+
+        // This is a new restriction path we have not seen before.
+        // Add a new via node and edge to the tree.
+        auto new_via_node_idx = insertViaNode(rg, from, to);
+        insertEdge(rg, cur_node, RestrictionEdge{to, new_via_node_idx, false});
+
+        cur_node = new_via_node_idx;
+    }
+
+    void end(const TurnRestriction &restriction) { insertRestriction(rg, cur_node, &restriction); }
+};
+
+// transferBuilder adds the transfer edges between overlapping restriction paths. It does this
+// by tracking paths in the graph that can be equal to a suffix of a restriction path, and
+// attempting to connect the them with a new edge.
+struct transferBuilder
+{
+    RestrictionGraph &rg;
+    std::vector<RestrictionID> suffix_nodes;
+    RestrictionID cur_node;
+
+    transferBuilder(RestrictionGraph &rg_) : rg(rg_) { cur_node = SPECIAL_RESTRICTIONID; }
+
+    static std::string name() { return "transfer builder"; };
+
+    void start(NodeID from, NodeID to) { cur_node = getOrInsertStartNode(rg, from, to); }
+
+    void next_suffixes(NodeID from, NodeID to)
+    {
+        // Update the suffix paths to include those that also have this edge
+        auto new_suffix_it = suffix_nodes.begin();
+        for (const auto &suffix_node : suffix_nodes)
+        {
+            const auto &edges = rg.GetEdges(suffix_node);
+            const auto edge_it = std::find_if(edges.begin(), edges.end(), [&to](const auto &edge) {
+                return edge.node_based_to == to && !edge.is_transfer;
+            });
+            if (edge_it != edges.end())
+            {
+                *(new_suffix_it++) = edge_it->target;
+            }
+        }
+        suffix_nodes.erase(new_suffix_it, suffix_nodes.end());
+
+        // Add a start node if it is a trivial suffix
+        auto start_way_it = rg.start_edge_to_node.find({from, to});
+        if (start_way_it != rg.start_edge_to_node.end())
+        {
+            suffix_nodes.push_back({start_way_it->second});
+        }
+    }
+
+    // For each edge on path, if there is an edge in the suffix path not on the current
+    // path, add as a transfer.
+    void add_suffix_transfer(const RestrictionID &suffix_node)
+    {
+        for (const auto &suffix_edge : rg.GetEdges(suffix_node))
+        {
+            if (suffix_edge.is_transfer)
+                continue;
+
+            // Check there are no unconditional restrictions at the current node that would prevent
+            // the transfer
+            const auto &restrictions = rg.GetRestrictions(cur_node);
+            const auto is_restricted =
+                std::any_of(restrictions.begin(), restrictions.end(), [&](const auto &restriction) {
+                    return restriction->IsTurnRestricted(suffix_edge.node_based_to) &&
+                           restriction->IsUnconditional();
+                });
+            if (is_restricted)
+                continue;
+
+            const auto &edges = rg.GetEdges(cur_node);
+            // Check that the suffix edge is not a next edge along the current path.
+            const auto can_transfer = std::none_of(edges.begin(), edges.end(), [&](auto &edge) {
+                return edge.node_based_to == suffix_edge.node_based_to;
+            });
+            if (can_transfer)
+            {
+                insertEdge(rg,
+                           cur_node,
+                           RestrictionEdge{suffix_edge.node_based_to, suffix_edge.target, true});
+            }
+        }
+    };
+
+    void next(NodeID from, NodeID to)
+    {
+        const auto &edges = rg.GetEdges(cur_node);
+        auto next_edge_itr = std::find_if(
+            edges.begin(), edges.end(), [&](const auto edge) { return edge.node_based_to == to; });
+
+        // We know this edge exists
+        cur_node = next_edge_itr->target;
+
+        this->next_suffixes(from, to);
+
+        std::for_each(suffix_nodes.begin(), suffix_nodes.end(), [&](const auto &suffix_node) {
+            this->add_suffix_transfer(suffix_node);
+        });
+
+        for (const auto &suffix_node : suffix_nodes)
+        {
+            // Also add any restrictions from suffix paths to the current node in the
+            // restriction graph.
+            for (const auto &restriction : rg.GetRestrictions(suffix_node))
+            {
+                insertRestriction(rg, cur_node, restriction);
+            }
+        }
+    }
+
+    void end(const TurnRestriction & /*unused*/) {}
+};
+
+template <typename builder_type>
+void buildGraph(RestrictionGraph &rg, const std::vector<TurnRestriction> &restrictions)
+{
+    const auto run_builder = [&](const auto &restriction) {
+        builder_type builder(rg);
+
+        builder.start(restriction.From(), restriction.FirstVia());
+        if (restriction.Type() == RestrictionType::WAY_RESTRICTION)
+        {
+            const auto &way_restriction = restriction.AsWayRestriction();
+            util::for_each_pair(way_restriction.via,
+                                [&](NodeID from, NodeID to) { builder.next(from, to); });
+        }
+        builder.end(restriction);
+    };
+
+    std::for_each(restrictions.begin(), restrictions.end(), run_builder);
+}
+} // namespace restriction_graph_details
+
+RestrictionGraph constructRestrictionGraph(const std::vector<TurnRestriction> &turn_restrictions)
+{
+    util::UnbufferedLog log;
+    log << "Constructing restriction graph on " << turn_restrictions.size() << " restrictions...";
+    TIMER_START(construct_restriction_graph);
+
+    namespace rgd = restriction_graph_details;
+    RestrictionGraph rg;
+    rgd::buildGraph<rgd::pathBuilder>(rg, turn_restrictions);
+    rgd::buildGraph<rgd::transferBuilder>(rg, turn_restrictions);
+
+    // Reorder nodes so that via nodes are at the front. This makes it easier to represent the
+    // bijection between restriction graph via nodes and edge-based graph duplicate nodes.
+    std::vector<bool> is_via_node(rg.nodes.size(), false);
+    for (const auto &entry : rg.via_edge_to_node)
+    {
+        is_via_node[entry.second] = true;
+    }
+    std::vector<RestrictionID> ordering(rg.nodes.size());
+    std::iota(ordering.begin(), ordering.end(), 0);
+    std::partition(ordering.begin(), ordering.end(), [&](const auto i) { return is_via_node[i]; });
+    // Start renumbering
+    const auto permutation = util::orderingToPermutation(ordering);
+    util::inplacePermutation(rg.nodes.begin(), rg.nodes.end(), permutation);
+    std::for_each(rg.edges.begin(), rg.edges.end(), [&](auto &edge) {
+        edge.target = permutation[edge.target];
+    });
+    rg.num_via_nodes = std::count(is_via_node.begin(), is_via_node.end(), true);
+    for (auto &entry : rg.via_edge_to_node)
+    {
+        entry.second = permutation[entry.second];
+    }
+    for (auto &entry : rg.start_edge_to_node)
+    {
+        entry.second = permutation[entry.second];
+    }
+
+    TIMER_STOP(construct_restriction_graph);
+    log << "ok, after " << TIMER_SEC(construct_restriction_graph) << "s";
+
+    return rg;
+}
+
+RestrictionGraph::RestrictionRange RestrictionGraph::GetRestrictions(RestrictionID id) const
+{
+    const auto &node = nodes[id];
+    return boost::make_iterator_range(restrictions.begin() + node.restrictions_begin_idx,
+                                      restrictions.begin() + node.restrictions_begin_idx +
+                                          node.num_restrictions);
+}
+
+RestrictionGraph::EdgeRange RestrictionGraph::GetEdges(RestrictionID id) const
+{
+    const auto &node = nodes[id];
+    return boost::make_iterator_range(edges.begin() + node.edges_begin_idx,
+                                      edges.begin() + node.edges_begin_idx + node.num_edges);
+}
+
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/restriction_parser.cpp b/src/extractor/restriction_parser.cpp
index 7c8f27031..c81f4331d 100644
--- a/src/extractor/restriction_parser.cpp
+++ b/src/extractor/restriction_parser.cpp
@@ -4,18 +4,14 @@
 #include "util/conditional_restrictions.hpp"
 #include "util/log.hpp"
 
-#include <boost/algorithm/string.hpp>
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/algorithm/string/regex.hpp>
 #include <boost/optional/optional.hpp>
 #include <boost/ref.hpp>
-#include <boost/regex.hpp>
 
 #include <osmium/osm.hpp>
 #include <osmium/tags/regex_filter.hpp>
 
 #include <algorithm>
-#include <iterator>
 
 namespace osrm
 {
@@ -54,7 +50,7 @@ RestrictionParser::RestrictionParser(bool use_turn_restrictions_,
  * in the corresponding profile. We use it for both namespacing restrictions, as in
  * restriction:motorcar as well as whitelisting if its in except:motorcar.
  */
-boost::optional<InputConditionalTurnRestriction>
+boost::optional<InputTurnRestriction>
 RestrictionParser::TryParse(const osmium::Relation &relation) const
 {
     // return if turn restrictions should be ignored
@@ -122,14 +118,13 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
         }
     }
 
-    // we pretend every restriction is a conditional restriction. If we do not find any restriction,
-    // we can trim away the vector after parsing
-    InputConditionalTurnRestriction restriction_container;
+    InputTurnRestriction restriction_container;
     restriction_container.is_only = is_only_restriction;
 
     constexpr auto INVALID_OSM_ID = std::numeric_limits<std::uint64_t>::max();
     auto from = INVALID_OSM_ID;
-    auto via = INVALID_OSM_ID;
+    auto via_node = INVALID_OSM_ID;
+    std::vector<OSMWayID> via_ways;
     auto to = INVALID_OSM_ID;
     bool is_node_restriction = true;
 
@@ -152,7 +147,7 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
                 continue;
             }
             BOOST_ASSERT(0 == strcmp("via", role));
-            via = static_cast<std::uint64_t>(member.ref());
+            via_node = static_cast<std::uint64_t>(member.ref());
             is_node_restriction = true;
             // set via node id
             break;
@@ -170,7 +165,7 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
             }
             else if (0 == strcmp("via", role))
             {
-                via = static_cast<std::uint64_t>(member.ref());
+                via_ways.push_back({static_cast<std::uint64_t>(member.ref())});
                 is_node_restriction = false;
             }
             break;
@@ -211,17 +206,18 @@ RestrictionParser::TryParse(const osmium::Relation &relation) const
         }
     }
 
-    if (from != INVALID_OSM_ID && via != INVALID_OSM_ID && to != INVALID_OSM_ID)
+    if (from != INVALID_OSM_ID && (via_node != INVALID_OSM_ID || !via_ways.empty()) &&
+        to != INVALID_OSM_ID)
     {
         if (is_node_restriction)
         {
             // template struct requires bracket for ID initialisation :(
-            restriction_container.node_or_way = InputNodeRestriction{{from}, {via}, {to}};
+            restriction_container.node_or_way = InputNodeRestriction{{from}, {via_node}, {to}};
         }
         else
         {
             // template struct requires bracket for ID initialisation :(
-            restriction_container.node_or_way = InputWayRestriction{{from}, {via}, {to}};
+            restriction_container.node_or_way = InputWayRestriction{{from}, via_ways, {to}};
         }
         return restriction_container;
     }
@@ -246,14 +242,15 @@ bool RestrictionParser::ShouldIgnoreRestriction(const std::string &except_tag_st
 
     // Be warned, this is quadratic work here, but we assume that
     // only a few exceptions are actually defined.
-    std::vector<std::string> exceptions;
-    boost::algorithm::split_regex(exceptions, except_tag_string, boost::regex("[;][ ]*"));
+    const std::regex delimiter_re("[;][ ]*");
+    std::sregex_token_iterator except_tags_begin(
+        except_tag_string.begin(), except_tag_string.end(), delimiter_re, -1);
+    std::sregex_token_iterator except_tags_end;
 
-    return std::any_of(
-        std::begin(exceptions), std::end(exceptions), [&](const std::string &current_string) {
-            return std::end(restrictions) !=
-                   std::find(std::begin(restrictions), std::end(restrictions), current_string);
-        });
-}
-}
+    return std::any_of(except_tags_begin, except_tags_end, [&](const std::string &current_string) {
+        return std::end(restrictions) !=
+               std::find(std::begin(restrictions), std::end(restrictions), current_string);
+    });
 }
+} // namespace extractor
+} // namespace osrm
diff --git a/src/extractor/scripting_environment_lua.cpp b/src/extractor/scripting_environment_lua.cpp
index ad7cb3b73..2d0978d51 100644
--- a/src/extractor/scripting_environment_lua.cpp
+++ b/src/extractor/scripting_environment_lua.cpp
@@ -37,7 +37,7 @@ template <> struct is_container<osmium::Way> : std::false_type
 template <> struct is_container<osmium::Relation> : std::false_type
 {
 };
-}
+} // namespace sol
 
 namespace osrm
 {
@@ -88,10 +88,10 @@ struct to_lua_object : public boost::static_visitor<sol::object>
 {
     to_lua_object(sol::state &state) : state(state) {}
     template <typename T> auto operator()(T &v) const { return sol::make_object(state, v); }
-    auto operator()(boost::blank &) const { return sol::nil; }
+    auto operator()(boost::blank &) const { return sol::lua_nil; }
     sol::state &state;
 };
-}
+} // namespace
 
 Sol2ScriptingEnvironment::Sol2ScriptingEnvironment(
     const std::string &file_name,
@@ -236,7 +236,7 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
 
     auto get_location_tag = [](auto &context, const auto &location, const char *key) {
         if (context.location_dependent_data.empty())
-            return sol::object(sol::nil);
+            return sol::object(context.state);
 
         const LocationDependentData::point_t point{location.lon(), location.lat()};
         if (!boost::geometry::equals(context.last_location_point, point))
@@ -259,7 +259,7 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
         "version",
         &osmium::Way::version,
         "get_nodes",
-        [](const osmium::Way &way) { return sol::as_table(way.nodes()); },
+        [](const osmium::Way &way) { return sol::as_table(&way.nodes()); },
         "get_location_tag",
         [&context, &get_location_tag](const osmium::Way &way, const char *key) {
             // HEURISTIC: use a single node (last) of the way to localize the way
@@ -424,8 +424,8 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
         "get_relations",
         [&getTypedRefBySol](ExtractionRelationContainer &cont, const sol::object &obj)
             -> const ExtractionRelationContainer::RelationIDList & {
-                return cont.GetRelations(getTypedRefBySol(obj));
-            },
+            return cont.GetRelations(getTypedRefBySol(obj));
+        },
         "relation",
         [](ExtractionRelationContainer &cont, const ExtractionRelation::OsmIDTyped &rel_id)
             -> const ExtractionRelation & { return cont.GetRelationData(rel_id); });
@@ -589,7 +589,6 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
     };
 
     auto initialize_V3_extraction_turn = [&]() {
-
         context.state.new_usertype<ExtractionTurn>(
             "ExtractionTurn",
             "angle",
@@ -871,7 +870,7 @@ void Sol2ScriptingEnvironment::ProcessElements(
     const ExtractionRelationContainer &relations,
     std::vector<std::pair<const osmium::Node &, ExtractionNode>> &resulting_nodes,
     std::vector<std::pair<const osmium::Way &, ExtractionWay>> &resulting_ways,
-    std::vector<InputConditionalTurnRestriction> &resulting_restrictions,
+    std::vector<InputTurnRestriction> &resulting_restrictions,
     std::vector<InputManeuverOverride> &resulting_maneuver_overrides)
 {
     ExtractionNode result_node;
@@ -885,18 +884,20 @@ void Sol2ScriptingEnvironment::ProcessElements(
         case osmium::item_type::node:
         {
             const auto &node = static_cast<const osmium::Node &>(*entity);
+            // NOLINTNEXTLINE(bugprone-use-after-move)
             result_node.clear();
             if (local_context.has_node_function &&
                 (!node.tags().empty() || local_context.properties.call_tagless_node_function))
             {
                 local_context.ProcessNode(node, result_node, relations);
             }
-            resulting_nodes.push_back({node, std::move(result_node)});
+            resulting_nodes.push_back({node, result_node});
         }
         break;
         case osmium::item_type::way:
         {
             const osmium::Way &way = static_cast<const osmium::Way &>(*entity);
+            // NOLINTNEXTLINE(bugprone-use-after-move)
             result_way.clear();
             if (local_context.has_way_function)
             {
@@ -928,7 +929,7 @@ std::vector<std::string>
 Sol2ScriptingEnvironment::GetStringListFromFunction(const std::string &function_name)
 {
     auto &context = GetSol2Context();
-    BOOST_ASSERT(context.state.lua_state() != nullptr);
+    BOOST_ASSERT(context.state.lua_state());
     std::vector<std::string> strings;
     sol::function function = context.state[function_name];
     if (function.valid())
@@ -938,18 +939,38 @@ Sol2ScriptingEnvironment::GetStringListFromFunction(const std::string &function_
     return strings;
 }
 
+namespace
+{
+
+// string list can be defined either as a Set(see profiles/lua/set.lua) or as a Sequence (see
+// profiles/lua/sequence.lua) `Set` is a table with keys that are actual values we are looking for
+// and values that always `true`. `Sequence` is a table with keys that are indices and values that
+// are actual values we are looking for.
+
+std::string GetSetOrSequenceValue(const std::pair<sol::object, sol::object> &pair)
+{
+    if (pair.second.is<std::string>())
+    {
+        return pair.second.as<std::string>();
+    }
+    BOOST_ASSERT(pair.first.is<std::string>());
+    return pair.first.as<std::string>();
+}
+
+} // namespace
+
 std::vector<std::string>
 Sol2ScriptingEnvironment::GetStringListFromTable(const std::string &table_name)
 {
     auto &context = GetSol2Context();
     BOOST_ASSERT(context.state.lua_state() != nullptr);
     std::vector<std::string> strings;
-    sol::table table = context.profile_table[table_name];
-    if (table.valid())
+    sol::optional<sol::table> table = context.profile_table[table_name];
+    if (table && table->valid())
     {
-        for (auto &&pair : table)
+        for (auto &&pair : *table)
         {
-            strings.push_back(pair.second.as<std::string>());
+            strings.emplace_back(GetSetOrSequenceValue(pair));
         }
     }
     return strings;
@@ -962,13 +983,13 @@ Sol2ScriptingEnvironment::GetStringListsFromTable(const std::string &table_name)
 
     auto &context = GetSol2Context();
     BOOST_ASSERT(context.state.lua_state() != nullptr);
-    sol::table table = context.profile_table[table_name];
-    if (!table.valid())
+    sol::optional<sol::table> table = context.profile_table[table_name];
+    if (!table || !table->valid())
     {
         return string_lists;
     }
 
-    for (const auto &pair : table)
+    for (const auto &pair : *table)
     {
         sol::table inner_table = pair.second;
         if (!inner_table.valid())
@@ -980,7 +1001,7 @@ Sol2ScriptingEnvironment::GetStringListsFromTable(const std::string &table_name)
         std::vector<std::string> inner_vector;
         for (const auto &inner_pair : inner_table)
         {
-            inner_vector.push_back(inner_pair.first.as<std::string>());
+            inner_vector.emplace_back(GetSetOrSequenceValue(inner_pair));
         }
         string_lists.push_back(std::move(inner_vector));
     }
@@ -1072,7 +1093,7 @@ void Sol2ScriptingEnvironment::ProcessTurn(ExtractionTurn &turn)
     case 2:
         if (context.has_turn_penalty_function)
         {
-            context.turn_function(context.profile_table, turn);
+            context.turn_function(context.profile_table, std::ref(turn));
 
             // Turn weight falls back to the duration value in deciseconds
             // or uses the extracted unit-less weight value
@@ -1087,7 +1108,7 @@ void Sol2ScriptingEnvironment::ProcessTurn(ExtractionTurn &turn)
     case 1:
         if (context.has_turn_penalty_function)
         {
-            context.turn_function(turn);
+            context.turn_function(std::ref(turn));
 
             // Turn weight falls back to the duration value in deciseconds
             // or uses the extracted unit-less weight value
@@ -1138,14 +1159,16 @@ void Sol2ScriptingEnvironment::ProcessSegment(ExtractionSegment &segment)
         case 4:
         case 3:
         case 2:
-            context.segment_function(context.profile_table, segment);
+            context.segment_function(context.profile_table, std::ref(segment));
             break;
         case 1:
-            context.segment_function(segment);
+            context.segment_function(std::ref(segment));
             break;
         case 0:
-            context.segment_function(
-                segment.source, segment.target, segment.distance, segment.duration);
+            context.segment_function(std::ref(segment.source),
+                                     std::ref(segment.target),
+                                     segment.distance,
+                                     segment.duration);
             segment.weight = segment.duration; // back-compatibility fallback to duration
             break;
         }
@@ -1162,14 +1185,14 @@ void LuaScriptingContext::ProcessNode(const osmium::Node &node,
     {
     case 4:
     case 3:
-        node_function(profile_table, node, result, relations);
+        node_function(profile_table, std::cref(node), std::ref(result), std::cref(relations));
         break;
     case 2:
-        node_function(profile_table, node, result);
+        node_function(profile_table, std::cref(node), std::ref(result));
         break;
     case 1:
     case 0:
-        node_function(node, result);
+        node_function(std::cref(node), std::ref(result));
         break;
     }
 }
@@ -1184,14 +1207,14 @@ void LuaScriptingContext::ProcessWay(const osmium::Way &way,
     {
     case 4:
     case 3:
-        way_function(profile_table, way, result, relations);
+        way_function(profile_table, std::cref(way), std::ref(result), std::cref(relations));
         break;
     case 2:
-        way_function(profile_table, way, result);
+        way_function(profile_table, std::cref(way), std::ref(result));
         break;
     case 1:
     case 0:
-        way_function(way, result);
+        way_function(std::cref(way), std::ref(result));
         break;
     }
 }
diff --git a/src/extractor/way_restriction_map.cpp b/src/extractor/way_restriction_map.cpp
index 5ccb9292c..bc1c90e09 100644
--- a/src/extractor/way_restriction_map.cpp
+++ b/src/extractor/way_restriction_map.cpp
@@ -1,8 +1,5 @@
 #include "extractor/way_restriction_map.hpp"
-#include "util/for_each_pair.hpp"
 
-#include <functional>
-#include <iterator>
 #include <tuple>
 #include <utility>
 
@@ -11,247 +8,117 @@ namespace osrm
 namespace extractor
 {
 
-namespace
+WayRestrictionMap::WayRestrictionMap(const RestrictionGraph &restriction_graph)
+    : restriction_graph(restriction_graph)
 {
-struct FindViaWay
-{
-    bool operator()(const std::tuple<NodeID, NodeID> value,
-                    const TurnRestriction &restriction) const
-    {
-        const auto &way = restriction.AsWayRestriction();
-        return value < std::tie(way.in_restriction.via, way.out_restriction.via);
-    }
-    bool operator()(const TurnRestriction &restriction,
-                    const std::tuple<NodeID, NodeID> value) const
-    {
-        const auto &way = restriction.AsWayRestriction();
-        return std::tie(way.in_restriction.via, way.out_restriction.via) < value;
-    }
-};
-
-template <typename restriction_type> auto asDuplicatedNode(const restriction_type &restriction)
-{
-    auto &way = restriction.AsWayRestriction();
-    // group restrictions by the via-way. On same via-ways group by from
-    return std::tie(way.in_restriction.via, way.out_restriction.via, way.in_restriction.from);
-}
-
-template <typename restriction_type> struct CompareByDuplicatedNode
-{
-    bool operator()(const ConditionalTurnRestriction &lhs, const ConditionalTurnRestriction &rhs)
-    {
-        if (asDuplicatedNode(lhs) < asDuplicatedNode(rhs))
-        {
-            return true;
-        }
-        else if (asDuplicatedNode(rhs) < asDuplicatedNode(lhs))
-        {
-            return false;
-        }
-        else
-        {
-            const auto lhs_to = lhs.AsWayRestriction().out_restriction.to;
-            const auto rhs_to = rhs.AsWayRestriction().out_restriction.to;
-
-            const bool has_conditions_lhs = !lhs.condition.empty();
-            const bool has_conditions_rhs = !rhs.condition.empty();
-
-            return std::tie(lhs_to, lhs.is_only, has_conditions_lhs) <
-                   std::tie(rhs_to, rhs.is_only, has_conditions_rhs);
-        }
-    }
-};
-
-template <typename restriction_type>
-std::vector<restriction_type>
-extractRestrictions(const std::vector<restriction_type> &turn_restrictions)
-{
-    std::vector<restriction_type> result;
-    for (const auto &turn_restriction : turn_restrictions)
-    {
-        if (turn_restriction.Type() == RestrictionType::WAY_RESTRICTION)
-        {
-            const auto &way = turn_restriction.AsWayRestriction();
-
-            // so far we can only handle restrictions that are not interrupted
-            if (way.in_restriction.via == way.out_restriction.from &&
-                way.in_restriction.to == way.out_restriction.via)
-                result.push_back(turn_restriction);
-        }
-    }
-    std::sort(result.begin(), result.end(), CompareByDuplicatedNode<restriction_type>());
-    auto new_end = std::unique(result.begin(), result.end());
-    result.erase(new_end, result.end());
-    return result;
-}
-
-template <typename restriction_type> struct ByInFromAndVia
-{
-    std::pair<NodeID, NodeID> operator()(const restriction_type &restriction)
-    {
-        const auto &way = restriction.AsWayRestriction();
-        return std::make_pair(way.in_restriction.from, way.in_restriction.via);
-    }
-};
-
-} // namespace
-
-// get all way restrictions
-WayRestrictionMap::WayRestrictionMap(
-    const std::vector<ConditionalTurnRestriction> &turn_restrictions_)
-    : restriction_data(extractRestrictions(turn_restrictions_)),
-      restriction_starts(restriction_data, ByInFromAndVia<ConditionalTurnRestriction>())
-{
-    std::size_t offset = 1;
-    // the first group starts at 0
-    if (!restriction_data.empty())
-        duplicated_node_groups.push_back(0);
-
-    auto const add_offset_on_new_groups = [&](auto const &lhs, auto const &rhs) {
-        BOOST_ASSERT(rhs == restriction_data[offset]);
-        BOOST_ASSERT(lhs.Type() == RestrictionType::WAY_RESTRICTION);
-        BOOST_ASSERT(rhs.Type() == RestrictionType::WAY_RESTRICTION);
-        // add a new lower bound for rhs
-        if (asDuplicatedNode(lhs) != asDuplicatedNode(rhs))
-            duplicated_node_groups.push_back(offset);
-        ++offset;
-    };
-    util::for_each_pair(restriction_data.begin(), restriction_data.end(), add_offset_on_new_groups);
-    duplicated_node_groups.push_back(restriction_data.size());
 }
 
 std::size_t WayRestrictionMap::NumberOfDuplicatedNodes() const
 {
-    return duplicated_node_groups.size() - 1;
+    return restriction_graph.num_via_nodes;
 }
 
-bool WayRestrictionMap::IsViaWay(const NodeID from, const NodeID to) const
+bool WayRestrictionMap::IsViaWayEdge(const NodeID from, const NodeID to) const
 {
-    // safe-guards
-    if (restriction_data.empty())
-        return false;
-
-    const auto itr = std::lower_bound(
-        restriction_data.begin(), restriction_data.end(), std::make_tuple(from, to), FindViaWay());
-
-    // no fitting restriction
-    if (itr == restriction_data.end())
-        return false;
-
-    const auto &way = itr->AsWayRestriction();
-
-    return way.out_restriction.from == from && way.out_restriction.via == to;
-}
-
-DuplicatedNodeID WayRestrictionMap::AsDuplicatedNodeID(const RestrictionID restriction_id) const
-{
-    const auto upper_bound_restriction = std::upper_bound(
-        duplicated_node_groups.begin(), duplicated_node_groups.end(), restriction_id);
-    const auto distance_to_upper_bound =
-        std::distance(duplicated_node_groups.begin(), upper_bound_restriction);
-    return distance_to_upper_bound - 1;
+    return restriction_graph.via_edge_to_node.count({from, to}) > 0;
 }
 
 std::vector<DuplicatedNodeID> WayRestrictionMap::DuplicatedNodeIDs(const NodeID from,
                                                                    const NodeID to) const
 {
-    const auto duplicated_node_range_itr = std::equal_range(
-        restriction_data.begin(), restriction_data.end(), std::make_tuple(from, to), FindViaWay());
-
-    const auto as_restriction_id = [this](const auto itr) {
-        return std::distance(restriction_data.begin(), itr);
-    };
-
-    auto first = AsDuplicatedNodeID(as_restriction_id(duplicated_node_range_itr.first));
-    auto end = AsDuplicatedNodeID(as_restriction_id(duplicated_node_range_itr.second));
-
-    std::vector<DuplicatedNodeID> result(end - first);
-    std::iota(result.begin(), result.end(), first);
-
+    const auto restriction_ways = restriction_graph.via_edge_to_node.equal_range({from, to});
+    std::vector<DuplicatedNodeID> result;
+    std::transform(restriction_ways.first,
+                   restriction_ways.second,
+                   std::back_inserter(result),
+                   [](const auto &range_val) { return DuplicatedNodeID(range_val.second); });
     return result;
 }
 
 bool WayRestrictionMap::IsRestricted(DuplicatedNodeID duplicated_node, const NodeID to) const
 {
-    // loop over all restrictions associated with the node. Mark as restricted based on
-    // is_only/restricted targets
-    for (RestrictionID restriction_index = duplicated_node_groups[duplicated_node];
-         restriction_index != duplicated_node_groups[duplicated_node + 1];
-         ++restriction_index)
-    {
-        BOOST_ASSERT(restriction_index < restriction_data.size());
-        const auto &restriction = restriction_data[restriction_index];
-        const auto &way = restriction.AsWayRestriction();
-
-        if (restriction.is_only)
-            return way.out_restriction.to != to;
-        else if (to == way.out_restriction.to)
-            return true;
-    }
-    return false;
+    // Checks if a turn to 'to' is restricted
+    BOOST_ASSERT(duplicated_node < restriction_graph.num_via_nodes);
+    const auto &restrictions = restriction_graph.GetRestrictions(duplicated_node);
+    return std::any_of(restrictions.begin(), restrictions.end(), [&to](const auto &restriction) {
+        return restriction->IsTurnRestricted(to);
+    });
 }
 
-ConditionalTurnRestriction const &
-WayRestrictionMap::GetRestriction(DuplicatedNodeID duplicated_node, const NodeID to) const
+std::vector<const TurnRestriction *>
+WayRestrictionMap::GetRestrictions(DuplicatedNodeID duplicated_node, const NodeID to) const
 {
-    // loop over all restrictions associated with the node. Mark as restricted based on
-    // is_only/restricted targets
-    for (RestrictionID restriction_index = duplicated_node_groups[duplicated_node];
-         restriction_index != duplicated_node_groups[duplicated_node + 1];
-         ++restriction_index)
+    std::vector<const TurnRestriction *> result;
+    // Fetch all restrictions that will restrict a turn to 'to'.
+    BOOST_ASSERT(duplicated_node < restriction_graph.num_via_nodes);
+    const auto &restrictions = restriction_graph.GetRestrictions(duplicated_node);
+    std::copy_if(restrictions.begin(),
+                 restrictions.end(),
+                 std::back_inserter(result),
+                 [&to](const auto &restriction) { return restriction->IsTurnRestricted(to); });
+    if (result.empty())
     {
-        BOOST_ASSERT(restriction_index < restriction_data.size());
-        const auto &restriction = restriction_data[restriction_index];
-        const auto &way = restriction.AsWayRestriction();
-
-        if (restriction.is_only && (way.out_restriction.to != to))
-        {
-            return restriction;
-        }
-        else if (!restriction.is_only && (to == way.out_restriction.to))
-        {
-            return restriction;
-        }
+        throw(
+            "Asking for the restriction of an unrestricted turn. Check with `IsRestricted` before "
+            "calling GetRestriction");
     }
-    throw("Asking for the restriction of an unrestricted turn. Check with `IsRestricted` before "
-          "calling GetRestriction");
-}
-
-std::vector<WayRestrictionMap::ViaWay> WayRestrictionMap::DuplicatedNodeRepresentatives() const
-{
-    std::vector<ViaWay> result;
-    result.reserve(NumberOfDuplicatedNodes());
-    std::transform(duplicated_node_groups.begin(),
-                   duplicated_node_groups.end() - 1,
-                   std::back_inserter(result),
-                   [&](auto const representative_id) -> ViaWay {
-                       auto &way = restriction_data[representative_id].AsWayRestriction();
-                       return {way.in_restriction.via, way.out_restriction.via};
-                   });
     return result;
 }
 
-NodeID WayRestrictionMap::RemapIfRestricted(const NodeID edge_based_node,
-                                            const NodeID node_based_from,
-                                            const NodeID node_based_via,
-                                            const NodeID node_based_to,
-                                            const NodeID number_of_edge_based_nodes) const
+std::vector<WayRestrictionMap::ViaEdge> WayRestrictionMap::DuplicatedViaEdges() const
 {
-    auto range = restriction_starts.Restrictions(node_based_from, node_based_via);
+    std::vector<ViaEdge> result;
+    result.resize(NumberOfDuplicatedNodes());
 
-    // returns true if the ID saved in an iterator belongs to a turn restriction that references
-    // node_based_to as destination of the `in_restriction`
-    const auto restriction_targets_to = [node_based_to](const auto &pair) {
-        return pair.second->AsWayRestriction().in_restriction.to == node_based_to;
-    };
-    const auto itr = std::find_if(range.first, range.second, restriction_targets_to);
+    // We use the node id from the restriction graph to enumerate all
+    // duplicate nodes, and map them to their node based edge representation.
+    // This means an node based edge (from,to) can have many duplicate nodes.
+    for (auto entry : restriction_graph.via_edge_to_node)
+    {
+        result[entry.second] = {entry.first.first, entry.first.second};
+    }
+    return result;
+}
 
-    // in case we found a matching restriction, we can remap the edge_based_node
-    if (itr != range.second)
-        return number_of_edge_based_nodes - NumberOfDuplicatedNodes() +
-               AsDuplicatedNodeID(itr->second - &restriction_data[0]);
-    else
-        return edge_based_node;
+NodeID WayRestrictionMap::RemapIfRestrictionStart(const NodeID edge_based_node,
+                                                  const NodeID node_based_from,
+                                                  const NodeID node_based_via,
+                                                  const NodeID node_based_to,
+                                                  const NodeID number_of_edge_based_nodes) const
+{
+
+    auto restriction_it =
+        restriction_graph.start_edge_to_node.find({node_based_from, node_based_via});
+    if (restriction_it != restriction_graph.start_edge_to_node.end())
+    {
+        for (const auto &edge : restriction_graph.GetEdges(restriction_it->second))
+        {
+            if (edge.node_based_to == node_based_to)
+            {
+                return number_of_edge_based_nodes - NumberOfDuplicatedNodes() + edge.target;
+            }
+        }
+    }
+    return edge_based_node;
+}
+
+NodeID WayRestrictionMap::RemapIfRestrictionVia(const NodeID edge_based_target_node,
+                                                const NodeID edge_based_via_node,
+                                                const NodeID node_based_to,
+                                                const NodeID number_of_edge_based_nodes) const
+{
+
+    auto duplicated_node_id =
+        edge_based_via_node + NumberOfDuplicatedNodes() - number_of_edge_based_nodes;
+    BOOST_ASSERT(duplicated_node_id < restriction_graph.num_via_nodes);
+    for (const auto &edge : restriction_graph.GetEdges(duplicated_node_id))
+    {
+        if (edge.node_based_to == node_based_to)
+        {
+            return number_of_edge_based_nodes - NumberOfDuplicatedNodes() + edge.target;
+        }
+    }
+    return edge_based_target_node;
 }
 
 } // namespace extractor
diff --git a/src/guidance/driveway_handler.cpp b/src/guidance/driveway_handler.cpp
index 81984b474..4c7eee14a 100644
--- a/src/guidance/driveway_handler.cpp
+++ b/src/guidance/driveway_handler.cpp
@@ -2,9 +2,6 @@
 
 #include "util/assert.hpp"
 
-using osrm::guidance::getTurnDirection;
-using osrm::util::angularDeviation;
-
 namespace osrm
 {
 namespace guidance
@@ -58,8 +55,9 @@ bool DrivewayHandler::canProcess(const NodeID /*nid*/,
     return static_cast<std::size_t>(low_priority_count) + 2 == intersection.size();
 }
 
-Intersection DrivewayHandler::
-operator()(const NodeID nid, const EdgeID source_edge_id, Intersection intersection) const
+Intersection DrivewayHandler::operator()(const NodeID nid,
+                                         const EdgeID source_edge_id,
+                                         Intersection intersection) const
 {
     auto road =
         std::find_if(intersection.begin() + 1, intersection.end(), [this](const auto &road) {
diff --git a/src/guidance/guidance_processing.cpp b/src/guidance/guidance_processing.cpp
index 6e6aae8d4..0f3155046 100644
--- a/src/guidance/guidance_processing.cpp
+++ b/src/guidance/guidance_processing.cpp
@@ -118,7 +118,6 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
         //
         tbb::filter_t<tbb::blocked_range<NodeID>, TurnsPipelineBufferPtr> guidance_stage(
             tbb::filter::parallel, [&](const tbb::blocked_range<NodeID> &intersection_node_range) {
-
                 auto buffer = std::make_shared<TurnsPipelineBuffer>();
                 buffer->nodes_processed = intersection_node_range.size();
 
@@ -202,9 +201,9 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
                         // be fine.
                         bearing_class_by_node_based_node[intersection_node] = bearing_class_id;
 
-                        // check if we are turning off a via way
-                        const auto turning_off_via_way =
-                            way_restriction_map.IsViaWay(incoming_edge.node, intersection_node);
+                        // check if we on a restriction via edge
+                        const auto is_restriction_via_edge =
+                            way_restriction_map.IsViaWayEdge(incoming_edge.node, intersection_node);
 
                         for (const auto &outgoing_edge : outgoing_edges)
                         {
@@ -240,11 +239,11 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
                                 guidance::TurnBearing(intersection[0].perceived_bearing),
                                 guidance::TurnBearing(turn->perceived_bearing)});
 
-                            // when turning off a a via-way turn restriction, we need to not only
+                            // When on the edge of a via-way turn restriction, we need to not only
                             // handle the normal edges for the way, but also add turns for every
                             // duplicated node. This process is integrated here to avoid doing the
                             // turn analysis multiple times.
-                            if (turning_off_via_way)
+                            if (is_restriction_via_edge)
                             {
                                 const auto duplicated_nodes = way_restriction_map.DuplicatedNodeIDs(
                                     incoming_edge.node, intersection_node);
@@ -262,10 +261,18 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
 
                                     if (is_way_restricted)
                                     {
-                                        auto const restriction = way_restriction_map.GetRestriction(
-                                            duplicated_node_id, node_at_end_of_turn);
+                                        auto const restrictions =
+                                            way_restriction_map.GetRestrictions(
+                                                duplicated_node_id, node_at_end_of_turn);
 
-                                        if (restriction.condition.empty())
+                                        auto has_unconditional =
+                                            std::any_of(restrictions.begin(),
+                                                        restrictions.end(),
+                                                        [](const auto &restriction) {
+                                                            return restriction->IsUnconditional();
+                                                        });
+
+                                        if (has_unconditional)
                                             continue;
 
                                         buffer->delayed_turn_data.push_back(guidance::TurnData{
@@ -302,7 +309,6 @@ void annotateTurns(const util::NodeBasedDynamicGraph &node_based_graph,
 
         tbb::filter_t<TurnsPipelineBufferPtr, void> guidance_output_stage(
             tbb::filter::serial_in_order, [&](auto buffer) {
-
                 guidance_progress.PrintAddition(buffer->nodes_processed);
 
                 connectivity_checksum = buffer->checksum.update_checksum(connectivity_checksum);
diff --git a/src/guidance/intersection_handler.cpp b/src/guidance/intersection_handler.cpp
index 0dedc8f9a..c2142bacc 100644
--- a/src/guidance/intersection_handler.cpp
+++ b/src/guidance/intersection_handler.cpp
@@ -183,7 +183,7 @@ TurnInstruction IntersectionHandler::getInstructionForObvious(const std::size_t
                     // duration/weight of the traversal. We can only approximate the distance here
                     // or actually follow the full road. When 2399 lands, we can exchange here for a
                     // precalculated distance value.
-                    const auto distance = util::coordinate_calculation::haversineDistance(
+                    const auto distance = util::coordinate_calculation::greatCircleDistance(
                         node_coordinates[node_based_graph.GetTarget(via_edge)],
                         node_coordinates[node_based_graph.GetTarget(road.eid)]);
 
diff --git a/src/guidance/motorway_handler.cpp b/src/guidance/motorway_handler.cpp
index 116369d10..4094a0d6a 100644
--- a/src/guidance/motorway_handler.cpp
+++ b/src/guidance/motorway_handler.cpp
@@ -92,8 +92,8 @@ bool MotorwayHandler::canProcess(const NodeID,
     return has_motorway || from_motorway;
 }
 
-Intersection MotorwayHandler::
-operator()(const NodeID, const EdgeID via_eid, Intersection intersection) const
+Intersection
+MotorwayHandler::operator()(const NodeID, const EdgeID via_eid, Intersection intersection) const
 {
     // coming from motorway
     if (isMotorwayClass(via_eid, node_based_graph))
diff --git a/src/guidance/roundabout_handler.cpp b/src/guidance/roundabout_handler.cpp
index a375c2ff8..8e9f9f0b4 100644
--- a/src/guidance/roundabout_handler.cpp
+++ b/src/guidance/roundabout_handler.cpp
@@ -57,8 +57,9 @@ bool RoundaboutHandler::canProcess(const NodeID from_nid,
     return roundabout_type != RoundaboutType::None;
 }
 
-Intersection RoundaboutHandler::
-operator()(const NodeID from_nid, const EdgeID via_eid, Intersection intersection) const
+Intersection RoundaboutHandler::operator()(const NodeID from_nid,
+                                           const EdgeID via_eid,
+                                           Intersection intersection) const
 {
     const auto flags = getRoundaboutFlags(from_nid, via_eid, intersection);
     const auto roundabout_type = getRoundaboutType(node_based_graph.GetTarget(via_eid));
@@ -211,7 +212,9 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
     std::unordered_set<unsigned> connected_names;
 
     const auto getNextOnRoundabout = [this, &roundabout_name_ids, &connected_names](
-        const NodeID node, const bool roundabout, const bool circular) {
+                                         const NodeID node,
+                                         const bool roundabout,
+                                         const bool circular) {
         BOOST_ASSERT(roundabout != circular);
         EdgeID continue_edge = SPECIAL_EDGEID;
         for (const auto edge_id : node_based_graph.GetAdjacentEdgeRange(node))
@@ -271,7 +274,7 @@ RoundaboutType RoundaboutHandler::getRoundaboutType(const NodeID nid) const
         for (const auto &compressed_edge : edge_bucket)
         {
             const auto next_coord = node_coordinates[compressed_edge.node_id];
-            length += util::coordinate_calculation::haversineDistance(last_coord, next_coord);
+            length += util::coordinate_calculation::greatCircleDistance(last_coord, next_coord);
             last_coord = next_coord;
         }
         return length;
diff --git a/src/guidance/segregated_intersection_classification.cpp b/src/guidance/segregated_intersection_classification.cpp
index 496da4eeb..e0d60381c 100644
--- a/src/guidance/segregated_intersection_classification.cpp
+++ b/src/guidance/segregated_intersection_classification.cpp
@@ -56,7 +56,7 @@ std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFa
         double length = 0.0;
         for (size_t i = 1; i < geom.size(); ++i)
         {
-            length += util::coordinate_calculation::haversineDistance(geom[i - 1], geom[i]);
+            length += util::coordinate_calculation::greatCircleDistance(geom[i - 1], geom[i]);
         }
         return length;
     };
@@ -109,8 +109,8 @@ std::unordered_set<EdgeID> findSegregatedNodes(const extractor::NodeBasedGraphFa
     };
 
     auto isSegregated = [&](NodeID node1,
-                            std::vector<EdgeInfo> v1,
-                            std::vector<EdgeInfo> v2,
+                            const std::vector<EdgeInfo> &v1,
+                            const std::vector<EdgeInfo> &v2,
                             EdgeInfo const &current,
                             double edge_length) {
         // Internal intersection edges must be short and cannot be a roundabout.
diff --git a/src/guidance/sliproad_handler.cpp b/src/guidance/sliproad_handler.cpp
index 08f8febf2..569cb6405 100644
--- a/src/guidance/sliproad_handler.cpp
+++ b/src/guidance/sliproad_handler.cpp
@@ -67,8 +67,9 @@ bool SliproadHandler::canProcess(const NodeID /*nid*/,
 // ^ a nid
 //    ^ ab source_edge_id
 //       ^ b intersection
-Intersection SliproadHandler::
-operator()(const NodeID /*nid*/, const EdgeID source_edge_id, Intersection intersection) const
+Intersection SliproadHandler::operator()(const NodeID /*nid*/,
+                                         const EdgeID source_edge_id,
+                                         Intersection intersection) const
 {
     BOOST_ASSERT(intersection.size() > 2);
 
@@ -451,8 +452,8 @@ operator()(const NodeID /*nid*/, const EdgeID source_edge_id, Intersection inter
             // Only check for curvature and ~90 degree when it makes sense to do so.
             const constexpr auto MIN_LENGTH = 3.;
 
-            const auto length = haversineDistance(node_coordinates[intersection_node_id],
-                                                  node_coordinates[main_road_intersection->node]);
+            const auto length = greatCircleDistance(node_coordinates[intersection_node_id],
+                                                    node_coordinates[main_road_intersection->node]);
 
             const double minimal_crossroad_angle_of_intersection = 40.;
 
@@ -506,7 +507,6 @@ operator()(const NodeID /*nid*/, const EdgeID source_edge_id, Intersection inter
                                                              candidate_data.name_id,    //
                                                              name_table,                //
                                                              street_name_suffix_table); //
-
             };
 
             const auto candidate_road_name_mismatch = std::all_of(begin(target_road_name_ids), //
@@ -740,8 +740,8 @@ bool SliproadHandler::isValidSliproadArea(const double max_area,
     const auto second = node_coordinates[b];
     const auto third = node_coordinates[c];
 
-    const auto length = haversineDistance(first, second);
-    const auto heigth = haversineDistance(second, third);
+    const auto length = greatCircleDistance(first, second);
+    const auto heigth = greatCircleDistance(second, third);
 
     const auto area = (length * heigth) / 2.;
 
diff --git a/src/guidance/suppress_mode_handler.cpp b/src/guidance/suppress_mode_handler.cpp
index c50579f22..a7ff5062c 100644
--- a/src/guidance/suppress_mode_handler.cpp
+++ b/src/guidance/suppress_mode_handler.cpp
@@ -61,8 +61,8 @@ bool SuppressModeHandler::canProcess(const NodeID,
     return (suppress_in_mode != end(suppressed)) && all_share_mode;
 }
 
-Intersection SuppressModeHandler::
-operator()(const NodeID, const EdgeID, Intersection intersection) const
+Intersection
+SuppressModeHandler::operator()(const NodeID, const EdgeID, Intersection intersection) const
 {
     const auto first = begin(intersection);
     const auto last = end(intersection);
@@ -77,5 +77,5 @@ operator()(const NodeID, const EdgeID, Intersection intersection) const
 
     return intersection;
 }
-}
-}
+} // namespace guidance
+} // namespace osrm
diff --git a/src/guidance/turn_discovery.cpp b/src/guidance/turn_discovery.cpp
index cdfffd4b4..d5138ecf1 100644
--- a/src/guidance/turn_discovery.cpp
+++ b/src/guidance/turn_discovery.cpp
@@ -51,7 +51,7 @@ bool findPreviousIntersection(const NodeID node_v,
     const auto via_edge_length =
         util::coordinate_calculation::getLength(coordinates_along_via_edge.begin(),
                                                 coordinates_along_via_edge.end(),
-                                                &util::coordinate_calculation::haversineDistance);
+                                                &util::coordinate_calculation::greatCircleDistance);
 
     // we check if via-edge is too short. In this case the previous turn cannot influence the turn
     // at via_edge and the intersection at NODE_W
diff --git a/src/guidance/turn_handler.cpp b/src/guidance/turn_handler.cpp
index d7644bf7d..35ee3b139 100644
--- a/src/guidance/turn_handler.cpp
+++ b/src/guidance/turn_handler.cpp
@@ -68,7 +68,7 @@ InputIt findOutermostForkCandidate(const InputIt begin, const InputIt end)
         return outermost - 1;
     }
 }
-}
+} // namespace
 
 namespace osrm
 {
@@ -137,8 +137,8 @@ bool TurnHandler::canProcess(const NodeID, const EdgeID, const Intersection &) c
 // Handles and processes possible turns
 // Input parameters describe an intersection as described in
 // #IntersectionExplanation@intersection_handler.hpp
-Intersection TurnHandler::
-operator()(const NodeID, const EdgeID via_edge, Intersection intersection) const
+Intersection
+TurnHandler::operator()(const NodeID, const EdgeID via_edge, Intersection intersection) const
 {
     if (intersection.size() == 1)
         return handleOneWayTurn(std::move(intersection));
@@ -684,7 +684,7 @@ bool TurnHandler::isCompatibleByRoadClass(const Intersection &intersection, cons
 boost::optional<TurnHandler::Fork> TurnHandler::findFork(const EdgeID via_edge,
                                                          Intersection &intersection) const
 {
-    const auto fork = findForkCandidatesByGeometry(intersection);
+    auto fork = findForkCandidatesByGeometry(intersection);
     if (fork)
     {
         // makes sure that the fork is isolated from other neighbouring streets on the left and
diff --git a/src/guidance/turn_lane_augmentation.cpp b/src/guidance/turn_lane_augmentation.cpp
index 2690c7ddb..07a8f7aa9 100644
--- a/src/guidance/turn_lane_augmentation.cpp
+++ b/src/guidance/turn_lane_augmentation.cpp
@@ -227,9 +227,8 @@ LaneDataVector handleRenamingSituations(const std::size_t none_index,
                 lane_data[none_index].to = lane_data[none_index].from;
             }
         }
-        else if (has_through &&
-                 (lane_data.size() == 1 ||
-                  lane_data[none_index + 1].tag != extractor::TurnLaneType::straight))
+        else if (has_through && (lane_data.size() == 1 || lane_data[none_index + 1].tag !=
+                                                              extractor::TurnLaneType::straight))
         {
             lane_data[none_index].tag = extractor::TurnLaneType::straight;
         }
diff --git a/src/guidance/turn_lane_data.cpp b/src/guidance/turn_lane_data.cpp
index 409d2e613..76503c26e 100644
--- a/src/guidance/turn_lane_data.cpp
+++ b/src/guidance/turn_lane_data.cpp
@@ -64,7 +64,7 @@ bool TurnLaneData::operator<(const TurnLaneData &other) const
            std::find(tag_by_modifier, tag_by_modifier + 8, other.tag);
 }
 
-LaneDataVector laneDataFromDescription(TurnLaneDescription turn_lane_description)
+LaneDataVector laneDataFromDescription(const TurnLaneDescription &turn_lane_description)
 {
     typedef std::unordered_map<TurnLaneType::Mask, std::pair<LaneID, LaneID>> LaneMap;
     // TODO need to handle cases that have none-in between two identical values
diff --git a/src/guidance/turn_lane_handler.cpp b/src/guidance/turn_lane_handler.cpp
index 06a56217d..ea9ad848f 100644
--- a/src/guidance/turn_lane_handler.cpp
+++ b/src/guidance/turn_lane_handler.cpp
@@ -655,7 +655,6 @@ std::pair<LaneDataVector, LaneDataVector> TurnLaneHandler::partitionLaneData(
                 data.from = std::min(turn_lane_data[lane].from, data.from);
                 data.to = std::max(turn_lane_data[lane].to, data.to);
             }
-
     };
 
     LaneDataVector first, second;
diff --git a/src/guidance/turn_lane_matcher.cpp b/src/guidance/turn_lane_matcher.cpp
index 7f2d073fd..395c3d0f9 100644
--- a/src/guidance/turn_lane_matcher.cpp
+++ b/src/guidance/turn_lane_matcher.cpp
@@ -272,6 +272,6 @@ Intersection triviallyMatchLanesToTurns(Intersection intersection,
     return intersection;
 }
 
-} // namespace lane_matching
+} // namespace lanes
 } // namespace guidance
 } // namespace osrm
diff --git a/src/nodejs/CMakeLists.txt b/src/nodejs/CMakeLists.txt
index ff16a3856..fe2a1fff6 100644
--- a/src/nodejs/CMakeLists.txt
+++ b/src/nodejs/CMakeLists.txt
@@ -15,6 +15,9 @@ message(STATUS "Configuring node_osrm bindings for NodeJs ${NODEJS_VERSION}")
 
 add_nodejs_module(node_osrm node_osrm.cpp)
 set_target_properties(node_osrm PROPERTIES CXX_STANDARD 14)
+# TODO: we disable clang-tidy for this target, because it causes errors in third-party NodeJs related headers
+set_target_properties(node_osrm PROPERTIES CXX_CLANG_TIDY "")
+
 target_link_libraries(node_osrm osrm)
 
 # node_osrm artifacts in ${BINDING_DIR} to depend targets on
diff --git a/src/nodejs/node_osrm.cpp b/src/nodejs/node_osrm.cpp
index c5ca5c9c1..5c8c486a5 100644
--- a/src/nodejs/node_osrm.cpp
+++ b/src/nodejs/node_osrm.cpp
@@ -74,8 +74,12 @@ NAN_MODULE_INIT(Engine::Init)
  *        Make sure you prepared the dataset with the correct toolchain.
  * @param {Boolean} [options.shared_memory] Connects to the persistent shared memory datastore.
  *        This requires you to run `osrm-datastore` prior to creating an `OSRM` object.
+ * @param {String} [options.dataset_name] Connects to the persistent shared memory datastore defined by `--dataset_name` option when running `osrm-datastore`.
+ *        This requires you to run `osrm-datastore --dataset_name` prior to creating an `OSRM` object.
+ * @param {String} [options.memory_file] **DEPRECATED**
+ *        Old behaviour: Path to a file on disk to store the memory using mmap.  Current behaviour: setting this value is the same as setting `mmap_memory: true`.
+ * @param {Boolean} [options.mmap_memory] Map on-disk files to virtual memory addresses (mmap), rather than loading into RAM.
  * @param {String} [options.path] The path to the `.osrm` files. This is mutually exclusive with setting {options.shared_memory} to true.
- * @param {String} [options.memory_file] Path to a file to store the memory using mmap.
  * @param {Number} [options.max_locations_trip] Max. locations supported in trip query (default: unlimited).
  * @param {Number} [options.max_locations_viaroute] Max. locations supported in viaroute query (default: unlimited).
  * @param {Number} [options.max_locations_distance_table] Max. locations supported in distance table query (default: unlimited).
@@ -144,12 +148,13 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
                ServiceMemFn service,
                Nan::Callback *callback,
                PluginParameters pluginParams_)
-            : Base(callback), osrm{std::move(osrm_)}, service{std::move(service)},
+            : Base(callback, "osrm:async"), osrm{std::move(osrm_)}, service{std::move(service)},
               params{std::move(params_)}, pluginParams{std::move(pluginParams_)}
         {
         }
 
-        void Execute() override try
+        void Execute() override
+        try
         {
             osrm::engine::api::ResultT r;
             r = osrm::util::json::Object();
@@ -179,7 +184,7 @@ inline void async(const Nan::FunctionCallbackInfo<v8::Value> &info,
             const constexpr auto argc = 2u;
             v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(result)};
 
-            callback->Call(argc, argv);
+            callback->Call(argc, argv, async_resource);
         }
 
         // Keeps the OSRM object alive even after shutdown until we're done with callback
@@ -225,12 +230,14 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
                ServiceMemFn service,
                Nan::Callback *callback,
                PluginParameters pluginParams_)
-            : Base(callback), osrm{std::move(osrm_)}, service{std::move(service)},
-              params{std::move(params_)}, pluginParams{std::move(pluginParams_)}
+            : Base(callback, "osrm:asyncForTiles"), osrm{std::move(osrm_)},
+              service{std::move(service)}, params{std::move(params_)}, pluginParams{
+                                                                           std::move(pluginParams_)}
         {
         }
 
-        void Execute() override try
+        void Execute() override
+        try
         {
             result = std::string();
             const auto status = ((*osrm).*(service))(*params, result);
@@ -250,7 +257,7 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
             auto str_result = result.get<std::string>();
             v8::Local<v8::Value> argv[argc] = {Nan::Null(), render(str_result)};
 
-            callback->Call(argc, argv);
+            callback->Call(argc, argv, async_resource);
         }
 
         // Keeps the OSRM object alive even after shutdown until we're done with callback
@@ -279,6 +286,7 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.radiuses] Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
+ * @param {Boolean} [options.generate_hints=true]  Whether or not adds a Hint to the response which can be used in subsequent requests.
  * @param {Boolean} [options.alternatives=false] Search for alternative routes.
  * @param {Number} [options.alternatives=0] Search for up to this many alternative routes.
  * *Please note that even if alternative routes are requested, a result cannot be guaranteed.*
@@ -289,6 +297,8 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
  * @param {Boolean} [options.continue_straight] Forces the route to keep going straight at waypoints and don't do a uturn even if it would be faster. Default value depends on the profile.
  * @param {Array} [options.approaches] Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
  *                  `null`/`true`/`false`
+ * @param {Array} [options.waypoints] Indices to coordinates to treat as waypoints. If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
+ * @param {String} [options.snapping] Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
  * @param {Function} callback
  *
  * @returns {Object} An array of [Waypoint](#waypoint) objects representing all waypoints in order AND an array of [`Route`](#route) objects ordered by descending recommendation rank.
@@ -304,7 +314,10 @@ inline void asyncForTiles(const Nan::FunctionCallbackInfo<v8::Value> &info,
 // clang-format on
 NAN_METHOD(Engine::route) //
 {
-    async(info, &argumentsToRouteParameter, &osrm::OSRM::Route, true);
+    osrm::Status (osrm::OSRM::*route_fn)(const osrm::RouteParameters &params,
+                                         osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Route;
+    async(info, &argumentsToRouteParameter, route_fn, true);
 }
 
 // clang-format off
@@ -321,9 +334,11 @@ NAN_METHOD(Engine::route) //
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.radiuses] Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
+ * @param {Boolean} [options.generate_hints=true]  Whether or not adds a Hint to the response which can be used in subsequent requests.
  * @param {Number} [options.number=1] Number of nearest segments that should be returned.
  * Must be an integer greater than or equal to `1`.
  * @param {Array} [options.approaches] Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+ * @param {String} [options.snapping] Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
  * @param {Function} callback
  *
  * @returns {Object} containing `waypoints`.
@@ -344,13 +359,16 @@ NAN_METHOD(Engine::route) //
 // clang-format on
 NAN_METHOD(Engine::nearest) //
 {
-    async(info, &argumentsToNearestParameter, &osrm::OSRM::Nearest, false);
+    osrm::Status (osrm::OSRM::*nearest_fn)(const osrm::NearestParameters &params,
+                                           osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Nearest;
+    async(info, &argumentsToNearestParameter, nearest_fn, false);
 }
 
 // clang-format off
 /**
- * Computes duration and distance tables for the given locations. Allows for both symmetric and asymmetric
- * tables.
+ * Computes duration table for the given locations. Allows for both symmetric and asymmetric tables.
+ * Optionally returns distance table.
  *
  * @name table
  * @memberof OSRM
@@ -360,11 +378,16 @@ NAN_METHOD(Engine::nearest) //
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.radiuses] Limits the coordinate snapping to streets in the given radius in meters. Can be `null` (unlimited, default) or `double >= 0`.
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
+ * @param {Boolean} [options.generate_hints=true] Whether or not adds a Hint to the response which can be used in subsequent requests.
  * @param {Array} [options.sources] An array of `index` elements (`0 <= integer < #coordinates`) to use
  *                                  location with given index as source. Default is to use all.
  * @param {Array} [options.destinations] An array of `index` elements (`0 <= integer < #coordinates`) to use location with given index as destination. Default is to use all.
  * @param {Array} [options.approaches] Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
- * @param {Array} [options.annotations] An array of the table types to return. Values can be `duration` or `distance` or both. If no annotations parameter is added, the default is to return the `durations` table. If `annotations=distance` or `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
+ * @param {Number} [options.fallback_speed] Replace `null` responses in result with as-the-crow-flies estimates based on `fallback_speed`.  Value is in metres/second.
+ * @param {String} [options.fallback_coordinate] Either `input` (default) or `snapped`.  If using a `fallback_speed`, use either the user-supplied coordinate (`input`), or the snapped coordinate (`snapped`) for calculating the as-the-crow-flies distance between two points.
+ * @param {Number} [options.scale_factor] Multiply the table duration values in the table by this number for more controlled input into a route optimization solver.
+ * @param {String} [options.snapping] Which edges can be snapped to, either `default`, or `any`.  `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
+ * @param {Array} [options.annotations] Return the requested table or tables in response. Can be `['duration']` (return the duration matrix, default), `[distance']` (return the distance matrix), or `['duration', distance']` (return both the duration matrix and the distance matrix).
 
  * @param {Function} callback
  *
@@ -372,10 +395,10 @@ NAN_METHOD(Engine::nearest) //
  * **`durations`**: array of arrays that stores the matrix in row-major order. `durations[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
  *                  Values are given in seconds.
  * **`distances`**: array of arrays that stores the matrix in row-major order. `distances[i][j]` gives the travel time from the i-th waypoint to the j-th waypoint.
- *                  Values are given in meters. Note that computing the `distances` table is currently only implemented for CH. If `annotations=distance` or
- *                  `annotations=duration,distance` is requested when running a MLD router, a `NotImplemented` error will be returned.
+ *                  Values are given in meters.
  * **`sources`**: array of [`Ẁaypoint`](#waypoint) objects describing all sources in order.
  * **`destinations`**: array of [`Ẁaypoint`](#waypoint) objects describing all destinations in order.
+ * **`fallback_speed_cells`**: (optional) if `fallback_speed` is used, will be an array of arrays of `row,column` values, indicating which cells contain estimated values.
  *
  * @example
  * var osrm = new OSRM('network.osrm');
@@ -388,7 +411,7 @@ NAN_METHOD(Engine::nearest) //
  * };
  * osrm.table(options, function(err, response) {
  *   console.log(response.durations); // array of arrays, matrix in row-major order
- *   console.log(response.distances); // array of arrays, matrix in row-major order (currently only implemented for CH router)
+ *   console.log(response.distances); // array of arrays, matrix in row-major order
  *   console.log(response.sources); // array of Waypoint objects
  *   console.log(response.destinations); // array of Waypoint objects
  * });
@@ -396,7 +419,10 @@ NAN_METHOD(Engine::nearest) //
 // clang-format on
 NAN_METHOD(Engine::table) //
 {
-    async(info, &argumentsToTableParameter, &osrm::OSRM::Table, true);
+    osrm::Status (osrm::OSRM::*table_fn)(const osrm::TableParameters &params,
+                                         osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Table;
+    async(info, &argumentsToTableParameter, table_fn, true);
 }
 
 // clang-format off
@@ -427,7 +453,10 @@ NAN_METHOD(Engine::table) //
 // clang-format on
 NAN_METHOD(Engine::tile)
 {
-    asyncForTiles(info, &argumentsToTileParameters, &osrm::OSRM::Tile, {/*unused*/});
+    osrm::Status (osrm::OSRM::*tile_fn)(const osrm::TileParameters &params,
+                                        osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Tile;
+    asyncForTiles(info, &argumentsToTileParameters, tile_fn, {/*unused*/});
 }
 
 // clang-format off
@@ -445,23 +474,29 @@ NAN_METHOD(Engine::tile)
  * @param {Array} [options.bearings] Limits the search to segments with given bearing in degrees towards true north in clockwise direction.
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
+ * @param {Boolean} [options.generate_hints=true] Whether or not adds a Hint to the response which can be used in subsequent requests.
  * @param {Boolean} [options.steps=false] Return route steps for each route.
  * @param {Array|Boolean} [options.annotations=false] An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all.
  * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview and per step). Can also be `geojson`.
  * @param {String} [options.overview=simplified] Add overview geometry either `full`, `simplified` according to highest zoom level it could be display on, or not at all (`false`).
  * @param {Array<Number>} [options.timestamps] Timestamp of the input location (integers, UNIX-like timestamp).
  * @param {Array} [options.radiuses] Standard deviation of GPS precision used for map matching. If applicable use GPS accuracy. Can be `null` for default value `5` meters or `double >= 0`.
- * @param {String} [options.gaps] Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore` (optional, default `split`).
- * @param {Boolean} [options.tidy] Allows the input track modification to obtain better matching quality for noisy tracks (optional, default `false`).
+ * @param {String} [options.gaps=split] Allows the input track splitting based on huge timestamp gaps between points. Either `split` or `ignore`.
+ * @param {Boolean} [options.tidy=false] Allows the input track modification to obtain better matching quality for noisy tracks.
+ * @param {Array} [options.waypoints] Indices to coordinates to treat as waypoints.  If not supplied, all coordinates are waypoints.  Must include first and last coordinate index.
+ * @param {String} [options.snapping] Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
  *
  * @param {Function} callback
  *
  * @returns {Object} containing `tracepoints` and `matchings`.
  * **`tracepoints`** Array of [`Ẁaypoint`](#waypoint) objects representing all points of the trace in order.
  *                   If the trace point was ommited by map matching because it is an outlier, the entry will be null.
- *                   Each `Waypoint` object includes two additional properties, 1) `matchings_index`: Index to the
- *                   [`Route`](#route) object in matchings the sub-trace was matched to, 2) `waypoint_index`: Index of
+ *                   Each `Waypoint` object has the following additional properties,
+ *                   1) `matchings_index`: Index to the
+ *                   [`Route`](#route) object in matchings the sub-trace was matched to,
+ *                   2) `waypoint_index`: Index of
  *                   the waypoint inside the matched route.
+ *                   3) `alternatives_count`: Number of probable alternative matchings for this trace point. A value of zero indicate that this point was matched unambiguously. Split the trace at these points for incremental map matching.
  * **`matchings`** is an array of [`Route`](#route) objects that assemble the trace. Each `Route` object has an additional `confidence` property,
  *                 which is the confidence of the matching. float value between `0` and `1`. `1` is very confident that the matching is correct.
  *
@@ -481,7 +516,10 @@ NAN_METHOD(Engine::tile)
 // clang-format on
 NAN_METHOD(Engine::match) //
 {
-    async(info, &argumentsToMatchParameter, &osrm::OSRM::Match, true);
+    osrm::Status (osrm::OSRM::*match_fn)(const osrm::MatchParameters &params,
+                                         osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Match;
+    async(info, &argumentsToMatchParameter, match_fn, true);
 }
 
 // clang-format off
@@ -514,6 +552,7 @@ NAN_METHOD(Engine::match) //
  *                                   Can be `null` or an array of `[{value},{range}]` with `integer 0 .. 360,integer 0 .. 180`.
  * @param {Array} [options.radiuses] Limits the coordinate snapping to streets in the given radius in meters. Can be `double >= 0` or `null` (unlimited, default).
  * @param {Array} [options.hints] Hints for the coordinate snapping. Array of base64 encoded strings.
+ * @param {Boolean} [options.generate_hints=true] Whether or not adds a Hint to the response which can be used in subsequent requests.
  * @param {Boolean} [options.steps=false] Return route steps for each route.
  * @param {Array|Boolean} [options.annotations=false] An array with strings of `duration`, `nodes`, `distance`, `weight`, `datasources`, `speed` or boolean for enabling/disabling all.
  * @param {String} [options.geometries=polyline] Returned route geometry format (influences overview and per step). Can also be `geojson`.
@@ -523,6 +562,7 @@ NAN_METHOD(Engine::match) //
  * @param {String} [options.source=any] Return route starts at `any` or `first` coordinate.
  * @param {String} [options.destination=any] Return route ends at `any` or `last` coordinate.
  * @param {Array} [options.approaches] Keep waypoints on curb side. Can be `null` (unrestricted, default) or `curb`.
+ * @param {String} [options.snapping] Which edges can be snapped to, either `default`, or `any`. `default` only snaps to edges marked by the profile as `is_startpoint`, `any` will allow snapping to any edge in the routing graph.
  *
  * @returns {Object} containing `waypoints` and `trips`.
  * **`waypoints`**: an array of [`Waypoint`](#waypoint) objects representing all waypoints in input order.
@@ -551,11 +591,41 @@ NAN_METHOD(Engine::match) //
 // clang-format on
 NAN_METHOD(Engine::trip) //
 {
-    async(info, &argumentsToTripParameter, &osrm::OSRM::Trip, true);
+    osrm::Status (osrm::OSRM::*trip_fn)(const osrm::TripParameters &params,
+                                        osrm::engine::api::ResultT &result) const =
+        &osrm::OSRM::Trip;
+    async(info, &argumentsToTripParameter, trip_fn, true);
 }
 
 /**
- * Responses
+ * All plugins support a second additional object that is available to configure some NodeJS
+ * specific behaviours.
+ *
+ * @name Configuration
+ * @param {Object} [plugin_config] - Object literal containing parameters for the trip query.
+ * @param {String} [plugin_config.format] The format of the result object to various API calls.
+ *                                        Valid options are `object` (default), which returns a
+ * standard Javascript object, as described above, and `json_buffer`, which will return a NodeJS
+ * **[Buffer](https://nodejs.org/api/buffer.html)** object, containing a JSON string. The latter has
+ * the advantage that it can be immediately serialized to disk/sent over the network, and the
+ * generation of the string is performed outside the main NodeJS event loop.  This option is ignored
+ * by the `tile` plugin.
+ *
+ * @example
+ * var osrm = new OSRM('network.osrm');
+ * var options = {
+ *   coordinates: [
+ *     [13.36761474609375, 52.51663871100423],
+ *     [13.374481201171875, 52.506191342034576]
+ *   ]
+ * };
+ * osrm.route(options, { format: "json_buffer" }, function(err, response) {
+ *   if (err) throw err;
+ *   console.log(response.toString("utf-8"));
+ * });
+ */
+
+/**
  * @class Responses
  */
 
@@ -565,8 +635,8 @@ NAN_METHOD(Engine::trip) //
  * @name Route
  * @memberof Responses
  *
- * @param {documentation} exteral in
- * [`osrm-backend`](../http.md#route)
+ * @param {documentation} external in
+ * [`osrm-backend`](../http.md#route-object)
  *
  */
 
@@ -576,8 +646,8 @@ NAN_METHOD(Engine::trip) //
  * @name RouteLeg
  * @memberof Responses
  *
- * @param {documentation} exteral in
- * [`osrm-backend`](../http.md#routeleg)
+ * @param {documentation} external in
+ * [`osrm-backend`](../http.md#routeleg-object)
  *
  */
 
@@ -588,8 +658,8 @@ NAN_METHOD(Engine::trip) //
  * @name RouteStep
  * @memberof Responses
  *
- * @param {documentation} exteral in
- * [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#routestep)
+ * @param {documentation} external in
+ * [`osrm-backend`](../http.md#routestep-object)
  *
  */
 
@@ -598,8 +668,8 @@ NAN_METHOD(Engine::trip) //
  * @name StepManeuver
  * @memberof Responses
  *
- * @param {documentation} exteral in
- * [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#stepmaneuver)
+ * @param {documentation} external in
+ * [`osrm-backend`](../http.md#stepmaneuver-object)
  *
  */
 
@@ -609,8 +679,8 @@ NAN_METHOD(Engine::trip) //
  * @name Waypoint
  * @memberof Responses
  *
- * @param {documentation} exteral in
- * [`osrm-backend`](https://github.com/Project-OSRM/osrm-backend/blob/master/docs/http.md#waypoint)
+ * @param {documentation} external in
+ * [`osrm-backend`](../http.md#waypoint-object)
  *
  */
 
diff --git a/src/osrm/contractor.cpp b/src/osrm/contractor.cpp
index a91c542ab..8ef8c4260 100644
--- a/src/osrm/contractor.cpp
+++ b/src/osrm/contractor.cpp
@@ -9,4 +9,4 @@ namespace osrm
 
 void contract(const contractor::ContractorConfig &config) { contractor::Contractor(config).Run(); }
 
-} // ns osrm
+} // namespace osrm
diff --git a/src/osrm/customizer.cpp b/src/osrm/customizer.cpp
index 35563ecf4..194fc588e 100644
--- a/src/osrm/customizer.cpp
+++ b/src/osrm/customizer.cpp
@@ -9,4 +9,4 @@ namespace osrm
 
 void customize(const CustomizationConfig &config) { customizer::Customizer().Run(config); }
 
-} // ns osrm
+} // namespace osrm
diff --git a/src/osrm/extractor.cpp b/src/osrm/extractor.cpp
index c045c4727..dc71fb2fa 100644
--- a/src/osrm/extractor.cpp
+++ b/src/osrm/extractor.cpp
@@ -15,4 +15,4 @@ void extract(const extractor::ExtractorConfig &config)
     extractor::Extractor(config).run(scripting_environment);
 }
 
-} // ns osrm
+} // namespace osrm
diff --git a/src/osrm/osrm.cpp b/src/osrm/osrm.cpp
index 54a6799fa..83e1076f7 100644
--- a/src/osrm/osrm.cpp
+++ b/src/osrm/osrm.cpp
@@ -52,7 +52,7 @@ OSRM::OSRM(engine::EngineConfig &config)
         engine_ = std::make_unique<engine::Engine<MLD>>(config);
         break;
     default:
-        util::exception("Algorithm not implemented!");
+        throw util::exception("Algorithm not implemented!");
     }
 }
 OSRM::~OSRM() = default;
@@ -61,40 +61,83 @@ OSRM &OSRM::operator=(OSRM &&) noexcept = default;
 
 // Forward to implementation
 
-engine::Status OSRM::Route(const engine::api::RouteParameters &params,
-                           osrm::engine::api::ResultT &result) const
+Status OSRM::Route(const engine::api::RouteParameters &params, json::Object &json_result) const
+{
+    osrm::engine::api::ResultT result = json::Object();
+    auto status = engine_->Route(params, result);
+    json_result = std::move(result.get<json::Object>());
+    return status;
+}
+
+Status OSRM::Route(const RouteParameters &params, engine::api::ResultT &result) const
 {
     return engine_->Route(params, result);
 }
 
-engine::Status OSRM::Table(const engine::api::TableParameters &params,
-                           osrm::engine::api::ResultT &result) const
+Status OSRM::Table(const engine::api::TableParameters &params, json::Object &json_result) const
+{
+    osrm::engine::api::ResultT result = json::Object();
+    auto status = engine_->Table(params, result);
+    json_result = std::move(result.get<json::Object>());
+    return status;
+}
+
+Status OSRM::Table(const TableParameters &params, engine::api::ResultT &result) const
 {
     return engine_->Table(params, result);
 }
 
-engine::Status OSRM::Nearest(const engine::api::NearestParameters &params,
-                             osrm::engine::api::ResultT &result) const
+Status OSRM::Nearest(const engine::api::NearestParameters &params, json::Object &json_result) const
+{
+    osrm::engine::api::ResultT result = json::Object();
+    auto status = engine_->Nearest(params, result);
+    json_result = std::move(result.get<json::Object>());
+    return status;
+}
+
+Status OSRM::Nearest(const NearestParameters &params, engine::api::ResultT &result) const
 {
     return engine_->Nearest(params, result);
 }
 
+Status OSRM::Trip(const engine::api::TripParameters &params, json::Object &json_result) const
+{
+    osrm::engine::api::ResultT result = json::Object();
+    auto status = engine_->Trip(params, result);
+    json_result = std::move(result.get<json::Object>());
+    return status;
+}
+
 engine::Status OSRM::Trip(const engine::api::TripParameters &params,
-                          osrm::engine::api::ResultT &result) const
+                          engine::api::ResultT &result) const
 {
     return engine_->Trip(params, result);
 }
 
-engine::Status OSRM::Match(const engine::api::MatchParameters &params,
-                           osrm::engine::api::ResultT &result) const
+Status OSRM::Match(const engine::api::MatchParameters &params, json::Object &json_result) const
+{
+    osrm::engine::api::ResultT result = json::Object();
+    auto status = engine_->Match(params, result);
+    json_result = std::move(result.get<json::Object>());
+    return status;
+}
+
+Status OSRM::Match(const MatchParameters &params, engine::api::ResultT &result) const
 {
     return engine_->Match(params, result);
 }
 
-engine::Status OSRM::Tile(const engine::api::TileParameters &params,
-                          osrm::engine::api::ResultT &result) const
+Status OSRM::Tile(const engine::api::TileParameters &params, std::string &str_result) const
+{
+    osrm::engine::api::ResultT result = std::string();
+    auto status = engine_->Tile(params, result);
+    str_result = std::move(result.get<std::string>());
+    return status;
+}
+
+Status OSRM::Tile(const engine::api::TileParameters &params, engine::api::ResultT &result) const
 {
     return engine_->Tile(params, result);
 }
 
-} // ns osrm
+} // namespace osrm
diff --git a/src/osrm/partitioner.cpp b/src/osrm/partitioner.cpp
index 981902ccd..ce3456b87 100644
--- a/src/osrm/partitioner.cpp
+++ b/src/osrm/partitioner.cpp
@@ -9,4 +9,4 @@ namespace osrm
 
 void partition(const PartitionerConfig &config) { partitioner::Partitioner().Run(config); }
 
-} // ns osrm
+} // namespace osrm
diff --git a/src/partitioner/bisection_to_partition.cpp b/src/partitioner/bisection_to_partition.cpp
index 650c0ab87..fe73b6ddd 100644
--- a/src/partitioner/bisection_to_partition.cpp
+++ b/src/partitioner/bisection_to_partition.cpp
@@ -109,7 +109,7 @@ void partitionLevel(const std::vector<BisectionID> &node_to_bisection_id,
         }
     }
 }
-}
+} // namespace
 
 // Implements a greedy algorithm that split cells using the bisection until a target cell size is
 // reached
@@ -140,5 +140,5 @@ bisectionToPartition(const std::vector<BisectionID> &node_to_bisection_id,
 
     return std::make_tuple(std::move(partitions), std::move(num_cells));
 }
-}
-}
+} // namespace partitioner
+} // namespace osrm
diff --git a/src/partitioner/dinic_max_flow.cpp b/src/partitioner/dinic_max_flow.cpp
index 502cf99db..a5def6a67 100644
--- a/src/partitioner/dinic_max_flow.cpp
+++ b/src/partitioner/dinic_max_flow.cpp
@@ -88,7 +88,7 @@ DinicMaxFlow::MinCut DinicMaxFlow::operator()(const BisectionGraphView &view,
             // heuristic)
             for (auto s : source_nodes)
                 levels[s] = 0;
-            const auto cut = MakeCut(view, levels, flow_value);
+            auto cut = MakeCut(view, levels, flow_value);
             return cut;
         }
     } while (true);
@@ -183,7 +183,6 @@ std::size_t DinicMaxFlow::BlockingFlow(FlowEdges &flow,
 
     // augment the flow along a path in the level graph
     const auto augment_flow = [&flow](const std::vector<NodeID> &path) {
-
         // add/remove flow edges from the current residual graph
         const auto augment_one = [&flow](const NodeID from, const NodeID to) {
             // check if there is flow in the opposite direction
diff --git a/src/partitioner/inertial_flow.cpp b/src/partitioner/inertial_flow.cpp
index 833a1d98a..59a4aceb4 100644
--- a/src/partitioner/inertial_flow.cpp
+++ b/src/partitioner/inertial_flow.cpp
@@ -149,7 +149,7 @@ DinicMaxFlow::MinCut bestMinCut(const BisectionGraphView &view,
 
     return best;
 }
-}
+} // namespace
 
 DinicMaxFlow::MinCut computeInertialFlowCut(const BisectionGraphView &view,
                                             const std::size_t num_slopes,
diff --git a/src/partitioner/partitioner.cpp b/src/partitioner/partitioner.cpp
index 29f6395a3..f01ea966c 100644
--- a/src/partitioner/partitioner.cpp
+++ b/src/partitioner/partitioner.cpp
@@ -118,6 +118,10 @@ int Partitioner::Run(const PartitionerConfig &config)
             edge_based_partition_ids[backward_node] = node_based_partition_ids[v];
     }
 
+    BOOST_ASSERT(std::none_of(edge_based_partition_ids.begin(),
+                              edge_based_partition_ids.end(),
+                              [](auto x) { return x == SPECIAL_NODEID; }));
+
     std::vector<Partition> partitions;
     std::vector<std::uint32_t> level_to_num_cells;
     std::tie(partitions, level_to_num_cells) =
diff --git a/src/partitioner/renumber.cpp b/src/partitioner/renumber.cpp
index 619bf2c59..9f3bee9d0 100644
--- a/src/partitioner/renumber.cpp
+++ b/src/partitioner/renumber.cpp
@@ -36,7 +36,7 @@ std::vector<LevelID> getHighestBorderLevel(const DynamicEdgeBasedGraph &graph,
 
     return border_level;
 }
-}
+} // namespace
 
 std::vector<std::uint32_t> makePermutation(const DynamicEdgeBasedGraph &graph,
                                            const std::vector<Partition> &partitions)
@@ -66,5 +66,5 @@ std::vector<std::uint32_t> makePermutation(const DynamicEdgeBasedGraph &graph,
 
     return util::orderingToPermutation(ordering);
 }
-}
-}
+} // namespace partitioner
+} // namespace osrm
diff --git a/src/server/api/parameters_parser.cpp b/src/server/api/parameters_parser.cpp
index db935fb5b..bfc4c2c20 100644
--- a/src/server/api/parameters_parser.cpp
+++ b/src/server/api/parameters_parser.cpp
@@ -62,7 +62,7 @@ boost::optional<ParameterT> parseParameters(std::string::iterator &iter,
 
     return boost::none;
 }
-} // ns detail
+} // namespace detail
 
 template <>
 boost::optional<engine::api::RouteParameters> parseParameters(std::string::iterator &iter,
@@ -110,6 +110,6 @@ boost::optional<engine::api::TileParameters> parseParameters(std::string::iterat
     return detail::parseParameters<engine::api::TileParameters, TileParametersGrammar<>>(iter, end);
 }
 
-} // ns api
-} // ns server
-} // ns osrm
+} // namespace api
+} // namespace server
+} // namespace osrm
diff --git a/src/server/api/url_parser.cpp b/src/server/api/url_parser.cpp
index ebd82341f..1a10f66c3 100644
--- a/src/server/api/url_parser.cpp
+++ b/src/server/api/url_parser.cpp
@@ -26,15 +26,15 @@ struct URLParser final : qi::grammar<Iterator, Into>
     {
         using boost::spirit::repository::qi::iter_pos;
 
-        alpha_numeral = qi::char_("a-zA-Z0-9");
+        identifier = qi::char_("a-zA-Z0-9_.~:-");
         percent_encoding =
             qi::char_('%') > qi::uint_parser<unsigned char, 16, 2, 2>()[qi::_val = qi::_1];
-        polyline_chars = qi::char_("a-zA-Z0-9_.--[]{}@?|\\~`^") | percent_encoding;
-        all_chars = polyline_chars | qi::char_("=,;:&().");
+        polyline_chars = qi::char_("a-zA-Z0-9_[]{}@?|\\~`^") | percent_encoding;
+        all_chars = polyline_chars | qi::char_("=,;:&().-");
 
-        service = +alpha_numeral;
+        service = +identifier;
         version = qi::uint_;
-        profile = +alpha_numeral;
+        profile = +identifier;
         query = +all_chars;
 
         // Example input: /route/v1/driving/7.416351,43.731205;7.420363,43.736189
@@ -54,13 +54,13 @@ struct URLParser final : qi::grammar<Iterator, Into>
     qi::rule<Iterator, std::string()> profile;
     qi::rule<Iterator, std::string()> query;
 
-    qi::rule<Iterator, char()> alpha_numeral;
+    qi::rule<Iterator, char()> identifier;
     qi::rule<Iterator, char()> all_chars;
     qi::rule<Iterator, char()> polyline_chars;
     qi::rule<Iterator, char()> percent_encoding;
 };
 
-} // anon.
+} // namespace
 
 namespace osrm
 {
@@ -93,6 +93,6 @@ boost::optional<ParsedURL> parseURL(std::string::iterator &iter, const std::stri
     return boost::none;
 }
 
-} // api
-} // server
-} // osrm
+} // namespace api
+} // namespace server
+} // namespace osrm
diff --git a/src/server/connection.cpp b/src/server/connection.cpp
index c6d29d269..6ba5ed242 100644
--- a/src/server/connection.cpp
+++ b/src/server/connection.cpp
@@ -1,15 +1,10 @@
 #include "server/connection.hpp"
 #include "server/request_handler.hpp"
-#include "server/request_parser.hpp"
 
 #include <boost/algorithm/string/predicate.hpp>
-#include <boost/assert.hpp>
 #include <boost/bind.hpp>
 #include <boost/iostreams/filter/gzip.hpp>
 #include <boost/iostreams/filtering_stream.hpp>
-
-#include <iterator>
-#include <string>
 #include <vector>
 
 namespace osrm
@@ -17,22 +12,42 @@ namespace osrm
 namespace server
 {
 
-Connection::Connection(boost::asio::io_service &io_service, RequestHandler &handler)
-    : strand(io_service), TCP_socket(io_service), timer(io_service), request_handler(handler)
+Connection::Connection(boost::asio::io_context &io_context, RequestHandler &handler)
+    : strand(boost::asio::make_strand(io_context)), TCP_socket(strand), timer(strand),
+      request_handler(handler), http_request_parser(std::make_optional<RequestParser>())
 {
 }
 
 boost::asio::ip::tcp::socket &Connection::socket() { return TCP_socket; }
 
+namespace
+{
+
+http::compression_type select_compression(const boost::beast::http::fields &fields)
+{
+    const auto header_value = fields[boost::beast::http::field::accept_encoding];
+    /* giving gzip precedence over deflate */
+    if (boost::icontains(header_value, "deflate"))
+    {
+        return http::deflate_rfc1951;
+    }
+    if (boost::icontains(header_value, "gzip"))
+    {
+        return http::gzip_rfc1952;
+    }
+    return http::no_compression;
+}
+
+} // namespace
+
 /// Start the first asynchronous operation for the connection.
 void Connection::start()
 {
-    TCP_socket.async_read_some(
-        boost::asio::buffer(incoming_data_buffer),
-        strand.wrap(boost::bind(&Connection::handle_read,
-                                this->shared_from_this(),
-                                boost::asio::placeholders::error,
-                                boost::asio::placeholders::bytes_transferred)));
+    TCP_socket.async_read_some(boost::asio::buffer(incoming_data_buffer),
+                               boost::bind(&Connection::handle_read,
+                                           this->shared_from_this(),
+                                           boost::asio::placeholders::error,
+                                           boost::asio::placeholders::bytes_transferred));
 
     if (keep_alive)
     {
@@ -48,6 +63,12 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
 {
     if (error)
     {
+        if (error != boost::asio::error::operation_aborted)
+        {
+            // Error not triggered by timer expiry, commence connection shutdown.
+            util::Log(logDEBUG) << "Connection read error: " << error.message();
+            handle_shutdown();
+        }
         return;
     }
 
@@ -57,22 +78,48 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
         timer.expires_from_now(boost::posix_time::seconds(0));
     }
 
+    boost::beast::error_code ec;
+    http_request_parser->put(boost::asio::buffer(incoming_data_buffer, bytes_transferred), ec);
     // no error detected, let's parse the request
     http::compression_type compression_type(http::no_compression);
-    RequestParser::RequestStatus result;
-    std::tie(result, compression_type) =
-        request_parser.parse(current_request,
-                             incoming_data_buffer.data(),
-                             incoming_data_buffer.data() + bytes_transferred);
 
-    // the request has been parsed
-    if (result == RequestParser::RequestStatus::valid)
+    if (ec)
     {
+        if (ec == boost::beast::http::error::need_more)
+        {
+            // we don't have a result yet, so continue reading
+            TCP_socket.async_read_some(boost::asio::buffer(incoming_data_buffer),
+                                       boost::bind(&Connection::handle_read,
+                                                   this->shared_from_this(),
+                                                   boost::asio::placeholders::error,
+                                                   boost::asio::placeholders::bytes_transferred));
+        }
+        else
+        {
+            // request is not parseable
+            current_reply = http::reply::stock_reply(http::reply::bad_request);
+
+            boost::asio::async_write(TCP_socket,
+                                     current_reply.to_buffers(),
+                                     boost::bind(&Connection::handle_write,
+                                                 this->shared_from_this(),
+                                                 boost::asio::placeholders::error));
+        }
+    }
+    else
+    {
+        // the request has been parsed
+        const auto &message = http_request_parser->get();
+        compression_type = select_compression(message);
+
+        fill_request(message, current_request);
 
         boost::system::error_code ec;
         current_request.endpoint = TCP_socket.remote_endpoint(ec).address();
+
         if (ec)
         {
+            util::Log(logDEBUG) << "Socket remote endpoint error: " << ec.message();
             handle_shutdown();
             return;
         }
@@ -119,29 +166,9 @@ void Connection::handle_read(const boost::system::error_code &error, std::size_t
         // write result to stream
         boost::asio::async_write(TCP_socket,
                                  output_buffer,
-                                 strand.wrap(boost::bind(&Connection::handle_write,
-                                                         this->shared_from_this(),
-                                                         boost::asio::placeholders::error)));
-    }
-    else if (result == RequestParser::RequestStatus::invalid)
-    { // request is not parseable
-        current_reply = http::reply::stock_reply(http::reply::bad_request);
-
-        boost::asio::async_write(TCP_socket,
-                                 current_reply.to_buffers(),
-                                 strand.wrap(boost::bind(&Connection::handle_write,
-                                                         this->shared_from_this(),
-                                                         boost::asio::placeholders::error)));
-    }
-    else
-    {
-        // we don't have a result yet, so continue reading
-        TCP_socket.async_read_some(
-            boost::asio::buffer(incoming_data_buffer),
-            strand.wrap(boost::bind(&Connection::handle_read,
-                                    this->shared_from_this(),
-                                    boost::asio::placeholders::error,
-                                    boost::asio::placeholders::bytes_transferred)));
+                                 boost::bind(&Connection::handle_write,
+                                             this->shared_from_this(),
+                                             boost::asio::placeholders::error));
     }
 }
 
@@ -155,7 +182,7 @@ void Connection::handle_write(const boost::system::error_code &error)
             --processed_requests;
             current_request = http::request();
             current_reply = http::reply();
-            request_parser = RequestParser();
+            http_request_parser.emplace();
             incoming_data_buffer = boost::array<char, 8192>();
             output_buffer.clear();
             this->start();
@@ -165,6 +192,10 @@ void Connection::handle_write(const boost::system::error_code &error)
             handle_shutdown();
         }
     }
+    else
+    {
+        util::Log(logDEBUG) << "Connection write error: " << error.message();
+    }
 }
 
 /// Handle completion of a timeout timer..
@@ -183,6 +214,8 @@ void Connection::handle_timeout(boost::system::error_code ec)
 
 void Connection::handle_shutdown()
 {
+    // Cancel timer to ensure all resources are released immediately on shutdown.
+    timer.cancel();
     // Initiate graceful connection closure.
     boost::system::error_code ignore_error;
     TCP_socket.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignore_error);
@@ -211,5 +244,15 @@ std::vector<char> Connection::compress_buffers(const std::vector<char> &uncompre
 
     return compressed_data;
 }
+
+void Connection::fill_request(const RequestParser::value_type &http_message,
+                              http::request &current_request)
+{
+    current_request.uri = http_message.target().to_string();
+    current_request.agent = http_message[boost::beast::http::field::user_agent].to_string();
+    current_request.referrer = http_message[boost::beast::http::field::referer].to_string();
+    current_request.connection = http_message[boost::beast::http::field::connection].to_string();
 }
-}
+
+} // namespace server
+} // namespace osrm
diff --git a/src/server/http/reply.cpp b/src/server/http/reply.cpp
index b73e381a7..284d0c8fa 100644
--- a/src/server/http/reply.cpp
+++ b/src/server/http/reply.cpp
@@ -104,6 +104,6 @@ boost::asio::const_buffer reply::status_to_buffer(const reply::status_type statu
 }
 
 reply::reply() : status(ok) {}
-}
-}
-}
+} // namespace http
+} // namespace server
+} // namespace osrm
diff --git a/src/server/request_handler.cpp b/src/server/request_handler.cpp
index 3e7135bdf..f03ac3ac5 100644
--- a/src/server/request_handler.cpp
+++ b/src/server/request_handler.cpp
@@ -177,5 +177,5 @@ void RequestHandler::HandleRequest(const http::request &current_request, http::r
                               << ", uri: " << current_request.uri;
     }
 }
-}
-}
+} // namespace server
+} // namespace osrm
diff --git a/src/server/request_parser.cpp b/src/server/request_parser.cpp
deleted file mode 100644
index e39c0e40b..000000000
--- a/src/server/request_parser.cpp
+++ /dev/null
@@ -1,302 +0,0 @@
-#include "server/request_parser.hpp"
-
-#include "server/http/compression_type.hpp"
-#include "server/http/header.hpp"
-#include "server/http/request.hpp"
-
-#include <boost/algorithm/string/predicate.hpp>
-
-#include <string>
-
-namespace osrm
-{
-namespace server
-{
-
-RequestParser::RequestParser()
-    : state(internal_state::method_start), current_header({"", ""}),
-      selected_compression(http::no_compression)
-{
-}
-
-std::tuple<RequestParser::RequestStatus, http::compression_type>
-RequestParser::parse(http::request &current_request, char *begin, char *end)
-{
-    while (begin != end)
-    {
-        RequestStatus result = consume(current_request, *begin++);
-        if (result != RequestStatus::indeterminate)
-        {
-            return std::make_tuple(result, selected_compression);
-        }
-    }
-    RequestStatus result = RequestStatus::indeterminate;
-
-    return std::make_tuple(result, selected_compression);
-}
-
-RequestParser::RequestStatus RequestParser::consume(http::request &current_request,
-                                                    const char input)
-{
-    switch (state)
-    {
-    case internal_state::method_start:
-        if (!is_char(input) || is_CTL(input) || is_special(input))
-        {
-            return RequestStatus::invalid;
-        }
-        state = internal_state::method;
-        return RequestStatus::indeterminate;
-    case internal_state::method:
-        if (input == ' ')
-        {
-            state = internal_state::uri;
-            return RequestStatus::indeterminate;
-        }
-        if (!is_char(input) || is_CTL(input) || is_special(input))
-        {
-            return RequestStatus::invalid;
-        }
-        return RequestStatus::indeterminate;
-    case internal_state::uri_start:
-        if (is_CTL(input))
-        {
-            return RequestStatus::invalid;
-        }
-        state = internal_state::uri;
-        current_request.uri.push_back(input);
-        return RequestStatus::indeterminate;
-    case internal_state::uri:
-        if (input == ' ')
-        {
-            state = internal_state::http_version_h;
-            return RequestStatus::indeterminate;
-        }
-        if (is_CTL(input))
-        {
-            return RequestStatus::invalid;
-        }
-        current_request.uri.push_back(input);
-        return RequestStatus::indeterminate;
-    case internal_state::http_version_h:
-        if (input == 'H')
-        {
-            state = internal_state::http_version_t_1;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_t_1:
-        if (input == 'T')
-        {
-            state = internal_state::http_version_t_2;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_t_2:
-        if (input == 'T')
-        {
-            state = internal_state::http_version_p;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_p:
-        if (input == 'P')
-        {
-            state = internal_state::http_version_slash;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_slash:
-        if (input == '/')
-        {
-            state = internal_state::http_version_major_start;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_major_start:
-        if (is_digit(input))
-        {
-            state = internal_state::http_version_major;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_major:
-        if (input == '.')
-        {
-            state = internal_state::http_version_minor_start;
-            return RequestStatus::indeterminate;
-        }
-        if (is_digit(input))
-        {
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_minor_start:
-        if (is_digit(input))
-        {
-            state = internal_state::http_version_minor;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::http_version_minor:
-        if (input == '\r')
-        {
-            state = internal_state::expecting_newline_1;
-            return RequestStatus::indeterminate;
-        }
-        if (is_digit(input))
-        {
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::expecting_newline_1:
-        if (input == '\n')
-        {
-            state = internal_state::header_line_start;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    case internal_state::header_line_start:
-        if (boost::iequals(current_header.name, "Accept-Encoding"))
-        {
-            /* giving gzip precedence over deflate */
-            if (boost::icontains(current_header.value, "deflate"))
-            {
-                selected_compression = http::deflate_rfc1951;
-            }
-            if (boost::icontains(current_header.value, "gzip"))
-            {
-                selected_compression = http::gzip_rfc1952;
-            }
-        }
-
-        if (boost::iequals(current_header.name, "Referer"))
-        {
-            current_request.referrer = current_header.value;
-        }
-
-        if (boost::iequals(current_header.name, "User-Agent"))
-        {
-            current_request.agent = current_header.value;
-        }
-
-        if (boost::iequals(current_header.name, "Connection"))
-        {
-            current_request.connection = current_header.value;
-        }
-
-        if (input == '\r')
-        {
-            state = internal_state::expecting_newline_3;
-            return RequestStatus::indeterminate;
-        }
-        if (!is_char(input) || is_CTL(input) || is_special(input))
-        {
-            return RequestStatus::invalid;
-        }
-        state = internal_state::header_name;
-        current_header.clear();
-        current_header.name.push_back(input);
-        return RequestStatus::indeterminate;
-    case internal_state::header_lws:
-        if (input == '\r')
-        {
-            state = internal_state::expecting_newline_2;
-            return RequestStatus::indeterminate;
-        }
-        if (input == ' ' || input == '\t')
-        {
-            return RequestStatus::indeterminate;
-        }
-        if (is_CTL(input))
-        {
-            return RequestStatus::invalid;
-        }
-        state = internal_state::header_value;
-        return RequestStatus::indeterminate;
-    case internal_state::header_name:
-        if (input == ':')
-        {
-            state = internal_state::header_value;
-            return RequestStatus::indeterminate;
-        }
-        if (!is_char(input) || is_CTL(input) || is_special(input))
-        {
-            return RequestStatus::invalid;
-        }
-        current_header.name.push_back(input);
-        return RequestStatus::indeterminate;
-    case internal_state::header_value:
-        if (input == ' ')
-        {
-            state = internal_state::header_value;
-            return RequestStatus::indeterminate;
-        }
-        if (input == '\r')
-        {
-            state = internal_state::expecting_newline_2;
-            return RequestStatus::indeterminate;
-        }
-        if (is_CTL(input))
-        {
-            return RequestStatus::invalid;
-        }
-        current_header.value.push_back(input);
-        return RequestStatus::indeterminate;
-    case internal_state::expecting_newline_2:
-        if (input == '\n')
-        {
-            state = internal_state::header_line_start;
-            return RequestStatus::indeterminate;
-        }
-        return RequestStatus::invalid;
-    default: // expecting_newline_3
-        return input == '\n' ? RequestStatus::valid : RequestStatus::invalid;
-    }
-}
-
-bool RequestParser::is_char(const int character) const
-{
-    return character >= 0 && character <= 127;
-}
-
-bool RequestParser::is_CTL(const int character) const
-{
-    return (character >= 0 && character <= 31) || (character == 127);
-}
-
-bool RequestParser::is_special(const int character) const
-{
-    switch (character)
-    {
-    case '(':
-    case ')':
-    case '<':
-    case '>':
-    case '@':
-    case ',':
-    case ';':
-    case ':':
-    case '\\':
-    case '"':
-    case '/':
-    case '[':
-    case ']':
-    case '?':
-    case '=':
-    case '{':
-    case '}':
-    case ' ':
-    case '\t':
-        return true;
-    default:
-        return false;
-    }
-}
-
-bool RequestParser::is_digit(const int character) const
-{
-    return character >= '0' && character <= '9';
-}
-}
-}
diff --git a/src/server/service/match_service.cpp b/src/server/service/match_service.cpp
index aca391bf4..c6132724a 100644
--- a/src/server/service/match_service.cpp
+++ b/src/server/service/match_service.cpp
@@ -39,7 +39,7 @@ std::string getWrongOptionHelp(const engine::api::MatchParameters &parameters)
 
     return help;
 }
-} // anon. ns
+} // namespace
 
 engine::Status MatchService::RunQuery(std::size_t prefix_length,
                                       std::string &query,
@@ -78,6 +78,6 @@ engine::Status MatchService::RunQuery(std::size_t prefix_length,
     }
     return BaseService::routing_machine.Match(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service/nearest_service.cpp b/src/server/service/nearest_service.cpp
index ca9811719..1b316acd3 100644
--- a/src/server/service/nearest_service.cpp
+++ b/src/server/service/nearest_service.cpp
@@ -33,7 +33,7 @@ std::string getWrongOptionHelp(const engine::api::NearestParameters &parameters)
 
     return help;
 }
-} // anon. ns
+} // namespace
 
 engine::Status NearestService::RunQuery(std::size_t prefix_length,
                                         std::string &query,
@@ -72,6 +72,6 @@ engine::Status NearestService::RunQuery(std::size_t prefix_length,
     }
     return BaseService::routing_machine.Nearest(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service/route_service.cpp b/src/server/service/route_service.cpp
index 9459e7bbf..013fb4cf6 100644
--- a/src/server/service/route_service.cpp
+++ b/src/server/service/route_service.cpp
@@ -37,7 +37,7 @@ std::string getWrongOptionHelp(const engine::api::RouteParameters &parameters)
 
     return help;
 }
-} // anon. ns
+} // namespace
 
 engine::Status RouteService::RunQuery(std::size_t prefix_length,
                                       std::string &query,
@@ -76,6 +76,6 @@ engine::Status RouteService::RunQuery(std::size_t prefix_length,
     }
     return BaseService::routing_machine.Route(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service/table_service.cpp b/src/server/service/table_service.cpp
index b2c1f6548..5166be0b9 100644
--- a/src/server/service/table_service.cpp
+++ b/src/server/service/table_service.cpp
@@ -68,7 +68,7 @@ std::string getWrongOptionHelp(const engine::api::TableParameters &parameters)
 
     return help;
 }
-} // anon. ns
+} // namespace
 
 engine::Status TableService::RunQuery(std::size_t prefix_length,
                                       std::string &query,
@@ -107,6 +107,6 @@ engine::Status TableService::RunQuery(std::size_t prefix_length,
     }
     return BaseService::routing_machine.Table(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service/tile_service.cpp b/src/server/service/tile_service.cpp
index bdf7996d7..f518eac9f 100644
--- a/src/server/service/tile_service.cpp
+++ b/src/server/service/tile_service.cpp
@@ -47,6 +47,6 @@ engine::Status TileService::RunQuery(std::size_t prefix_length,
     result = std::string();
     return BaseService::routing_machine.Tile(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service/trip_service.cpp b/src/server/service/trip_service.cpp
index 20af63c12..33f325e3b 100644
--- a/src/server/service/trip_service.cpp
+++ b/src/server/service/trip_service.cpp
@@ -39,7 +39,7 @@ std::string getWrongOptionHelp(const engine::api::TripParameters &parameters)
 
     return help;
 }
-} // anon. ns
+} // namespace
 
 engine::Status TripService::RunQuery(std::size_t prefix_length,
                                      std::string &query,
@@ -80,6 +80,6 @@ engine::Status TripService::RunQuery(std::size_t prefix_length,
     }
     return BaseService::routing_machine.Trip(*parameters, result);
 }
-}
-}
-}
+} // namespace service
+} // namespace server
+} // namespace osrm
diff --git a/src/server/service_handler.cpp b/src/server/service_handler.cpp
index 81fc3f719..1dfe817bf 100644
--- a/src/server/service_handler.cpp
+++ b/src/server/service_handler.cpp
@@ -51,5 +51,5 @@ engine::Status ServiceHandler::RunQuery(api::ParsedURL parsed_url,
 
     return service->RunQuery(parsed_url.prefix_length, parsed_url.query, result);
 }
-}
-}
+} // namespace server
+} // namespace osrm
diff --git a/src/storage/storage.cpp b/src/storage/storage.cpp
index e3d5ede2b..9494285ab 100644
--- a/src/storage/storage.cpp
+++ b/src/storage/storage.cpp
@@ -165,7 +165,7 @@ bool swapData(Monitor &monitor,
 
     return true;
 }
-}
+} // namespace
 
 void populateLayoutFromFile(const boost::filesystem::path &path, storage::BaseDataLayout &layout)
 {
@@ -489,15 +489,6 @@ void Storage::PopulateStaticData(const SharedDataIndex &index)
         partitioner::files::readCells(config.GetPath(".osrm.cells"), storage);
     }
 
-    if (boost::filesystem::exists(config.GetPath(".osrm.cell_metrics")))
-    {
-        auto exclude_metrics = make_cell_metric_view(index, "/mld/metrics/" + metric_name);
-        std::unordered_map<std::string, std::vector<customizer::CellMetricView>> metrics = {
-            {metric_name, std::move(exclude_metrics)},
-        };
-        customizer::files::readCellMetrics(config.GetPath(".osrm.cell_metrics"), metrics);
-    }
-
     // load maneuver overrides
     {
         auto views = make_maneuver_overrides_views(index, "/common/maneuver_overrides");
@@ -596,5 +587,5 @@ void Storage::PopulateUpdatableData(const SharedDataIndex &index)
         }
     }
 }
-}
-}
+} // namespace storage
+} // namespace osrm
diff --git a/src/tools/components.cpp b/src/tools/components.cpp
index 056edb460..dcd051518 100644
--- a/src/tools/components.cpp
+++ b/src/tools/components.cpp
@@ -107,8 +107,8 @@ struct FeatureWriter
 };
 
 //
-}
-}
+} // namespace tools
+} // namespace osrm
 
 int main(int argc, char *argv[])
 {
diff --git a/src/tools/contract.cpp b/src/tools/contract.cpp
index 37b62c245..289ec671b 100644
--- a/src/tools/contract.cpp
+++ b/src/tools/contract.cpp
@@ -142,7 +142,8 @@ return_code parseArguments(int argc,
     return return_code::ok;
 }
 
-int main(int argc, char *argv[]) try
+int main(int argc, char *argv[])
+try
 {
     util::LogPolicy::GetInstance().Unmute();
     std::string verbosity;
diff --git a/src/tools/customize.cpp b/src/tools/customize.cpp
index da8e8ed68..3a63eb3b3 100644
--- a/src/tools/customize.cpp
+++ b/src/tools/customize.cpp
@@ -131,7 +131,8 @@ return_code parseArguments(int argc,
     return return_code::ok;
 }
 
-int main(int argc, char *argv[]) try
+int main(int argc, char *argv[])
+try
 {
     util::LogPolicy::GetInstance().Unmute();
     std::string verbosity;
diff --git a/src/tools/extract.cpp b/src/tools/extract.cpp
index ba725e0c1..0cd1c7b4f 100644
--- a/src/tools/extract.cpp
+++ b/src/tools/extract.cpp
@@ -141,7 +141,8 @@ return_code parseArguments(int argc,
     return return_code::ok;
 }
 
-int main(int argc, char *argv[]) try
+int main(int argc, char *argv[])
+try
 {
     util::LogPolicy::GetInstance().Unmute();
     extractor::ExtractorConfig extractor_config;
diff --git a/src/tools/io-benchmark.cpp b/src/tools/io-benchmark.cpp
index 598f23d20..7e4742fe9 100644
--- a/src/tools/io-benchmark.cpp
+++ b/src/tools/io-benchmark.cpp
@@ -45,8 +45,8 @@ void runStatistics(std::vector<double> &timings_vector, Statistics &stats)
         timings_vector.begin(), timings_vector.end(), timings_vector.begin(), 0.0);
     stats.dev = std::sqrt(primary_sq_sum / timings_vector.size() - (stats.mean * stats.mean));
 }
-}
-}
+} // namespace tools
+} // namespace osrm
 
 boost::filesystem::path test_path;
 
diff --git a/src/tools/partition.cpp b/src/tools/partition.cpp
index 6c34bac10..bbc8f10ad 100644
--- a/src/tools/partition.cpp
+++ b/src/tools/partition.cpp
@@ -185,7 +185,8 @@ return_code parseArguments(int argc,
     return return_code::ok;
 }
 
-int main(int argc, char *argv[]) try
+int main(int argc, char *argv[])
+try
 {
     util::LogPolicy::GetInstance().Unmute();
     std::string verbosity;
diff --git a/src/tools/routed.cpp b/src/tools/routed.cpp
index 718e3e4d0..7aec139a7 100644
--- a/src/tools/routed.cpp
+++ b/src/tools/routed.cpp
@@ -220,7 +220,8 @@ inline unsigned generateServerProgramOptions(const int argc,
     return INIT_OK_DO_NOT_START_ENGINE;
 }
 
-int main(int argc, const char *argv[]) try
+int main(int argc, const char *argv[])
+try
 {
     util::LogPolicy::GetInstance().Unmute();
 
diff --git a/src/tools/store.cpp b/src/tools/store.cpp
index 533f0d010..1504d9ed2 100644
--- a/src/tools/store.cpp
+++ b/src/tools/store.cpp
@@ -221,7 +221,8 @@ bool generateDataStoreOptions(const int argc,
     std::_Exit(128 + signum);
 }
 
-int main(const int argc, const char *argv[]) try
+int main(const int argc, const char *argv[])
+try
 {
     int signals[] = {SIGTERM, SIGSEGV, SIGINT, SIGILL, SIGABRT, SIGFPE};
     for (auto sig : signals)
diff --git a/src/updater/csv_source.cpp b/src/updater/csv_source.cpp
index 3b1e5f258..a242a0c66 100644
--- a/src/updater/csv_source.cpp
+++ b/src/updater/csv_source.cpp
@@ -62,6 +62,6 @@ TurnLookupTable readTurnValues(const std::vector<std::string> &paths)
                                                qi::double_ >> -(',' >> qi::double_));
     return parser(paths);
 }
-}
-}
-}
+} // namespace csv
+} // namespace updater
+} // namespace osrm
diff --git a/src/updater/updater.cpp b/src/updater/updater.cpp
index f4dc902a3..9301c804b 100644
--- a/src/updater/updater.cpp
+++ b/src/updater/updater.cpp
@@ -4,15 +4,12 @@
 #include "extractor/compressed_edge_container.hpp"
 #include "extractor/edge_based_graph_factory.hpp"
 #include "extractor/files.hpp"
-#include "extractor/node_based_edge.hpp"
 #include "extractor/packed_osm_ids.hpp"
 #include "extractor/restriction.hpp"
 #include "extractor/serialization.hpp"
 
 #include "guidance/files.hpp"
 
-#include "storage/io.hpp"
-
 #include "util/exception.hpp"
 #include "util/exception_utils.hpp"
 #include "util/for_each_pair.hpp"
@@ -20,7 +17,6 @@
 #include "util/log.hpp"
 #include "util/mmap_tar.hpp"
 #include "util/opening_hours.hpp"
-#include "util/static_graph.hpp"
 #include "util/static_rtree.hpp"
 #include "util/string_util.hpp"
 #include "util/timezones.hpp"
@@ -29,10 +25,6 @@
 
 #include <boost/assert.hpp>
 #include <boost/filesystem/fstream.hpp>
-#include <boost/geometry.hpp>
-#include <boost/geometry/index/rtree.hpp>
-#include <boost/interprocess/file_mapping.hpp>
-#include <boost/interprocess/mapped_region.hpp>
 
 #include <tbb/blocked_range.h>
 #include <tbb/concurrent_vector.h>
@@ -45,10 +37,8 @@
 #include <atomic>
 #include <bitset>
 #include <cstdint>
-#include <fstream>
 #include <iterator>
 #include <memory>
-#include <thread>
 #include <tuple>
 #include <vector>
 
@@ -69,7 +59,7 @@ template <typename T1, typename T2> struct hash<std::tuple<T1, T2>>
         return hash_val(std::get<0>(t), std::get<1>(t));
     }
 };
-}
+} // namespace std
 
 namespace osrm
 {
@@ -80,6 +70,7 @@ namespace
 
 template <typename T> inline bool is_aligned(const void *pointer)
 {
+    // NOLINTNEXTLINE(misc-redundant-expression)
     static_assert(sizeof(T) % alignof(T) == 0, "pointer can not be used as an array pointer");
     return reinterpret_cast<uintptr_t>(pointer) % alignof(T) == 0;
 }
@@ -122,6 +113,7 @@ void checkWeightsConsistency(
         if (geometry_id.forward)
         {
             auto range = segment_data.GetForwardWeights(geometry_id.id);
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             EdgeWeight weight = std::accumulate(range.begin(), range.end(), EdgeWeight{0});
             if (weight > edge.data.weight)
             {
@@ -132,6 +124,7 @@ void checkWeightsConsistency(
         else
         {
             auto range = segment_data.GetReverseWeights(geometry_id.id);
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             EdgeWeight weight = std::accumulate(range.begin(), range.end(), EdgeWeight{0});
             if (weight > edge.data.weight)
             {
@@ -151,7 +144,7 @@ updateSegmentData(const UpdaterConfig &config,
                   const SegmentLookupTable &segment_speed_lookup,
                   extractor::SegmentDataContainer &segment_data,
                   std::vector<util::Coordinate> &coordinates,
-                  extractor::PackedOSMIDs &osm_node_ids)
+                  const extractor::PackedOSMIDs &osm_node_ids)
 {
     // vector to count used speeds for logging
     // size offset by one since index 0 is used for speeds not from external file
@@ -162,9 +155,10 @@ updateSegmentData(const UpdaterConfig &config,
 
     // closure to convert SpeedSource value to weight and count fallbacks to durations
     std::atomic<std::uint32_t> fallbacks_to_duration{0};
-    auto convertToWeight = [&profile_properties, &fallbacks_to_duration](
-        const SegmentWeight &existing_weight, const SpeedSource &value, double distance_in_meters) {
-
+    auto convertToWeight = [&profile_properties,
+                            &fallbacks_to_duration](const SegmentWeight &existing_weight,
+                                                    const SpeedSource &value,
+                                                    double distance_in_meters) {
         double rate = std::numeric_limits<double>::quiet_NaN();
 
         // if value.rate is not set, we fall back to duration
@@ -428,10 +422,14 @@ updateTurnPenalties(const UpdaterConfig &config,
                     const TurnLookupTable &turn_penalty_lookup,
                     std::vector<TurnPenalty> &turn_weight_penalties,
                     std::vector<TurnPenalty> &turn_duration_penalties,
-                    extractor::PackedOSMIDs osm_node_ids)
+                    const extractor::PackedOSMIDs &osm_node_ids)
 {
     const auto weight_multiplier = profile_properties.GetWeightMultiplier();
 
+    // [NOTE] turn_index_blocks could be simply loaded by `files::readTurnPenaltiesIndex()`,
+    //      however, we leave the below mmap to keep compatiblity.
+    //      Use `files::readTurnPenaltiesIndex()` instead once the compatiblity is not that
+    //      important.
     // Mapped file pointer for turn indices
     boost::iostreams::mapped_file_source turn_index_region;
     const extractor::lookup::TurnIndexBlock *turn_index_blocks;
@@ -507,7 +505,7 @@ bool IsRestrictionValid(const Timezoner &tz_handler, const extractor::Conditiona
 std::vector<std::uint64_t>
 updateConditionalTurns(std::vector<TurnPenalty> &turn_weight_penalties,
                        const std::vector<extractor::ConditionalTurnPenalty> &conditional_turns,
-                       Timezoner time_zone_handler)
+                       const Timezoner &time_zone_handler)
 {
     std::vector<std::uint64_t> updated_turns;
     if (conditional_turns.size() == 0)
@@ -523,7 +521,7 @@ updateConditionalTurns(std::vector<TurnPenalty> &turn_weight_penalties,
     }
     return updated_turns;
 }
-}
+} // namespace
 
 EdgeID
 Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &edge_based_edge_list,
@@ -694,6 +692,7 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
                 new_weight += weight;
             }
             const auto durations = segment_data.GetForwardDurations(geometry_id.id);
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             new_duration = std::accumulate(durations.begin(), durations.end(), EdgeWeight{0});
         }
         else
@@ -709,6 +708,7 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
                 new_weight += weight;
             }
             const auto durations = segment_data.GetReverseDurations(geometry_id.id);
+            // NOLINTNEXTLINE(bugprone-fold-init-type)
             new_duration = std::accumulate(durations.begin(), durations.end(), EdgeWeight{0});
         }
         return std::make_tuple(new_weight, new_duration);
@@ -770,9 +770,9 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
             {
                 if (turn_weight_penalty < 0)
                 {
-                    util::Log(logWARNING) << "turn penalty " << turn_weight_penalty
-                                          << " is too negative: clamping turn weight to "
-                                          << weight_min_value;
+                    util::Log(logWARNING)
+                        << "turn penalty " << turn_weight_penalty
+                        << " is too negative: clamping turn weight to " << weight_min_value;
                     turn_weight_penalty = weight_min_value - new_weight;
                     turn_weight_penalties[edge.data.turn_id] = turn_weight_penalty;
                 }
@@ -826,5 +826,5 @@ Updater::LoadAndUpdateEdgeExpandedGraph(std::vector<extractor::EdgeBasedEdge> &e
     util::Log() << "Done reading edges in " << TIMER_MSEC(load_edges) << "ms.";
     return number_of_edge_based_nodes;
 }
-}
-}
+} // namespace updater
+} // namespace osrm
diff --git a/src/util/assert.cpp b/src/util/assert.cpp
index 0e8ab79c5..f8a9cc2e6 100644
--- a/src/util/assert.cpp
+++ b/src/util/assert.cpp
@@ -18,7 +18,7 @@ namespace
 
     std::terminate();
 }
-}
+} // namespace
 
 // Boost.Assert only declares the following two functions and let's us define them here.
 namespace boost
@@ -32,4 +32,4 @@ void assertion_failed_msg(
 {
     ::assertion_failed_msg_helper(expr, msg, function, file, line);
 }
-}
+} // namespace boost
diff --git a/src/util/conditional_restrictions.cpp b/src/util/conditional_restrictions.cpp
index ed37873c8..b748f1162 100644
--- a/src/util/conditional_restrictions.cpp
+++ b/src/util/conditional_restrictions.cpp
@@ -16,8 +16,8 @@ inline std::ostream &operator<<(std::ostream &stream, const ConditionalRestricti
     return stream << restriction.value << "=" << restriction.condition;
 }
 #endif
-}
-}
+} // namespace util
+} // namespace osrm
 
 BOOST_FUSION_ADAPT_STRUCT(osrm::util::ConditionalRestriction,
                           (std::string, value)(std::string, condition))
@@ -31,9 +31,8 @@ namespace detail
 
 namespace
 {
-namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator, typename Skipper = qi::blank_type>
 struct conditional_restrictions_grammar
@@ -76,7 +75,7 @@ struct conditional_restrictions_grammar
     qi::rule<Iterator, Skipper, ConditionalRestriction()> restriction;
     qi::rule<Iterator, Skipper, std::string()> value, condition;
 };
-}
+} // namespace detail
 
 std::vector<ConditionalRestriction> ParseConditionalRestrictions(const std::string &str)
 {
@@ -92,5 +91,5 @@ std::vector<ConditionalRestriction> ParseConditionalRestrictions(const std::stri
     return result;
 }
 
-} // util
-} // osrm
+} // namespace util
+} // namespace osrm
diff --git a/src/util/coordinate.cpp b/src/util/coordinate.cpp
index 3d6fd030a..e9082399c 100644
--- a/src/util/coordinate.cpp
+++ b/src/util/coordinate.cpp
@@ -42,5 +42,5 @@ bool operator==(const FloatCoordinate lhs, const FloatCoordinate rhs)
 
 bool operator!=(const Coordinate lhs, const Coordinate rhs) { return !(lhs == rhs); }
 bool operator!=(const FloatCoordinate lhs, const FloatCoordinate rhs) { return !(lhs == rhs); }
-}
-}
+} // namespace util
+} // namespace osrm
diff --git a/src/util/coordinate_calculation.cpp b/src/util/coordinate_calculation.cpp
index 10e64c6cb..bdc4d1206 100644
--- a/src/util/coordinate_calculation.cpp
+++ b/src/util/coordinate_calculation.cpp
@@ -72,12 +72,10 @@ std::uint64_t squaredEuclideanDistance(const Coordinate lhs, const Coordinate rh
     return result;
 }
 
-// Uses method described here:
-// https://www.gpo.gov/fdsys/pkg/CFR-2005-title47-vol4/pdf/CFR-2005-title47-vol4-sec73-208.pdf
-// should be within 0.1% or so of Vincenty method (assuming 19 buckets are enough)
-// Should be more faster and more precise than Haversine
-double fccApproximateDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
+double greatCircleDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
 {
+    // Should be within 0.1% or so of Vincenty method (assuming 19 buckets are enough)
+    // Should be more faster and more precise than Haversine
     const auto lon1 = static_cast<double>(util::toFloating(coordinate_1.lon));
     const auto lat1 = static_cast<double>(util::toFloating(coordinate_1.lat));
     const auto lon2 = static_cast<double>(util::toFloating(coordinate_2.lon));
@@ -86,56 +84,6 @@ double fccApproximateDistance(const Coordinate coordinate_1, const Coordinate co
         .distance({lon1, lat1}, {lon2, lat2});
 }
 
-double haversineDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
-{
-    auto lon1 = static_cast<int>(coordinate_1.lon);
-    auto lat1 = static_cast<int>(coordinate_1.lat);
-    auto lon2 = static_cast<int>(coordinate_2.lon);
-    auto lat2 = static_cast<int>(coordinate_2.lat);
-    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
-    const double lt1 = lat1 / COORDINATE_PRECISION;
-    const double ln1 = lon1 / COORDINATE_PRECISION;
-    const double lt2 = lat2 / COORDINATE_PRECISION;
-    const double ln2 = lon2 / COORDINATE_PRECISION;
-
-    const double dlat1 = lt1 * detail::DEGREE_TO_RAD;
-    const double dlong1 = ln1 * detail::DEGREE_TO_RAD;
-    const double dlat2 = lt2 * detail::DEGREE_TO_RAD;
-    const double dlong2 = ln2 * detail::DEGREE_TO_RAD;
-
-    const double dlong = dlong1 - dlong2;
-    const double dlat = dlat1 - dlat2;
-
-    const double aharv = std::pow(std::sin(dlat / 2.0), 2.0) +
-                         std::cos(dlat1) * std::cos(dlat2) * std::pow(std::sin(dlong / 2.), 2);
-    const double charv = 2. * std::atan2(std::sqrt(aharv), std::sqrt(1.0 - aharv));
-    return detail::EARTH_RADIUS * charv;
-}
-
-double greatCircleDistance(const Coordinate coordinate_1, const Coordinate coordinate_2)
-{
-    auto lon1 = static_cast<int>(coordinate_1.lon);
-    auto lat1 = static_cast<int>(coordinate_1.lat);
-    auto lon2 = static_cast<int>(coordinate_2.lon);
-    auto lat2 = static_cast<int>(coordinate_2.lat);
-    BOOST_ASSERT(lat1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon1 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lat2 != std::numeric_limits<int>::min());
-    BOOST_ASSERT(lon2 != std::numeric_limits<int>::min());
-
-    const double float_lat1 = (lat1 / COORDINATE_PRECISION) * detail::DEGREE_TO_RAD;
-    const double float_lon1 = (lon1 / COORDINATE_PRECISION) * detail::DEGREE_TO_RAD;
-    const double float_lat2 = (lat2 / COORDINATE_PRECISION) * detail::DEGREE_TO_RAD;
-    const double float_lon2 = (lon2 / COORDINATE_PRECISION) * detail::DEGREE_TO_RAD;
-
-    const double x_value = (float_lon2 - float_lon1) * std::cos((float_lat1 + float_lat2) / 2.0);
-    const double y_value = float_lat2 - float_lat1;
-    return std::hypot(x_value, y_value) * detail::EARTH_RADIUS;
-}
-
 double perpendicularDistance(const Coordinate segment_source,
                              const Coordinate segment_target,
                              const Coordinate query_location,
@@ -153,7 +101,7 @@ double perpendicularDistance(const Coordinate segment_source,
                               web_mercator::fromWGS84(query_location));
     nearest_location = web_mercator::toWGS84(projected_nearest);
 
-    const double approximate_distance = fccApproximateDistance(query_location, nearest_location);
+    const double approximate_distance = greatCircleDistance(query_location, nearest_location);
     BOOST_ASSERT(0.0 <= approximate_distance);
     return approximate_distance;
 }
@@ -179,30 +127,24 @@ Coordinate centroid(const Coordinate lhs, const Coordinate rhs)
     return centroid;
 }
 
-double bearing(const Coordinate first_coordinate, const Coordinate second_coordinate)
+double bearing(const Coordinate coordinate_1, const Coordinate coordinate_2)
 {
-    const double lon_diff =
-        static_cast<double>(toFloating(second_coordinate.lon - first_coordinate.lon));
-    const double lon_delta = detail::degToRad(lon_diff);
-    const double lat1 = detail::degToRad(static_cast<double>(toFloating(first_coordinate.lat)));
-    const double lat2 = detail::degToRad(static_cast<double>(toFloating(second_coordinate.lat)));
-    const double y = std::sin(lon_delta) * std::cos(lat2);
-    const double x =
-        std::cos(lat1) * std::sin(lat2) - std::sin(lat1) * std::cos(lat2) * std::cos(lon_delta);
-    double result = detail::radToDeg(std::atan2(y, x));
-    while (result < 0.0)
+    const auto lon1 = static_cast<double>(util::toFloating(coordinate_1.lon));
+    const auto lat1 = static_cast<double>(util::toFloating(coordinate_1.lat));
+    const auto lon2 = static_cast<double>(util::toFloating(coordinate_2.lon));
+    const auto lat2 = static_cast<double>(util::toFloating(coordinate_2.lat));
+    const auto &ruler = cheap_ruler_container.getRuler(coordinate_1.lat, coordinate_2.lat);
+    auto result = ruler.bearing({lon1, lat1}, {lon2, lat2});
+    if (result < 0.0)
     {
         result += 360.0;
     }
+    BOOST_ASSERT(0 <= result && result <= 360);
 
-    while (result >= 360.0)
-    {
-        result -= 360.0;
-    }
     // If someone gives us two identical coordinates, then the concept of a bearing
     // makes no sense.  However, because it sometimes happens, we'll at least
     // return a consistent value of 0 so that the behaviour isn't random.
-    BOOST_ASSERT(first_coordinate != second_coordinate || result == 0.);
+    BOOST_ASSERT(coordinate_1 != coordinate_2 || result == 0.);
 
     return result;
 }
@@ -322,7 +264,7 @@ double circleRadius(const Coordinate C1, const Coordinate C2, const Coordinate C
     // a circle by three points requires thee distinct points
     auto center = circleCenter(C1, C2, C3);
     if (center)
-        return haversineDistance(C1, *center);
+        return greatCircleDistance(C1, *center);
     else
         return std::numeric_limits<double>::infinity();
 }
@@ -372,8 +314,8 @@ double findClosestDistance(const Coordinate coordinate,
                            const Coordinate segment_begin,
                            const Coordinate segment_end)
 {
-    return haversineDistance(coordinate,
-                             projectPointOnSegment(segment_begin, segment_end, coordinate).second);
+    return greatCircleDistance(
+        coordinate, projectPointOnSegment(segment_begin, segment_end, coordinate).second);
 }
 
 // find the closes distance between two sets of coordinates
@@ -386,7 +328,7 @@ double findClosestDistance(const std::vector<Coordinate> &lhs, const std::vector
             std::min(current_min, findClosestDistance(coordinate, rhs.begin(), rhs.end()));
         return false;
     };
-
+    // NOLINTNEXTLINE(bugprone-unused-return-value)
     std::find_if(std::begin(lhs), std::end(lhs), compute_minimum_distance_in_rhs);
     return current_min;
 }
@@ -437,7 +379,7 @@ Coordinate difference(const Coordinate lhs, const Coordinate rhs)
 
 double computeArea(const std::vector<Coordinate> &polygon)
 {
-    using util::coordinate_calculation::haversineDistance;
+    using util::coordinate_calculation::greatCircleDistance;
 
     if (polygon.empty())
         return 0.;
@@ -458,15 +400,15 @@ double computeArea(const std::vector<Coordinate> &polygon)
     double area = 0.;
     auto first = polygon.begin();
     auto previous_base = util::Coordinate{first->lon, ref_latitude};
-    auto previous_y = haversineDistance(previous_base, *first);
+    auto previous_y = greatCircleDistance(previous_base, *first);
     for (++first; first != polygon.end(); ++first)
     {
         BOOST_ASSERT(first->lat >= ref_latitude);
 
         const auto current_base = util::Coordinate{first->lon, ref_latitude};
-        const auto current_y = haversineDistance(current_base, *first);
+        const auto current_y = greatCircleDistance(current_base, *first);
         const auto chunk_area =
-            haversineDistance(previous_base, current_base) * (previous_y + current_y);
+            greatCircleDistance(previous_base, current_base) * (previous_y + current_y);
 
         area += (current_base.lon >= previous_base.lon) ? chunk_area : -chunk_area;
 
diff --git a/src/util/exception.cpp b/src/util/exception.cpp
index 8e7f4d184..2788deace 100644
--- a/src/util/exception.cpp
+++ b/src/util/exception.cpp
@@ -18,5 +18,5 @@ namespace util
 
 void exception::anchor() const {}
 void RuntimeError::anchor() const {}
-}
-}
+} // namespace util
+} // namespace osrm
diff --git a/src/util/fingerprint.cpp b/src/util/fingerprint.cpp
index d5e8e7ede..303d318aa 100644
--- a/src/util/fingerprint.cpp
+++ b/src/util/fingerprint.cpp
@@ -91,5 +91,5 @@ bool FingerPrint::IsDataCompatible(const FingerPrint &other) const
     return IsValid() && other.major_version == major_version &&
            other.minor_version == minor_version;
 }
-}
-}
+} // namespace util
+} // namespace osrm
diff --git a/src/util/geojson_debug_policies.cpp b/src/util/geojson_debug_policies.cpp
index 725b8078a..0cd898808 100644
--- a/src/util/geojson_debug_policies.cpp
+++ b/src/util/geojson_debug_policies.cpp
@@ -17,9 +17,9 @@ NodeIdVectorToLineString::NodeIdVectorToLineString(
 }
 
 // converts a vector of node ids into a linestring geojson feature
-util::json::Object NodeIdVectorToLineString::
-operator()(const std::vector<NodeID> &node_ids,
-           const boost::optional<json::Object> &properties) const
+util::json::Object
+NodeIdVectorToLineString::operator()(const std::vector<NodeID> &node_ids,
+                                     const boost::optional<json::Object> &properties) const
 {
     util::json::Array coordinates;
     std::transform(node_ids.begin(),
@@ -37,9 +37,9 @@ NodeIdVectorToMultiPoint::NodeIdVectorToMultiPoint(
 {
 }
 
-util::json::Object NodeIdVectorToMultiPoint::
-operator()(const std::vector<NodeID> &node_ids,
-           const boost::optional<json::Object> &properties) const
+util::json::Object
+NodeIdVectorToMultiPoint::operator()(const std::vector<NodeID> &node_ids,
+                                     const boost::optional<json::Object> &properties) const
 {
     util::json::Array coordinates;
     std::transform(node_ids.begin(),
@@ -51,20 +51,20 @@ operator()(const std::vector<NodeID> &node_ids,
 }
 
 //----------------------------------------------------------------
-util::json::Object CoordinateVectorToMultiPoint::
-operator()(const std::vector<util::Coordinate> &input_coordinates,
-           const boost::optional<json::Object> &properties) const
+util::json::Object
+CoordinateVectorToMultiPoint::operator()(const std::vector<util::Coordinate> &input_coordinates,
+                                         const boost::optional<json::Object> &properties) const
 {
-    const auto coordinates = makeJsonArray(input_coordinates);
+    auto coordinates = makeJsonArray(input_coordinates);
     return makeFeature("MultiPoint", std::move(coordinates), properties);
 }
 
 //----------------------------------------------------------------
-util::json::Object CoordinateVectorToLineString::
-operator()(const std::vector<util::Coordinate> &input_coordinates,
-           const boost::optional<json::Object> &properties) const
+util::json::Object
+CoordinateVectorToLineString::operator()(const std::vector<util::Coordinate> &input_coordinates,
+                                         const boost::optional<json::Object> &properties) const
 {
-    const auto coordinates = makeJsonArray(input_coordinates);
+    auto coordinates = makeJsonArray(input_coordinates);
     return makeFeature("LineString", std::move(coordinates), properties);
 }
 
diff --git a/src/util/glibc_workaround.cpp b/src/util/glibc_workaround.cpp
index 19811bee1..ed185016f 100644
--- a/src/util/glibc_workaround.cpp
+++ b/src/util/glibc_workaround.cpp
@@ -25,7 +25,7 @@ void __throw_out_of_range_fmt(const char *err, ...)
     // Safe and over-simplified version. Ignore the format and print it as-is.
     __throw_out_of_range(err);
 }
-}
+} // namespace std
 #endif // _ENABLE_GLIBC_WORKAROUND
 
 #endif // GLIBC_WORKAROUND
\ No newline at end of file
diff --git a/src/util/log.cpp b/src/util/log.cpp
index 0d9a06813..2809a406a 100644
--- a/src/util/log.cpp
+++ b/src/util/log.cpp
@@ -22,7 +22,7 @@ static const char MAGENTA[]{"\x1b[35m"};
 // static const char GREEN[] { "\x1b[32m"};
 // static const char BLUE[] { "\x1b[34m"};
 // static const char CYAN[] { "\x1b[36m"};
-}
+} // namespace
 
 void LogPolicy::Unmute() { m_is_mute = false; }
 
@@ -63,7 +63,11 @@ std::string LogPolicy::GetLevels()
     return "NONE, ERROR, WARNING, INFO, DEBUG";
 }
 
-Log::Log(LogLevel level_, std::ostream &ostream) : level(level_), stream(ostream)
+Log::Log(LogLevel level_, std::ostream &ostream) : level(level_), stream(ostream) { Init(); }
+
+Log::Log(LogLevel level_) : level(level_), buffer{}, stream{buffer} { Init(); }
+
+void Log::Init()
 {
     std::lock_guard<std::mutex> lock(get_mutex());
     if (!LogPolicy::GetInstance().IsMute() && level <= LogPolicy::GetInstance().GetLevel())
@@ -91,8 +95,6 @@ Log::Log(LogLevel level_, std::ostream &ostream) : level(level_), stream(ostream
     }
 }
 
-Log::Log(LogLevel level_) : Log(level_, buffer) {}
-
 std::mutex &Log::get_mutex()
 {
     static std::mutex mtx;
@@ -150,5 +152,5 @@ UnbufferedLog::UnbufferedLog(LogLevel level_)
 {
     stream.flags(std::ios_base::unitbuf);
 }
-}
-}
+} // namespace util
+} // namespace osrm
diff --git a/src/util/opening_hours.cpp b/src/util/opening_hours.cpp
index 6d74c854e..e3ce583d9 100644
--- a/src/util/opening_hours.cpp
+++ b/src/util/opening_hours.cpp
@@ -125,7 +125,7 @@ namespace
 {
 namespace ph = boost::phoenix;
 namespace qi = boost::spirit::qi;
-}
+} // namespace
 
 template <typename Iterator, typename Skipper = qi::blank_type>
 struct opening_hours_grammar : qi::grammar<Iterator, Skipper, std::vector<OpeningHours>()>
@@ -398,7 +398,7 @@ struct opening_hours_grammar : qi::grammar<Iterator, Skipper, std::vector<Openin
     qi::uint_parser<unsigned, 10, 2, 2> uint2_p;
     qi::uint_parser<unsigned, 10, 4, 4> uint4_p;
 };
-}
+} // namespace detail
 
 std::vector<OpeningHours> ParseOpeningHours(const std::string &str)
 {
@@ -431,5 +431,5 @@ bool CheckOpeningHours(const std::vector<OpeningHours> &input, const struct tm &
     return is_open;
 }
 
-} // util
-} // osrm
+} // namespace util
+} // namespace osrm
diff --git a/src/util/timed_historgram.cpp b/src/util/timed_historgram.cpp
index 706651069..92657e70c 100644
--- a/src/util/timed_historgram.cpp
+++ b/src/util/timed_historgram.cpp
@@ -8,5 +8,5 @@ namespace detail
 {
 std::atomic_uint operation = {0};
 }
-}
-}
+} // namespace util
+} // namespace osrm
diff --git a/src/util/timezones.cpp b/src/util/timezones.cpp
index 264176a68..948f34855 100644
--- a/src/util/timezones.cpp
+++ b/src/util/timezones.cpp
@@ -110,14 +110,23 @@ void Timezoner::LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t ut
         // time zone geojson specific checks
         const auto &feature = features_array[i].GetObject();
         const auto &properties = feature["properties"].GetObject();
-        if (!properties.HasMember("tzid"))
+        std::string tzid_key = "tzid";
+        if (properties.HasMember("tzid"))
+        {
+            if (!properties["tzid"].IsString())
+                throw osrm::util::exception("Feature has non-string 'tzid' value.");
+            tzid_key = "tzid";
+        }
+        else if (properties.HasMember("TZID"))
+        {
+            if (!properties["TZID"].IsString())
+                throw osrm::util::exception("Feature has non-string 'TZID' value.");
+            tzid_key = "TZID";
+        }
+        else
         {
             throw osrm::util::exception("Feature is missing 'tzid' member in properties.");
         }
-        else if (!properties["tzid"].IsString())
-        {
-            throw osrm::util::exception("Feature has non-string 'tzid' value.");
-        }
 
         // Case-sensitive check of type https://tools.ietf.org/html/rfc7946#section-1.4
         const auto &geometry = feature["geometry"].GetObject();
@@ -137,7 +146,7 @@ void Timezoner::LoadLocalTimesRTree(rapidjson::Document &geojson, std::time_t ut
                                   local_times.size());
 
             // Get time zone name and emplace polygon and local time for the UTC input
-            const auto &tzname = properties["tzid"].GetString();
+            const auto &tzname = properties[tzid_key.c_str()].GetString();
             local_times.push_back(local_time_t{polygon, get_local_time_in_tz(tzname)});
         }
         else
@@ -162,5 +171,5 @@ boost::optional<struct tm> Timezoner::operator()(const point_t &point) const
     }
     return boost::none;
 }
-}
-}
+} // namespace updater
+} // namespace osrm
diff --git a/taginfo.json b/taginfo.json
index d7a5409b4..358845d80 100644
--- a/taginfo.json
+++ b/taginfo.json
@@ -125,6 +125,7 @@
         {"key": "side_road", "value": "rotary", "description": "gets speed penalty"},
         {"key": "route", "object_types": ["way"]},
         {"key": "highway", "value": "traffic_signals", "object_types": ["node"]},
+        {"key": "highway", "value": "crossing", "object_types": ["node"]},
         {"key": "access", "value": "yes"},
         {"key": "access", "value": "motorcar"},
         {"key": "access", "value": "motor_vehicle"},
@@ -202,6 +203,7 @@
         {"key": "barrier", "value": "lift_gate"},
         {"key": "barrier", "value": "no"},
         {"key": "barrier", "value": "entrance"},
+        {"key": "barrier", "value": "kerb"},
         {"key": "highway", "value": "motorway"},
         {"key": "highway", "value": "motorway_link"},
         {"key": "highway", "value": "trunk"},
@@ -220,6 +222,8 @@
         {"key": "highway", "value": "movable"},
         {"key": "highway", "value": "shuttle_train"},
         {"key": "highway", "value": "default"},
+        {"key": "kerb", "value": "lowered", "object_types": ["node"]},
+        {"key": "kerb", "value": "flush", "object_types": ["node"]},
         {"key": "width", "description": "Penalties for narrow streets"},
         {"key": "lanes", "description": "Penalties for shared single lane streets"},
         {"key": "lanes:forward", "description": "Lanes in forward direction"},
diff --git a/test/nodejs/constants.js b/test/nodejs/constants.js
index a6a32ca25..72b93da30 100644
--- a/test/nodejs/constants.js
+++ b/test/nodejs/constants.js
@@ -10,7 +10,7 @@ exports.three_test_coordinates = [[7.41337, 43.72956],
 
 exports.two_test_coordinates = exports.three_test_coordinates.slice(0, 2)
 
-exports.test_tile = {'at': [17059, 11948, 15], 'size': 156624};
+exports.test_tile = {'at': [17059, 11948, 15], 'size': 156539};
 
 // Test files generated by the routing engine; check test/data
 if (process.env.OSRM_DATA_PATH !== undefined) {
diff --git a/test/nodejs/route.js b/test/nodejs/route.js
index f23eaf3ee..7d27639ea 100644
--- a/test/nodejs/route.js
+++ b/test/nodejs/route.js
@@ -708,6 +708,6 @@ test('route: snapping parameter passed through OK', function(assert) {
     var osrm = new OSRM(monaco_path);
     osrm.route({snapping: "any", coordinates: [[7.448205209414596,43.754001097311544],[7.447122039202185,43.75306156811368]]}, function(err, route) {
         assert.ifError(err);
-        assert.equal(Math.round(route.routes[0].distance * 10), 1314); // Round it to nearest 0.1m to eliminate floating point comparison error
+        assert.equal(Math.round(route.routes[0].distance * 10), 1315); // Round it to nearest 0.1m to eliminate floating point comparison error
     });
 });
\ No newline at end of file
diff --git a/test/nodejs/table.js b/test/nodejs/table.js
index 7f7fea006..f4f0e6312 100644
--- a/test/nodejs/table.js
+++ b/test/nodejs/table.js
@@ -130,7 +130,7 @@ tables.forEach(function(annotation) {
     });
 
     test('table: ' + annotation + ' throws on invalid arguments', function(assert) {
-        assert.plan(15);
+        assert.plan(17);
         var osrm = new OSRM(data_path);
         var options = {annotations: [annotation.slice(0,-1)]};
         assert.throws(function() { osrm.table(options); },
@@ -157,10 +157,13 @@ tables.forEach(function(annotation) {
             /Sources must be an array of indices \(or undefined\)/);
         options.sources = [0, 4];
         assert.throws(function() { osrm.table(options, function(err, response) {}) },
-            /Source indices must be less than or equal to the number of coordinates/);
+            /Source indices must be less than the number of coordinates/);
         options.sources = [0.3, 1.1];
         assert.throws(function() { osrm.table(options, function(err, response) {}) },
             /Source must be an integer/);
+        options.sources = [0, 1, 2];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Source indices must be less than the number of coordinates/);
 
         options.destinations = true;
         delete options.sources;
@@ -168,10 +171,13 @@ tables.forEach(function(annotation) {
             /Destinations must be an array of indices \(or undefined\)/);
         options.destinations = [0, 4];
         assert.throws(function() { osrm.table(options, function(err, response) {}) },
-            /Destination indices must be less than or equal to the number of coordinates/);
+            /Destination indices must be less than the number of coordinates/);
         options.destinations = [0.3, 1.1];
         assert.throws(function() { osrm.table(options, function(err, response) {}) },
             /Destination must be an integer/);
+        options.destinations = [0, 4];
+        assert.throws(function() { osrm.table(options, function(err, response) {}) },
+            /Destination indices must be less than the number of coordinates/);
 
         // does not throw: the following two have been changed in OSRM v5
         options.sources = [0, 1];
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.clang-format b/third_party/cheap-ruler-cpp-2778eb8/.clang-format
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/.clang-format
rename to third_party/cheap-ruler-cpp-2778eb8/.clang-format
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.gitignore b/third_party/cheap-ruler-cpp-2778eb8/.gitignore
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/.gitignore
rename to third_party/cheap-ruler-cpp-2778eb8/.gitignore
diff --git a/third_party/cheap-ruler-cpp-2.5.4/.travis.yml b/third_party/cheap-ruler-cpp-2778eb8/.travis.yml
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/.travis.yml
rename to third_party/cheap-ruler-cpp-2778eb8/.travis.yml
diff --git a/third_party/cheap-ruler-cpp-2.5.4/CMakeLists.txt b/third_party/cheap-ruler-cpp-2778eb8/CMakeLists.txt
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/CMakeLists.txt
rename to third_party/cheap-ruler-cpp-2778eb8/CMakeLists.txt
diff --git a/third_party/cheap-ruler-cpp-2.5.4/LICENSE b/third_party/cheap-ruler-cpp-2778eb8/LICENSE
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/LICENSE
rename to third_party/cheap-ruler-cpp-2778eb8/LICENSE
diff --git a/third_party/cheap-ruler-cpp-2.5.4/README.md b/third_party/cheap-ruler-cpp-2778eb8/README.md
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/README.md
rename to third_party/cheap-ruler-cpp-2778eb8/README.md
diff --git a/third_party/cheap-ruler-cpp-2.5.4/cmake/build.cmake b/third_party/cheap-ruler-cpp-2778eb8/cmake/build.cmake
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/cmake/build.cmake
rename to third_party/cheap-ruler-cpp-2778eb8/cmake/build.cmake
diff --git a/third_party/cheap-ruler-cpp-2.5.4/cmake/mason.cmake b/third_party/cheap-ruler-cpp-2778eb8/cmake/mason.cmake
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/cmake/mason.cmake
rename to third_party/cheap-ruler-cpp-2778eb8/cmake/mason.cmake
diff --git a/third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp b/third_party/cheap-ruler-cpp-2778eb8/include/mapbox/cheap_ruler.hpp
similarity index 67%
rename from third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp
rename to third_party/cheap-ruler-cpp-2778eb8/include/mapbox/cheap_ruler.hpp
index d5ae7428b..19854fc08 100644
--- a/third_party/cheap-ruler-cpp-2.5.4/include/mapbox/cheap_ruler.hpp
+++ b/third_party/cheap-ruler-cpp-2778eb8/include/mapbox/cheap_ruler.hpp
@@ -1,7 +1,10 @@
 #pragma once
 
-#include <mapbox/geometry.hpp>
+#include <mapbox/geometry/box.hpp>
+#include <mapbox/geometry/multi_line_string.hpp>
+#include <mapbox/geometry/polygon.hpp>
 
+#include <cassert>
 #include <cmath>
 #include <cstdint>
 #include <limits>
@@ -19,6 +22,14 @@ using point             = geometry::point<double>;
 using polygon           = geometry::polygon<double>;
 
 class CheapRuler {
+
+    // Values that define WGS84 ellipsoid model of the Earth
+    static constexpr double RE = 6378.137; // equatorial radius
+    static constexpr double FE = 1.0 / 298.257223563; // flattening
+
+    static constexpr double E2 = FE * (2 - FE);
+    static constexpr double RAD = M_PI / 180.0;
+
 public:
     enum Unit {
         Kilometers,
@@ -63,68 +74,61 @@ public:
             break;
         }
 
-        auto cos = std::cos(latitude * M_PI / 180.);
-        auto cos2 = 2. * cos * cos - 1.;
-        auto cos3 = 2. * cos * cos2 - cos;
-        auto cos4 = 2. * cos * cos3 - cos2;
-        auto cos5 = 2. * cos * cos4 - cos3;
+        // Curvature formulas from https://en.wikipedia.org/wiki/Earth_radius#Meridional
+        double mul = RAD * RE * m;
+        double coslat = std::cos(latitude * RAD);
+        double w2 = 1 / (1 - E2 * (1 - coslat * coslat));
+        double w = std::sqrt(w2);
 
-        // multipliers for converting longitude and latitude
-        // degrees into distance (http://1.usa.gov/1Wb1bv7)
-        kx = m * (111.41513 * cos - 0.09455 * cos3 + 0.00012 * cos5);
-        ky = m * (111.13209 - 0.56605 * cos2 + 0.0012 * cos4);
+        // multipliers for converting longitude and latitude degrees into distance
+        kx = mul * w * coslat;        // based on normal radius of curvature
+        ky = mul * w * w2 * (1 - E2); // based on meridonal radius of curvature
     }
 
     static CheapRuler fromTile(uint32_t y, uint32_t z) {
-        double n = M_PI * (1. - 2. * (y + 0.5) / std::pow(2., z));
-        double latitude = std::atan(0.5 * (std::exp(n) - std::exp(-n))) * 180. / M_PI;
+        assert(z < 32);
+        double n = M_PI * (1. - 2. * (y + 0.5) / double(uint32_t(1) << z));
+        double latitude = std::atan(std::sinh(n)) / RAD;
 
         return CheapRuler(latitude);
     }
 
+    double squareDistance(point a, point b) const {
+        auto dx = longDiff(a.x, b.x) * kx;
+        auto dy = (a.y - b.y) * ky;
+        return dx * dx + dy * dy;
+    }
+
     //
     // Given two points of the form [x = longitude, y = latitude], returns the distance.
     //
-    double distance(point a, point b) {
-        auto dx = (a.x - b.x) * kx;
-        auto dy = (a.y - b.y) * ky;
-
-        return std::sqrt(dx * dx + dy * dy);
+    double distance(point a, point b) const {
+        return std::sqrt(squareDistance(a, b));
     }
 
     //
     // Returns the bearing between two points in angles.
     //
-    double bearing(point a, point b) {
-        auto dx = (b.x - a.x) * kx;
+    double bearing(point a, point b) const {
+        auto dx = longDiff(b.x, a.x) * kx;
         auto dy = (b.y - a.y) * ky;
 
-        if (!dx && !dy) {
-            return 0.;
-        }
-
-        auto value = std::atan2(dx, dy) * 180. / M_PI;
-
-        if (value > 180.) {
-            value -= 360.;
-        }
-
-        return value;
+        return std::atan2(dx, dy) / RAD;
     }
 
     //
     // Returns a new point given distance and bearing from the starting point.
     //
-    point destination(point origin, double dist, double bearing_) {
-        auto a = (90. - bearing_) * M_PI / 180.;
+    point destination(point origin, double dist, double bearing_) const {
+        auto a = bearing_ * RAD;
 
-        return offset(origin, std::cos(a) * dist, std::sin(a) * dist);
+        return offset(origin, std::sin(a) * dist, std::cos(a) * dist);
     }
 
     //
     // Returns a new point given easting and northing offsets from the starting point.
     //
-    point offset(point origin, double dx, double dy) {
+    point offset(point origin, double dx, double dy) const {
         return point(origin.x + dx / kx, origin.y + dy / ky);
     }
 
@@ -134,8 +138,8 @@ public:
     double lineDistance(const line_string& points) {
         double total = 0.;
 
-        for (unsigned i = 0; i < points.size() - 1; ++i) {
-            total += distance(points[i], points[i + 1]);
+        for (size_t i = 1; i < points.size(); ++i) {
+            total += distance(points[i - 1], points[i]);
         }
 
         return total;
@@ -145,14 +149,15 @@ public:
     // Given a polygon (an array of rings, where each ring is an array of points),
     // returns the area.
     //
-    double area(polygon poly) {
+    double area(polygon poly) const {
         double sum = 0.;
 
         for (unsigned i = 0; i < poly.size(); ++i) {
             auto& ring = poly[i];
 
             for (unsigned j = 0, len = ring.size(), k = len - 1; j < len; k = j++) {
-                sum += (ring[j].x - ring[k].x) * (ring[j].y + ring[k].y) * (i ? -1. : 1.);
+                sum += longDiff(ring[j].x, ring[k].x) *
+                  (ring[j].y + ring[k].y) * (i ? -1. : 1.);
             }
         }
 
@@ -162,9 +167,13 @@ public:
     //
     // Returns the point at a specified distance along the line.
     //
-    point along(const line_string& line, double dist) {
+    point along(const line_string& line, double dist) const {
         double sum = 0.;
 
+        if (line.empty()) {
+            return {};
+        }
+
         if (dist <= 0.) {
             return line[0];
         }
@@ -184,25 +193,52 @@ public:
         return line[line.size() - 1];
     }
 
+    //
+    // Returns the distance from a point `p` to a line segment `a` to `b`.
+    //
+  double pointToSegmentDistance(const point& p, const point& a, const point& b) const {
+        auto t = 0.0;
+        auto x = a.x;
+        auto y = a.y;
+        auto dx = longDiff(b.x, x) * kx;
+        auto dy = (b.y - y) * ky;
+
+        if (dx != 0.0 || dy != 0.0) {
+            t = (longDiff(p.x, x) * kx * dx + (p.y - y) * ky * dy) / (dx * dx + dy * dy);
+            if (t > 1.0) {
+                x = b.x;
+                y = b.y;
+            } else if (t > 0.0) {
+                x += (dx / kx) * t;
+                y += (dy / ky) * t;
+            }
+        }
+        return distance(p, { x, y });
+    }
+
     //
     // Returns a tuple of the form <point, index, t> where point is closest point on the line
     // from the given point, index is the start index of the segment with the closest point,
     // and t is a parameter from 0 to 1 that indicates where the closest point is on that segment.
     //
-    std::tuple<point, unsigned, double> pointOnLine(const line_string& line, point p) {
+    std::tuple<point, unsigned, double> pointOnLine(const line_string& line, point p) const {
         double minDist = std::numeric_limits<double>::infinity();
         double minX = 0., minY = 0., minI = 0., minT = 0.;
 
+        if (line.empty()) {
+            return std::make_tuple(point(), 0., 0.);
+        }
+
         for (unsigned i = 0; i < line.size() - 1; ++i) {
             auto t = 0.;
             auto x = line[i].x;
             auto y = line[i].y;
-            auto dx = (line[i + 1].x - x) * kx;
+            auto dx = longDiff(line[i + 1].x, x) * kx;
             auto dy = (line[i + 1].y - y) * ky;
 
             if (dx != 0. || dy != 0.) {
-                t = ((p.x - x) * kx * dx + (p.y - y) * ky * dy) / (dx * dx + dy * dy);
-
+                t = (longDiff(p.x, x) * kx * dx +
+                     (p.y - y) * ky * dy) / (dx * dx + dy * dy);
                 if (t > 1) {
                     x = line[i + 1].x;
                     y = line[i + 1].y;
@@ -213,10 +249,7 @@ public:
                 }
             }
 
-            dx = (p.x - x) * kx;
-            dy = (p.y - y) * ky;
-
-            auto sqDist = dx * dx + dy * dy;
+            auto sqDist = squareDistance(p, {x, y});
 
             if (sqDist < minDist) {
                 minDist = sqDist;
@@ -235,7 +268,7 @@ public:
     // Returns a part of the given line between the start and the stop points (or their closest
     // points on the line).
     //
-    line_string lineSlice(point start, point stop, const line_string& line) {
+    line_string lineSlice(point start, point stop, const line_string& line) const {
         auto getPoint = [](auto tuple) { return std::get<0>(tuple); };
         auto getIndex = [](auto tuple) { return std::get<1>(tuple); };
         auto getT     = [](auto tuple) { return std::get<2>(tuple); };
@@ -273,13 +306,13 @@ public:
     // Returns a part of the given line between the start and the stop points
     // indicated by distance along the line.
     //
-    line_string lineSliceAlong(double start, double stop, const line_string& line) {
+    line_string lineSliceAlong(double start, double stop, const line_string& line) const {
         double sum = 0.;
         line_string slice;
 
-        for (unsigned i = 0; i < line.size() - 1; ++i) {
-            auto p0 = line[i];
-            auto p1 = line[i + 1];
+        for (size_t i = 1; i < line.size(); ++i) {
+            auto p0 = line[i - 1];
+            auto p1 = line[i];
             auto d = distance(p0, p1);
 
             sum += d;
@@ -305,7 +338,7 @@ public:
     // Given a point, returns a bounding box object ([w, s, e, n])
     // created from the given point buffered by a given distance.
     //
-    box bufferPoint(point p, double buffer) {
+    box bufferPoint(point p, double buffer) const {
         auto v = buffer / ky;
         auto h = buffer / kx;
 
@@ -318,7 +351,7 @@ public:
     //
     // Given a bounding box, returns the box buffered by a given distance.
     //
-    box bufferBBox(box bbox, double buffer) {
+    box bufferBBox(box bbox, double buffer) const {
         auto v = buffer / ky;
         auto h = buffer / kx;
 
@@ -331,15 +364,15 @@ public:
     //
     // Returns true if the given point is inside in the given bounding box, otherwise false.
     //
-    bool insideBBox(point p, box bbox) {
-        return p.x >= bbox.min.x &&
-               p.x <= bbox.max.x &&
-               p.y >= bbox.min.y &&
-               p.y <= bbox.max.y;
+    static bool insideBBox(point p, box bbox) {
+        return p.y >= bbox.min.y &&
+               p.y <= bbox.max.y &&
+               longDiff(p.x, bbox.min.x) >= 0 &&
+               longDiff(p.x, bbox.max.x) <= 0;
     }
 
     static point interpolate(point a, point b, double t) {
-        double dx = b.x - a.x;
+        double dx = longDiff(b.x, a.x);
         double dy = b.y - a.y;
 
         return point(a.x + dx * t, a.y + dy * t);
@@ -348,6 +381,9 @@ public:
 private:
     double ky;
     double kx;
+    static double longDiff(double a, double b) {
+        return std::remainder(a - b, 360);
+    }
 };
 
 } // namespace cheap_ruler
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp b/third_party/cheap-ruler-cpp-2778eb8/test/cheap_ruler.cpp
similarity index 65%
rename from third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp
rename to third_party/cheap-ruler-cpp-2778eb8/test/cheap_ruler.cpp
index 0ac73c81f..bd51f7ee8 100644
--- a/third_party/cheap-ruler-cpp-2.5.4/test/cheap_ruler.cpp
+++ b/third_party/cheap-ruler-cpp-2778eb8/test/cheap_ruler.cpp
@@ -1,5 +1,6 @@
 #include <mapbox/cheap_ruler.hpp>
 #include <gtest/gtest.h>
+#include <random>
 
 #include "fixtures/lines.hpp"
 #include "fixtures/turf.hpp"
@@ -60,6 +61,13 @@ TEST_F(CheapRulerTest, destination) {
 }
 
 TEST_F(CheapRulerTest, lineDistance) {
+    {
+        cr::line_string emptyLine {};
+        auto expected = 0.0;
+        auto actual = ruler.lineDistance(emptyLine);
+        assertErr(expected, actual, 0.0);
+    }
+
     for (unsigned i = 0; i < lines.size(); ++i) {
         auto expected = turf_lineDistance[i];
         auto actual = ruler.lineDistance(lines[i]);
@@ -88,6 +96,16 @@ TEST_F(CheapRulerTest, area) {
 }
 
 TEST_F(CheapRulerTest, along) {
+    {
+        cr::point emptyPoint {};
+        cr::line_string emptyLine {};
+        auto expected = emptyPoint;
+        auto actual = ruler.along(emptyLine, 0.0);
+
+        assertErr(expected.x, actual.x, 0.0);
+        assertErr(expected.y, actual.y, 0.0);
+    }
+
     for (unsigned i = 0; i < lines.size(); ++i) {
         auto expected = turf_along[i];
         auto actual = ruler.along(lines[i], turf_along_dist[i]);
@@ -110,14 +128,23 @@ TEST_F(CheapRulerTest, pointOnLine) {
     cr::line_string line = {{ -77.031669, 38.878605 }, { -77.029609, 38.881946 }};
     auto result = ruler.pointOnLine(line, { -77.034076, 38.882017 });
 
-    ASSERT_EQ(std::get<0>(result), cr::point(-77.03052697027461, 38.880457194811896)); // point
+    assertErr(std::get<0>(result).x, -77.03052689033436, 1e-6);
+    assertErr(std::get<0>(result).y, 38.880457324462576, 1e-6);
     ASSERT_EQ(std::get<1>(result), 0u); // index
-    ASSERT_EQ(std::get<2>(result), 0.5543833618360235); // t
+    assertErr(std::get<2>(result), 0.5544221677861756, 1e-6); // t
 
     ASSERT_EQ(std::get<2>(ruler.pointOnLine(line, { -80., 38. })), 0.) << "t is not less than 0";
     ASSERT_EQ(std::get<2>(ruler.pointOnLine(line, { -75., 38. })), 1.) << "t is not bigger than 1";
 }
 
+TEST_F(CheapRulerTest, pointToSegmentDistance) {
+    cr::point p{ -77.034076, 38.882017 };
+    cr::point p0{ -77.031669, 38.878605 };
+    cr::point p1{ -77.029609, 38.881946 };
+    const auto distance = ruler.pointToSegmentDistance(p, p0, p1);
+    assertErr(0.37461484020420416, distance, 1e-6);
+}
+
 TEST_F(CheapRulerTest, lineSlice) {
     for (unsigned i = 0; i < lines.size(); ++i) {
         auto line = lines[i];
@@ -127,11 +154,19 @@ TEST_F(CheapRulerTest, lineSlice) {
         auto expected = turf_lineSlice[i];
         auto actual = ruler.lineDistance(ruler.lineSlice(start, stop, line));
 
-        assertErr(expected, actual, 1e-5);
+        /// @todo Should update turf_lineSlice and revert maxError back.
+        assertErr(expected, actual, 1e-4);
     }
 }
 
 TEST_F(CheapRulerTest, lineSliceAlong) {
+    {
+        cr::line_string emptyLine {};
+        auto expected = ruler.lineDistance(emptyLine);
+        auto actual = ruler.lineDistance(ruler.lineSliceAlong(0.0, 0.0, emptyLine));
+        assertErr(expected, actual, 0.0);
+    }
+
     for (unsigned i = 0; i < lines.size(); ++i) {
         if (i == 46) {
             // skip due to Turf bug https://github.com/Turfjs/turf/issues/351
@@ -143,7 +178,8 @@ TEST_F(CheapRulerTest, lineSliceAlong) {
         auto expected = turf_lineSlice[i];
         auto actual = ruler.lineDistance(ruler.lineSliceAlong(dist * 0.3, dist * 0.7, line));
 
-        assertErr(expected, actual, 1e-5);
+        /// @todo Should update turf_lineSlice and revert maxError back.
+        assertErr(expected, actual, 1e-4);
     }
 }
 
@@ -154,7 +190,7 @@ TEST_F(CheapRulerTest, lineSliceReverse) {
     auto stop = ruler.along(line, dist * 0.3);
     auto actual = ruler.lineDistance(ruler.lineSlice(start, stop, line));
 
-    ASSERT_EQ(actual, 0.018676802802910702);
+    assertErr(0.018676476689649835, actual, 1e-6);
 }
 
 TEST_F(CheapRulerTest, bufferPoint) {
@@ -173,7 +209,10 @@ TEST_F(CheapRulerTest, bufferBBox) {
     cr::box bbox({ 30, 38 }, { 40, 39 });
     cr::box bbox2 = ruler.bufferBBox(bbox, 1);
 
-    ASSERT_EQ(bbox2, cr::box({ 29.989319515875376, 37.99098271225711 }, { 40.01068048412462, 39.00901728774289 }));
+    assertErr(bbox2.min.x,  29.989319515875376, 1e-6);
+    assertErr(bbox2.min.y,  37.99098271225711, 1e-6);
+    assertErr(bbox2.max.x,  40.01068048412462, 1e-6);
+    assertErr(bbox2.max.y,  39.00901728774289, 1e-6);
 }
 
 TEST_F(CheapRulerTest, insideBBox) {
@@ -193,6 +232,43 @@ TEST_F(CheapRulerTest, fromTile) {
     assertErr(ruler1.distance(p1, p2), ruler2.distance(p1, p2), 2e-5);
 }
 
+TEST_F(CheapRulerTest, longitudeWrap) {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::bernoulli_distribution d(0.5); // true with prob 0.5
+
+    auto r = cr::CheapRuler(50.5);
+    cr::polygon poly(1);
+    auto& ring = poly[0];
+    cr::line_string line;
+    cr::point origin(0, 50.5);  // Greenwich
+    auto rad = 1000.0;
+    // construct a regular dodecagon
+    for (int i = -180; i <= 180; i += 30) {
+      auto p = r.destination(origin, rad, i);
+      // shift randomly east/west to the international date line
+      p.x += d(gen) ? 180 : -180;
+      ring.push_back(p);
+      line.push_back(p);
+    }
+    auto p = r.lineDistance(line);
+    auto a = r.area(poly);
+    // cheap_ruler does planar calculations, so the perimeter and area of a
+    // planar regular dodecagon with circumradius rad are used in these checks.
+    // For the record, the results for rad = 1000 km are:
+    //        perimeter    area
+    // planar 6211.657082  3000000
+    // WGS84  6187.959236  2996317.6328
+    // error  0.38%        0.12%
+    assertErr(12 * rad / sqrt(2 + sqrt(3.0)), p, 1e-12);
+    assertErr(3 * rad * rad, a, 1e-12);
+    for (int j = 1; j < (int)line.size(); ++j) {
+      auto azi = r.bearing(line[j-1], line[j]);
+      // offset expect and actual by 1 to make err criterion absolute
+      assertErr(1, std::remainder(270 - 15 + 30*j - azi, 360) + 1, 1e-12);
+      }
+}
+
 int main(int argc, char **argv) {
     ::testing::InitGoogleTest(&argc, argv);
 
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/lines.hpp b/third_party/cheap-ruler-cpp-2778eb8/test/fixtures/lines.hpp
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/test/fixtures/lines.hpp
rename to third_party/cheap-ruler-cpp-2778eb8/test/fixtures/lines.hpp
diff --git a/third_party/cheap-ruler-cpp-2.5.4/test/fixtures/turf.hpp b/third_party/cheap-ruler-cpp-2778eb8/test/fixtures/turf.hpp
similarity index 100%
rename from third_party/cheap-ruler-cpp-2.5.4/test/fixtures/turf.hpp
rename to third_party/cheap-ruler-cpp-2778eb8/test/fixtures/turf.hpp
diff --git a/third_party/libosmium/.clang-tidy b/third_party/libosmium/.clang-tidy
index 9f3240b87..466adca34 100644
--- a/third_party/libosmium/.clang-tidy
+++ b/third_party/libosmium/.clang-tidy
@@ -1,14 +1,31 @@
 ---
-Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-vararg,-fuchsia-*,-google-runtime-references,-hicpp-invalid-access-moved,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-vararg,-misc-macro-parentheses,-misc-unused-parameters,-modernize-make-unique,-modernize-raw-string-literal,-readability-avoid-const-params-in-decls,-readability-implicit-bool-cast,-readability-implicit-bool-conversion'
+Checks: '*,-abseil-string-find-str-contains,-altera-*,-android-cloexec-*,-bugprone-branch-clone,-bugprone-easily-swappable-parameters,-bugprone-macro-parentheses,-cert-dcl21-cpp,-cert-err58-cpp,-clang-analyzer-optin.cplusplus.VirtualCall,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-macro-usage,-cppcoreguidelines-non-private-member-variables-in-classes,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-vararg,-fuchsia-*,-google-runtime-references,-hicpp-avoid-c-arrays,-hicpp-invalid-access-moved,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-vararg,-llvmlibc-*,-llvm-qualified-auto,-misc-macro-parentheses,-misc-non-private-member-variables-in-classes,-misc-no-recursion,-misc-unused-parameters,-modernize-avoid-c-arrays,-modernize-make-unique,-modernize-raw-string-literal,-modernize-use-trailing-return-type,-readability-avoid-const-params-in-decls,-readability-function-cognitive-complexity,-readability-identifier-length,-readability-implicit-bool-cast,-readability-implicit-bool-conversion,-readability-magic-numbers,-readability-qualified-auto'
 #
 #  For a list of check options, see:
-#  http://clang.llvm.org/extra/clang-tidy/checks/list.html
+#  https://clang.llvm.org/extra/clang-tidy/checks/list.html
 #
 #  Disabled checks:
 #
+#  abseil-string-find-str-contains
+#    We don't want the dependency.
+#
+#  altera-*
+#    Doesn't apply.
+#
 #  android-cloexec-*
 #    O_CLOEXEC isn't available on Windows making this non-portable.
 #
+#  bugprone-branch-clone
+#    Nice idea but collides but with switch statements we'll need to use
+#    fall-throughs to fix this, which is also bad.
+#
+#  bugprone-easily-swappable-parameters
+#    Interesting test, but not something we can do much about in many places.
+#
+#  bugprone-macro-parentheses
+#    False positive in the only place where it reports something and
+#    disabling locally doesn't work.
+#
 #  cert-dcl21-cpp
 #    It is unclear whether this is still a good recommendation in modern C++.
 #
@@ -16,6 +33,22 @@ Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines
 #    Used in several singelton factory functions. I don't know of a better
 #    way to do this and it is rather unlikely that this will be a problem.
 #
+#  clang-analyzer-optin.cplusplus.VirtualCall
+#    Disable a warning we get from the Catch test framework.
+#
+#  cppcoreguidelines-avoid-c-arrays
+#    Alias for modernize-avoid-c-arrays.
+#
+#  cppcoreguidelines-avoid-magic-numbers
+#    Generally good advice, but there are too many places where this is
+#    useful, for instance in tests.
+#
+#  cppcoreguidelines-macro-usage
+#    There are cases where we actually need macros.
+#
+#  cppcoreguidelines-non-private-member-variables-in-classes
+#    Alias for misc-non-private-member-variables-in-classes
+#
 #  cppcoreguidelines-owning-memory
 #    Don't want to add dependency on gsl library.
 #
@@ -48,6 +81,9 @@ Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines
 #    This is just a matter of preference, and we can't change the interfaces
 #    now anyways.
 #
+#  hicpp-avoid-c-arrays
+#    Alias for modernize-avoid-c-arrays.
+#
 #  hicpp-invalid-access-moved
 #    Creates false positives.
 #
@@ -60,14 +96,33 @@ Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines
 #  hicpp-vararg
 #    Too strict, sometimes calling vararg functions is necessary.
 #
+#  llvm-qualified-auto
+#  readability-qualified-auto
+#    This reports too many cases. Typical case is an iterator that might be
+#    a pointer on one system but some special type on another.
+#
+#  llvmlibc-*
+#    Doesn't apply to us.
+#
 #  misc-macro-parentheses
-#    False positive in the only place where it reports something and
-#    disabling locally doesn't work.
+#    Old name for bugprone-macro-parentheses.
+#
+#  misc-non-private-member-variables-in-classes
+#    Reports this also for structs, which doesn't make any sense. There is
+#    an option "IgnoreClassesWithAllMemberVariablesBeingPublic" which should
+#    disable this, but it didn't work for me.
+#
+#  misc-no-recursion
+#    There is nothing wrong with recursion.
 #
 #  misc-unused-parameters
 #    Can't be fixed, because then Doxygen will complain. (In file
 #    include/osmium/area/problem_reporter.hpp).
 #
+#  modernize-avoid-c-arrays
+#    Makes sense for some array, but especially for char arrays using
+#    std::array isn't a good solution.
+#
 #  modernize-make-unique
 #    This is a C++11 library and C++ doesn't have std::make_unique.
 #
@@ -75,16 +130,28 @@ Checks: '*,-android-cloexec-*,-cert-dcl21-cpp,-cert-err58-cpp,-cppcoreguidelines
 #    Readability isn't that much better, arguably worse because of the new
 #    syntax.
 #
+#  modernize-use-trailing-return-type
+#    I am not quite that modern.
+#
 #  readability-avoid-const-params-in-decls
 #    This is header only library, so the declaration and implementation are
 #    often the same and we want to have the const in implementations.
 #
+#  readability-function-cognitive-complexity
+#    Sometimes the large functions are needed.
+#
+#  readability-identifier-length
+#    Too strict.
+#
 #  readability-implicit-bool-cast
 #    Old name for readability-implicit-bool-conversion.
 #
 #  readability-implicit-bool-conversion
 #    I don't think this makes the code more readable.
 #
+#  readability-magic-numbers
+#    Alias for cppcoreguidelines-avoid-magic-numbers.
+#
 #WarningsAsErrors: '*'
 HeaderFilterRegex: '\/include\/osmium\/.*'
 ...
diff --git a/third_party/libosmium/.github/FUNDING.yml b/third_party/libosmium/.github/FUNDING.yml
new file mode 100644
index 000000000..74b20fde6
--- /dev/null
+++ b/third_party/libosmium/.github/FUNDING.yml
@@ -0,0 +1 @@
+custom: "https://osmcode.org/sponsors.html"
diff --git a/third_party/libosmium/.github/ISSUE_TEMPLATE/bug-report.md b/third_party/libosmium/.github/ISSUE_TEMPLATE/bug-report.md
new file mode 100644
index 000000000..553d2f1d7
--- /dev/null
+++ b/third_party/libosmium/.github/ISSUE_TEMPLATE/bug-report.md
@@ -0,0 +1,48 @@
+---
+name: Report problems with the software
+about: You found a (possible) bug in libosmium
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## What version of libosmium are you using?
+
+<!-- Please use the [latest
+release](https://github.com/osmcode/libosmium/releases) or master if at all
+possible. -->
+
+
+## What operating system and compiler are you using?
+
+<!-- Also what Linux distribution if applicable, OS version? -->
+
+
+## Tell us something about your system
+
+<!-- How much RAM do you have, how many CPUs, bare metal or cloud setup? -->
+
+
+## What did you do exactly?
+
+<!-- Please provide the command(s) you used including all options etc. Include
+links to input files. -->
+
+
+## What did you expect to happen?
+
+<!-- Describe in detail what you expected the above would do. -->
+
+
+## What did happen instead?
+
+<!-- Please describe what happened and why you think this is wrong. Please
+include (or link to, if it is too verbose) the log output. -->
+
+
+## What did you do to try analyzing the problem?
+
+<!-- Describe what steps you already did to try analyzing the problem before
+reporting. -->
+
diff --git a/third_party/libosmium/.github/ISSUE_TEMPLATE/config.yml b/third_party/libosmium/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 000000000..af95e9080
--- /dev/null
+++ b/third_party/libosmium/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,4 @@
+contact_links:
+  - name: help.osm.org
+    url: https://help.openstreetmap.org/
+    about: Ask questions and get support from the community.
diff --git a/third_party/libosmium/.github/actions/build-windows/action.yml b/third_party/libosmium/.github/actions/build-windows/action.yml
new file mode 100644
index 000000000..1514577ad
--- /dev/null
+++ b/third_party/libosmium/.github/actions/build-windows/action.yml
@@ -0,0 +1,10 @@
+name: Windows Build
+
+runs:
+  using: composite
+  steps:
+    - name: Build
+      run: cmake --build . --config Release --verbose
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/build/action.yml b/third_party/libosmium/.github/actions/build/action.yml
new file mode 100644
index 000000000..81161d5ee
--- /dev/null
+++ b/third_party/libosmium/.github/actions/build/action.yml
@@ -0,0 +1,10 @@
+name: Build
+
+runs:
+  using: composite
+  steps:
+    - name: Build
+      run: make VERBOSE=1
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/cmake-windows/action.yml b/third_party/libosmium/.github/actions/cmake-windows/action.yml
new file mode 100644
index 000000000..1812fac8e
--- /dev/null
+++ b/third_party/libosmium/.github/actions/cmake-windows/action.yml
@@ -0,0 +1,13 @@
+name: Windows CMake
+
+runs:
+  using: composite
+  steps:
+    - name: Create build directory
+      run: mkdir build
+      shell: bash
+    - name: Configure
+      run: cmake -LA .. -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake -DBUILD_HEADERS=OFF -DBUILD_BENCHMARKS=ON -DOsmium_DEBUG=TRUE -DPROTOZERO_INCLUDE_DIR=${GITHUB_WORKSPACE}/../protozero/include
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/cmake/action.yml b/third_party/libosmium/.github/actions/cmake/action.yml
new file mode 100644
index 000000000..b0f00ba78
--- /dev/null
+++ b/third_party/libosmium/.github/actions/cmake/action.yml
@@ -0,0 +1,19 @@
+name: CMake
+
+runs:
+  using: composite
+  steps:
+    - name: Create build directory
+      run: mkdir build
+      shell: bash
+    - name: Configure
+      run: |
+        cmake -LA .. \
+              -DBUILD_DATA_TESTS=ON \
+              -DUSE_CPP_VERSION=${CPP_VERSION} \
+              -DWITH_PROJ=${WITH_PROJ} \
+              -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
+              -DPROTOZERO_INCLUDE_DIR=${GITHUB_WORKSPACE}/../protozero/include
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/ctest-windows/action.yml b/third_party/libosmium/.github/actions/ctest-windows/action.yml
new file mode 100644
index 000000000..5c56da4da
--- /dev/null
+++ b/third_party/libosmium/.github/actions/ctest-windows/action.yml
@@ -0,0 +1,10 @@
+name: Windows Test
+
+runs:
+  using: composite
+  steps:
+    - name: Test
+      run: ctest --output-on-failure -C Release
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/ctest/action.yml b/third_party/libosmium/.github/actions/ctest/action.yml
new file mode 100644
index 000000000..ae0d9bb37
--- /dev/null
+++ b/third_party/libosmium/.github/actions/ctest/action.yml
@@ -0,0 +1,10 @@
+name: ctest
+
+runs:
+  using: composite
+  steps:
+    - name: Test
+      run: ctest --output-on-failure
+      shell: bash
+      working-directory: build
+
diff --git a/third_party/libosmium/.github/actions/install-macos/action.yml b/third_party/libosmium/.github/actions/install-macos/action.yml
new file mode 100644
index 000000000..896eb723b
--- /dev/null
+++ b/third_party/libosmium/.github/actions/install-macos/action.yml
@@ -0,0 +1,13 @@
+name: Install homebrew packages on macOS
+
+runs:
+  using: composite
+  steps:
+    - name: Install packages
+      run: |
+        brew install \
+        boost \
+        gdal \
+        google-sparsehash
+      shell: bash
+
diff --git a/third_party/libosmium/.github/actions/install-protozero/action.yml b/third_party/libosmium/.github/actions/install-protozero/action.yml
new file mode 100644
index 000000000..7526c0e62
--- /dev/null
+++ b/third_party/libosmium/.github/actions/install-protozero/action.yml
@@ -0,0 +1,9 @@
+name: Install Protozero from git
+
+runs:
+  using: composite
+  steps:
+    - name: Install from git
+      run: git clone --quiet --depth 1 https://github.com/mapbox/protozero.git ../protozero
+      shell: bash
+
diff --git a/third_party/libosmium/.github/actions/install-ubuntu/action.yml b/third_party/libosmium/.github/actions/install-ubuntu/action.yml
new file mode 100644
index 000000000..b11ee3b30
--- /dev/null
+++ b/third_party/libosmium/.github/actions/install-ubuntu/action.yml
@@ -0,0 +1,23 @@
+name: Install apt packages on Ubuntu/Debian
+
+runs:
+  using: composite
+  steps:
+    - name: Install packages
+      run: |
+        sudo apt-get update -q
+        sudo apt-get install -yq \
+             doxygen \
+             libboost-dev \
+             libgdal-dev \
+             libgeos++-dev \
+             liblz4-dev \
+             libproj-dev \
+             libsparsehash-dev \
+             ruby-json \
+             spatialite-bin
+        test "$CC" = clang-6.0 && sudo apt-get install -yq --no-install-suggests --no-install-recommends clang-6.0
+        test "$CC" = clang-8   && sudo apt-get install -yq --no-install-suggests --no-install-recommends clang-8
+        test "$CC" = clang-13  && sudo apt-get install -yq --no-install-suggests --no-install-recommends clang-13
+      shell: bash
+
diff --git a/third_party/libosmium/.github/actions/install-windows/action.yml b/third_party/libosmium/.github/actions/install-windows/action.yml
new file mode 100644
index 000000000..ffe3a3c68
--- /dev/null
+++ b/third_party/libosmium/.github/actions/install-windows/action.yml
@@ -0,0 +1,17 @@
+name: Install vcpkg packages on Windows
+
+runs:
+  using: composite
+  steps:
+    - name: Install packages
+      run: |
+        vcpkg install \
+          boost-crc:x64-windows \
+          boost-variant:x64-windows \
+          bzip2:x64-windows \
+          expat:x64-windows \
+          lz4:x64-windows \
+          sparsehash:x64-windows \
+          zlib:x64-windows
+      shell: bash
+
diff --git a/third_party/libosmium/.github/workflows/ci.yml b/third_party/libosmium/.github/workflows/ci.yml
new file mode 100644
index 000000000..73f6991b9
--- /dev/null
+++ b/third_party/libosmium/.github/workflows/ci.yml
@@ -0,0 +1,316 @@
+name: CI
+
+on: [ push, pull_request ]
+
+jobs:
+
+  linux:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+    strategy:
+      fail-fast: false
+      matrix:
+        name: [Ubuntu-18, Ubuntu-20, Ubuntu-21, Debian-9, Debian-10, Debian-11, Debian-Testing, Debian-Experimental, Fedora-34]
+        build_type: [Dev]
+        cpp_compiler: [g++]
+        cpp_version: [c++11]
+        include:
+          - name: Ubuntu-18
+            # Uses gcc 7.5.0, clang 6.0.0, cmake 3.10.2
+            image: "ubuntu:18.04"
+            ubuntu: 18
+            installer: apt
+          - name: Ubuntu-20
+            # Uses gcc 9.3.0, clang 10.0.0, cmake 3.16.3
+            image: "ubuntu:20.04"
+            ubuntu: 20
+            installer: apt
+          - name: Ubuntu-21
+            # Uses gcc 10.3.0, clang, 12.0.0, cmake 3.18.4
+            image: "ubuntu:21.04"
+            ubuntu: 21
+            installer: apt
+          - name: Debian-9
+            # Uses gcc 6.3.0, clang 3.8.1, cmake 3.7.2
+            image: "debian:stretch"
+            installer: apt
+          - name: Debian-10
+            # Uses gcc 8.3.0, clang 7.0.1, cmake 3.13.4
+            image: "debian:buster"
+            installer: apt
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            cpp_version: c++17
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            cpp_version: c++20
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            c_compiler: clang
+            cpp_compiler: clang++
+            cpp_version: c++17
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            c_compiler: clang
+            cpp_compiler: clang++
+            cpp_version: c++20
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            build_type: RelWithDebInfo
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            c_compiler: clang
+            cpp_compiler: clang++
+          - name: Debian-11
+            # Uses gcc 10.2.1, clang 11.0.1, cmake 3.18.4
+            image: "debian:bullseye"
+            installer: apt
+            c_compiler: clang
+            cpp_compiler: clang++
+            CXXFLAGS: -fsanitize=address,undefined,integer -fno-sanitize-recover=all -fno-omit-frame-pointer
+            LDFLAGS: -fsanitize=address,undefined,integer
+          - name: Debian-Testing
+            # Uses gcc 10.3.0, clang 11.1.0, cmake 3.21.3
+            image: "debian:testing"
+            installer: apt
+            CXXFLAGS: -Wno-stringop-overread
+          - name: Debian-Testing
+            # Uses gcc 10.3.0, clang 11.1.0, cmake 3.21.3
+            image: "debian:testing"
+            installer: apt
+            c_compiler: clang
+            cpp_compiler: clang++
+          - name: Debian-Experimental
+            # Uses gcc 11, clang 14, cmake 3.21.3
+            image: "debian:experimental"
+            installer: apt
+            CXXFLAGS: -Wno-stringop-overread
+          - name: Debian-Experimental
+            # Uses gcc 11, clang 14, cmake 3.21.3
+            image: "debian:experimental"
+            installer: apt
+            c_compiler: clang-14
+            cpp_compiler: clang++-14
+          - name: Fedora-34
+            # Uses gcc 11.2.1, clang 12.0.1, cmake 3.20.5
+            image: "fedora:34"
+            installer: dnf
+            CXXFLAGS: -Wno-stringop-overread
+          - name: Fedora-35
+            # Uses gcc 11.2.1, clang 12.0.1, cmake 3.20.5
+            image: "fedora:35"
+            installer: dnf
+            CXXFLAGS: -Wno-stringop-overread
+    container:
+      image: ${{ matrix.image }}
+      env:
+        LANG: en_US.UTF-8
+        BUILD_TYPE: ${{ matrix.build_type }}
+        CXXFLAGS: ${{ matrix.CXXFLAGS }}
+        LDFLAGS: ${{ matrix.LDFLAGS }}
+        CC: ${{ matrix.c_compiler }}
+        CXX: ${{ matrix.cpp_compiler }}
+        CPP_VERSION: ${{ matrix.cpp_version }}
+        WITH_PROJ: ON
+    steps:
+      - name: Prepare container (apt)
+        run: |
+          export APT_LISTCHANGES_FRONTEND=none
+          export DEBIAN_FRONTEND=noninteractive
+          apt-get update -qq
+          apt-get install -y \
+            clang \
+            cmake \
+            doxygen \
+            g++ \
+            git \
+            graphviz \
+            libboost-dev \
+            libbz2-dev \
+            libexpat1-dev \
+            libgdal-dev \
+            libgeos++-dev \
+            liblz4-dev \
+            libproj-dev \
+            libsparsehash-dev \
+            make \
+            ruby \
+            ruby-json \
+            spatialite-bin \
+            zlib1g-dev
+        shell: bash
+        if: matrix.installer == 'apt'
+      - name: Install compiler
+        shell: bash
+        run: |
+          export APT_LISTCHANGES_FRONTEND=none
+          export DEBIAN_FRONTEND=noninteractive
+          apt-get install -y clang-14
+        if: matrix.cpp_compiler == 'clang++-14'
+      - name: Prepare container (dnf)
+        run: |
+          dnf install --quiet --assumeyes \
+              boost-devel \
+              bzip2-devel \
+              cmake \
+              doxygen \
+              expat-devel \
+              gcc-c++ \
+              gdal-devel \
+              gdalcpp-static \
+              geos-devel \
+              git \
+              graphviz \
+              lz4-devel \
+              make \
+              proj-devel \
+              ruby \
+              rubygem-json \
+              sparsehash-devel \
+              spatialite-tools \
+              zlib-devel
+        shell: bash
+        if: matrix.installer == 'dnf'
+      # Use v1 of checkout because v2 doesn't work with submodules
+      - uses: actions/checkout@v1
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - uses: ./.github/actions/build
+      - uses: ./.github/actions/ctest
+
+  ubuntu-latest:
+    runs-on: ubuntu-20.04
+    timeout-minutes: 40
+    env:
+      CC: clang-13
+      CXX: clang++-13
+      BUILD_TYPE: Dev
+      WITH_PROJ: ON
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - name: Install new clang
+        run: |
+          wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -
+          sudo add-apt-repository 'deb http://apt.llvm.org/focal/ llvm-toolchain-focal-13 main'
+        shell: bash
+      - uses: ./.github/actions/install-ubuntu
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - uses: ./.github/actions/build
+      - uses: ./.github/actions/ctest
+
+  macos10-dev:
+    runs-on: macos-10.15
+    timeout-minutes: 60
+    env:
+      CC: clang
+      CXX: clang++
+      BUILD_TYPE: Dev
+      WITH_PROJ: OFF
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-macos
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - uses: ./.github/actions/build
+      - uses: ./.github/actions/ctest
+
+  macos11-dev:
+    runs-on: macos-11
+    timeout-minutes: 60
+    env:
+      CC: clang
+      CXX: clang++
+      BUILD_TYPE: Dev
+      WITH_PROJ: OFF
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-macos
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - uses: ./.github/actions/build
+      - uses: ./.github/actions/ctest
+
+  macos11-release:
+    runs-on: macos-11
+    timeout-minutes: 60
+    env:
+      CC: clang
+      CXX: clang++
+      BUILD_TYPE: Release
+      WITH_PROJ: OFF
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-macos
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - uses: ./.github/actions/build
+      - uses: ./.github/actions/ctest
+
+  windows-2019-minimal:
+    runs-on: windows-2019
+    timeout-minutes: 40
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-windows
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake-windows
+      - uses: ./.github/actions/build-windows
+      - uses: ./.github/actions/ctest-windows
+
+  windows-2019-full:
+    runs-on: windows-2019
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-windows
+      - name: Install extra packages
+        run: vcpkg install geos:x64-windows gdal:x64-windows proj4:x64-windows
+        shell: bash
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake-windows
+      - uses: ./.github/actions/build-windows
+      - uses: ./.github/actions/ctest-windows
+
+  windows-2022-minimal:
+    runs-on: windows-2022
+    timeout-minutes: 40
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-windows
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake-windows
+      - uses: ./.github/actions/build-windows
+      - uses: ./.github/actions/ctest-windows
+
diff --git a/third_party/libosmium/.github/workflows/clang-tidy.yml b/third_party/libosmium/.github/workflows/clang-tidy.yml
new file mode 100644
index 000000000..4328b5e81
--- /dev/null
+++ b/third_party/libosmium/.github/workflows/clang-tidy.yml
@@ -0,0 +1,66 @@
+name: clang-tidy
+
+on: workflow_dispatch
+
+jobs:
+
+  clang-tidy:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        image: ["debian:bullseye", "debian:testing", "debian:experimental"]
+        include:
+          - image: "debian:bullseye"
+            clang: 11
+          - image: "debian:testing"
+            clang: 12
+          - image: "debian:experimental"
+            clang: 14
+    container:
+      image: ${{ matrix.image }}
+      env:
+        BUILD_TYPE: Dev
+        CC: clang-${{ matrix.clang }}
+        CXX: clang++-${{ matrix.clang }}
+        CPP_VERSION: c++11
+        WITH_PROJ: ON
+    steps:
+      - name: Prepare container (apt)
+        run: |
+          export APT_LISTCHANGES_FRONTEND=none
+          export DEBIAN_FRONTEND=noninteractive
+          apt-get update -qq
+          apt-get install -y \
+            clang-${{ matrix.clang }} \
+            clang-tidy-${{ matrix.clang }} \
+            cmake \
+            git \
+            libboost-dev \
+            libbz2-dev \
+            libexpat1-dev \
+            libgdal-dev \
+            libgeos++-dev \
+            liblz4-dev \
+            libproj-dev \
+            libsparsehash-dev \
+            make \
+            zlib1g-dev
+        shell: bash
+      # Use v1 of checkout because v2 doesn't work with submodules
+      - uses: actions/checkout@v1
+        with:
+          submodules: true
+      - uses: ./.github/actions/install-protozero
+      - uses: ./.github/actions/cmake
+      - name: clang-tidy
+        run: make clang-tidy | tee clang-tidy-${{ matrix.clang }}.log
+        shell: bash
+        working-directory: build
+      - name: Upload Log
+        uses: actions/upload-artifact@v2
+        if: always()
+        with:
+          name: clang-tidy-${{ matrix.clang }}-log
+          path: build/clang-tidy-${{ matrix.clang }}.log
+
diff --git a/third_party/libosmium/.travis.yml b/third_party/libosmium/.travis.yml
deleted file mode 100644
index bc5615d9b..000000000
--- a/third_party/libosmium/.travis.yml
+++ /dev/null
@@ -1,243 +0,0 @@
-#-----------------------------------------------------------------------------
-#
-#  Configuration for continuous integration service at travis-ci.org
-#
-#-----------------------------------------------------------------------------
-
-language: generic
-
-sudo: false
-
-dist: trusty
-
-#-----------------------------------------------------------------------------
-
-cache:
-  directories:
-    - $HOME/.ccache
-
-env:
-  global:
-    - CCACHE_TEMPDIR=/tmp/.ccache-temp
-    - CCACHE_COMPRESS=1
-    - CASHER_TIME_OUT=1000
-
-#-----------------------------------------------------------------------------
-
-# Save common build configurations as shortcuts, so we can reference them later.
-addons_shortcuts:
-  addons_clang35: &clang35
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.5']
-  addons_clang38: &clang38
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.8']
-  addons_clang39: &clang39
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-3.9']
-  addons_clang40: &clang40
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest', 'llvm-toolchain-trusty-4.0' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-4.0']
-  addons_clang50: &clang50
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest', 'llvm-toolchain-trusty-5.0' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'clang-5.0', 'g++-6', 'gcc-6']
-  addons_gcc48: &gcc48
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-4.8', 'gcc-4.8' ]
-  addons_gcc49: &gcc49
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-4.9', 'gcc-4.9' ]
-  addons_gcc5: &gcc5
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-5', 'gcc-5' ]
-  addons_gcc6: &gcc6
-    apt:
-      sources: [ 'ubuntu-toolchain-r-test', 'boost-latest' ]
-      packages: [ 'libboost1.55-all-dev', 'libgdal-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin', 'g++-6', 'gcc-6' ]
-
-#-----------------------------------------------------------------------------
-
-matrix:
-  include:
-
-    # 1/ Linux Clang Builds
-    - os: linux
-      compiler: linux-clang35-release
-      env: CC='clang-3.5' CXX='clang++-3.5' BUILD_TYPE='Release'
-      addons: *clang35
-
-    - os: linux
-      compiler: linux-clang35-dev
-      env: CC='clang-3.5' CXX='clang++-3.5' BUILD_TYPE='Dev'
-      addons: *clang35
-
-    - os: linux
-      compiler: linux-clang38-release
-      env: CC='clang-3.8' CXX='clang++-3.8' BUILD_TYPE='Release'
-      addons: *clang38
-
-    - os: linux
-      compiler: linux-clang38-dev
-      env: CC='clang-3.8' CXX='clang++-3.8' BUILD_TYPE='Dev'
-      addons: *clang38
-
-    - os: linux
-      compiler: linux-clang39-release
-      env: CC='clang-3.9' CXX='clang++-3.9' BUILD_TYPE='Release'
-      addons: *clang39
-
-    - os: linux
-      compiler: linux-clang39-dev
-      env: CC='clang-3.9' CXX='clang++-3.9' BUILD_TYPE='Dev'
-      addons: *clang39
-
-    - os: linux
-      compiler: linux-clang40-release
-      env: CC='clang-4.0' CXX='clang++-4.0' BUILD_TYPE='Release'
-      addons: *clang40
-
-    - os: linux
-      compiler: linux-clang40-dev
-      env: CC='clang-4.0' CXX='clang++-4.0' BUILD_TYPE='Dev'
-      addons: *clang40
-
-    - os: linux
-      compiler: linux-clang50-release
-      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Release'
-      addons: *clang50
-
-    - os: linux
-      compiler: linux-clang50-dev
-      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Dev'
-      addons: *clang50
-
-# Disabled because it creates false-positives on the old travis systems
-#    - os: linux
-#      compiler: linux-clang50-debug
-#      env: CC='clang-5.0' CXX='clang++-5.0' BUILD_TYPE='Debug'
-#           CXXFLAGS="-fsanitize=address,undefined,integer -fno-sanitize-recover=all -fno-omit-frame-pointer"
-#           LDFLAGS="-fsanitize=address,undefined,integer"
-#      # LSAN doesn't work on container-based system
-#      sudo: required
-#      addons: *clang50
-
-    # 2/ Linux GCC Builds
-    - os: linux
-      compiler: linux-gcc48-release
-      env: CC='gcc-4.8' CXX='g++-4.8' BUILD_TYPE='Release'
-           CXXFLAGS='-Wno-return-type'
-      addons: *gcc48
-
-    - os: linux
-      compiler: linux-gcc48-dev
-      env: CC='gcc-4.8' CXX='g++-4.8' BUILD_TYPE='Dev'
-           CXXFLAGS='-Wno-return-type'
-      addons: *gcc48
-
-    - os: linux
-      compiler: linux-gcc49-release
-      env: CC='gcc-4.9' CXX='g++-4.9' BUILD_TYPE='Release'
-      addons: *gcc49
-
-    - os: linux
-      compiler: linux-gcc49-dev
-      env: CC='gcc-4.9' CXX='g++-4.9' BUILD_TYPE='Dev'
-      addons: *gcc49
-
-    - os: linux
-      compiler: linux-gcc5-release
-      env: CC='gcc-5' CXX='g++-5' BUILD_TYPE='Release'
-      addons: *gcc5
-
-    - os: linux
-      compiler: linux-gcc5-dev
-      env: CC='gcc-5' CXX='g++-5' BUILD_TYPE='Dev'
-      addons: *gcc5
-
-    - os: linux
-      compiler: linux-gcc6-release
-      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Release'
-      addons: *gcc6
-
-    - os: linux
-      compiler: linux-gcc6-dev
-      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Dev'
-      addons: *gcc6
-
-    - os: linux
-      compiler: linux-gcc6-coverage
-      env: CC='gcc-6' CXX='g++-6' BUILD_TYPE='Coverage'
-      addons: *gcc6
-
-    # 3/ OSX Clang Builds
-    - os: osx
-      osx_image: xcode6.4
-      compiler: xcode64-clang-release
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
-
-    - os: osx
-      osx_image: xcode6.4
-      compiler: xcode64-clang-dev
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
-
-    - os: osx
-      osx_image: xcode7
-      compiler: xcode7-clang-release
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
-
-    - os: osx
-      osx_image: xcode7
-      compiler: xcode7-clang-dev
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
-
-    - os: osx
-      osx_image: xcode8.3
-      compiler: xcode8-clang-release
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Release'
-
-    - os: osx
-      osx_image: xcode8.3
-      compiler: xcode8-clang-dev
-      env: CC='clang' CXX='clang++' BUILD_TYPE='Dev'
-
-
-install:
-  - git clone --quiet --depth 1 https://github.com/mapbox/protozero.git ../protozero
-  - |
-    if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then
-      brew remove gdal
-      brew install cmake boost google-sparsehash gdal || true
-    fi
-  - cmake --version
-
-before_script:
-  - cd ${TRAVIS_BUILD_DIR}
-  - git submodule update --init
-  - mkdir build && cd build
-  - cmake -LA .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_DATA_TESTS=ON -DBUILD_WITH_CCACHE=1
-
-script:
-  - make VERBOSE=1 && ctest --output-on-failure
-
-after_success:
-  - |
-    if [ "${BUILD_TYPE}" = "Coverage" ]; then
-      curl -S -f https://codecov.io/bash -o codecov
-      chmod +x codecov
-      gcov-${CXX#g++-} -p $(find test/CMakeFiles -name '*.o')
-      ./codecov -Z -c -X gcov -F unit_tests
-      gcov-${CXX#g++-} -p $(find test/data-tests -name '*.o')
-      ./codecov -Z -c -X gcov -F data_tests
-      gcov-${CXX#g++-} -p $(find examples -name '*.o')
-      ./codecov -Z -c -X gcov -F examples
-    fi
-
-#-----------------------------------------------------------------------------
diff --git a/third_party/libosmium/.ycm_extra_conf.py b/third_party/libosmium/.ycm_extra_conf.py
index 6fc19376d..a89927357 100644
--- a/third_party/libosmium/.ycm_extra_conf.py
+++ b/third_party/libosmium/.ycm_extra_conf.py
@@ -2,7 +2,7 @@
 #
 #  Configuration for YouCompleteMe Vim plugin
 #
-#  http://valloric.github.io/YouCompleteMe/
+#  https://valloric.github.io/YouCompleteMe/
 #
 #-----------------------------------------------------------------------------
 
diff --git a/third_party/libosmium/CHANGELOG.md b/third_party/libosmium/CHANGELOG.md
index fa838f50b..1c2fd6639 100644
--- a/third_party/libosmium/CHANGELOG.md
+++ b/third_party/libosmium/CHANGELOG.md
@@ -13,6 +13,436 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 ### Fixed
 
 
+## [2.18.0] - 2022-02-07
+
+### Changed
+
+* Use `system_error` instead of `runtime_error` where it fits better.
+* Remove `OSMIUM_NORETURN` macro. This hasn't been used in a while.
+
+### Removed deprecated parts of the code
+
+Several parts of libosmium have been marked deprecated, many of them for a very
+long time. These are now removed:
+
+* Sparsehash index class `osmium::index::map::SparseMemTable` as well as the
+  complete file `osmium/index/map/sparse_mem_table.hpp`.
+* Callback functionality of the `osmium::memory::Buffer` class. The
+  `set_full_callback()` will not be available any more. See the source
+  for replacement options.
+* Various `osmium::builder::build_*` functions in
+  `osmium/builder/builder_helper.hpp`. Use `osmium::builder::add_*`
+  functions instead. Removes `builder_helper.hpp`.
+* `osmium::builder::Builder::add_item(const osmium::memory::Item* item)`.
+  Use the function of the same name taking a reference instead.
+* `osmium::builder::OSMObject/ChangesetBuilder::add_user()`. Use
+  `set_user()` instead.
+* `osmium::builder::ChangesetBuilder::bounds()` returning a modifiable
+  reference. Use `set_bounds()` instead.
+* Several functions around `osmium::io::OutputIterator`.
+* `osmium::Area::inner_ring_cbegin/cend()`, use `inner_rings()` instead.
+* `osmium::RelationMember::ref()`, use `set_ref()` instead.
+* Implicit conversion from `osmium::Timestamp` to `std::time_t`. Use
+  `seconds_since_epoch()` instead.
+* `osmium::string_to_user_id()`, use `string_to_uid` instead.
+* `osmium::static_cast_with_assert()` helper functions as well as the
+  complete include file `osmium/util/cast.hpp`.
+* Some constructors of `osmium::util::MemoryMapping` and
+  `osmium::util::TypedMemoryMapping`. Use other constructor instead.
+
+
+## [2.17.3] - 2022-01-19
+
+### Fixed
+
+* Removed possible deadlock when shutting down active Reader.
+
+
+## [2.17.2] - 2021-12-16
+
+### Changed
+
+* Libosmium now supports being compiled in C++17 and C++20 mode. The minimum
+  version required is still C++11, but if you use libosmium in an C++17 or
+  C++20 application this should work properly.
+* Switch from catch version 1 to catch2 as test framework.
+* When `std::variant` is available (C++17 and above), libosmium will use that
+  instead of `boost::variant` reducing the dependencies a little bit.
+* Removed various workaround that were needed for older MSVC compilers.
+* Remove use of `boost::filter_iterator` and `boost::indirect_iterator`. The
+  removes the dependency on Boost Iterator.
+* Examples now mostly use the somewhat cleaner `return` instead of
+  `std::exit()` to return an exit code from `main`.
+* As always: Various small code cleanups.
+
+### Fixed
+
+* When ordering OSM objects (mostly use in the `CheckOrder` handler), the
+  smallest id possible (`INTMIN`) wasn't sorted correctly.
+* Threading problem when reading files.
+* Possible dereference of invalid iterator in legacy area assembler. This
+  only affects the legacy area assembler that takes old-style multipolygons
+  into account, so modern code that is not working with history data is not
+  affected.
+* Fixed read from an empty queue when reading a file which could block
+  libosmium forever when an error was encountered while reading a file.
+
+### Deprecated
+
+Several parts of libosmium have been marked deprecated, many of them for a very
+long time. These will not be part of the next version of libosmium:
+
+* Sparsehash index class `osmium::index::map::SparseMemTable` as well as the
+  complete file `osmium/index/map/sparse_mem_table.hpp`.
+* Callback functionality of the `osmium::memory::Buffer` class. The
+  `set_full_callback()` will not be available any more. See the source
+  for replacement options.
+* Various `osmium::builder::build_*` functions in
+  `osmium/builder/builder_helper.hpp`. Use `osmium::builder::add_*`
+  functions instead. Removes `builder_helper.hpp`.
+* `osmium::builder::Builder::add_item(const osmium::memory::Item* item)`.
+  Use the function of the same name taking a reference instead.
+* `osmium::builder::OSMObject/ChangesetBuilder::add_user()`. Use
+  `set_user()` instead.
+* `osmium::builder::ChangesetBuilder::bounds()` returning a modifiable
+  reference. Use `set_bounds()` instead.
+* Several functions around `osmium::io::OutputIterator`.
+* `osmium::Area::inner_ring_cbegin/cend()`, use `inner_rings()` instead.
+* `osmium::RelationMember::ref()`, use `set_ref()` instead.
+* Implicit conversion from `osmium::Timestamp` to `std::time_t`. Use
+  `seconds_since_epoch()` instead.
+* `osmium::string_to_user_id()`, use `string_to_uid` instead.
+* `osmium::static_cast_with_assert()` helper functions as well as the
+  complete include file `osmium/util/cast.hpp`.
+* Some constructors of `osmium::util::MemoryMapping` and
+  `osmium::util::TypedMemoryMapping`. Use other constructor instead.
+
+
+## [2.17.1] - 2021-10-05
+
+### Added
+
+* Add `osmium_tags_filter` example showing use of tags filter.
+* Add `Writer::set_header()` function to set header after constructing.
+
+### Changed
+
+* Various improvements in PBF file reading make it slightly faster and less
+  CPU intensive.
+* Since 2.17.0 Osmium will, when reading files, tell the kernel using
+  `fadvise` that it can remove pages from the buffer cache that are not
+  needed any more. This is usually beneficial, because the memory can be used
+  for something else. But if you are reading the same OSM file multiple times
+  at the same time or in short succession, it might be better to keep those
+  buffer pages. In that case you can set the environment variable
+  `OSMIUM_CLEAN_PAGE_CACHE_AFTER_READ` to `no` and Osmium will not call
+  `fadvise`. Set it to `yes` or anything else (or not set it at all) to get
+  the default behaviour.
+* If the macro `OSMIUM_DEFINE_EXPORT` is defined, all exception classes used
+  by Osmium will get "tagged as exported" using `__declspec(dllexport)` when
+  using MSVC or `__attribute__ ((visibility("default")))` on other compilers.
+  This is needed in PyOsmium.
+
+### Fixed
+
+* Fix integer parser. IDs in OPL files can now be anything between -2^63 and
+  2^63-1.
+
+
+## [2.17.0] - 2021-04-26
+
+### Added
+
+* Add "ids" output format. New IDS output format that is similar to
+  the OPL format, but only the entity type and id is written out.
+* Add convenience functions `left()`, `right()`, `top()`, `bottom()` to
+  access `osmium::Box` boundaries.
+* Add polygon output to WKB factory.
+* Add functions to access storage from `node_locations_for_ways`
+  handler.
+* Add flag `osmium::io::buffers_type` for telling the `Reader` class whether
+  you want buffers read to only contain a single type of OSM entity.
+* Add convenient named `nodes()`, `ways()`, and `relations()` accessor
+  functions to `nwr_array` class.
+* Add `DeltaDecode::value()` accessor function.
+* Add variant of the `Buffer::purge_removed()` function which doesn't take
+  a callback parameter.
+
+### Changed
+
+* Different varint decoding for faster PBF decoding. This makes PBF
+  decoding about 15% faster.
+* Several code optimmizations in (PBF) writer code that speed up
+  writing of OSM files considerably while using less CPU and spreading
+  the load on multiple CPUs.
+* Use memset/memcpy instead of `std::fill_n` and `std::copy` in object
+  builder for some slight speedups.
+* Ignore metadata setting on reader for history/change files. History
+  and change files must be read with metadata, because otherwise the
+  information is lost whether an object is visible or deleted. So
+  ignore this setting in that case.
+* On Linux: Use fadvise() to tell kernel about our reading patterns:
+  1. Tell kernel that we are reading OSM files sequentially. This
+     should improve pre-fetching of data blocks.
+  2. Tell kernel that we are done with block so they can be released.
+     This means we don't hog the buffer cache for something that
+     will, in all likelyhood, not be needed any more.
+* Use assert() instead of exception in "can not happen" situation in
+  the relations manager code.
+* Various code cleanups.
+
+### Fixed
+
+* Test failure with `add_tag_list` on some systems.
+* Test framework fix for aarch64 architecture.
+* Remove undefined behaviour in bzip2 compression code.
+* Rename some local variables to not shadow member functions.
+* Wrap `osmium::util::MemoryMapping::unmap()` in try/catch on Windows
+  also because we call this from a noexcept function.
+* Removed superfluous `std::forward`s and fixed code that called
+  `std::forward` multiple times on the same object.
+* Fix in OPL parser which could lead to invalid data being generated.
+* Fixed three bugs in O5M parser which could lead to an infinit loop
+  or segmentation faults.
+
+## [2.16.0] - 2021-01-08
+
+### Added
+
+* The PBF reader and writer now understand PBF blobs compressed with the LZ4
+  compression algorithm in addition to the usual ZLIB compression (or no
+  compression at all). LZ4 is much faster to compress and uncompress. Use
+  by setting the `pbf_compression` output file format option to `lz4`. You
+  have to define `OSMIUM_WITH_LZ4` to enable this before including any
+  libosmium includes.
+* The function `osmium::io::supported_pbf_compression_types` can now be used
+  to get a list of all PBF compression types supported.
+* The output file option `pbf_compression_level` can now be set to an integer.
+  The range depends on the compression type used, 0-9 for zlib compression
+  and 1-65537 for lz4 compression.
+* Adds `ptr_begin()`/`ptr_end()` functions to `ObjectPointerCollection` for
+  accessing the pointers instead of the underlying objects.
+
+### Changed
+
+* The `osmium::io::Writer::close()` function now returns the number of bytes
+  written to an OSM file if it is available (and 0 otherwise).
+* Use stable sort when sorting `ObjectPointerCollection`.
+
+### Fixed
+
+* Various small fixes and cleanups.
+
+
+## [2.15.6] - 2020-06-27
+
+### Added
+
+* Add `IdSetSmall::merge_sorted` function.
+
+### Changed
+
+* Little optimization for IdSetSmall: Don't add the same id twice in a row.
+
+### Fixed
+
+* Do not build areas with "recursion depth > 20". This happens when there
+  are complex multipolygon with many rings touching in single points. This
+  is a quick fix that hopefully keeps us going until we find a better
+  solution.
+
+## [2.15.5] - 2020-04-21
+
+### Added
+
+* Additional constructor for `builder::attr::member_type(_string)` taking
+  char type making it even easier to generate test data.
+* Allow single C string or `std::string` as argument for `builder::attr::_tag`.
+  Must contain key and value separated by the equal sign.
+* New `builder::attr::_t()` function to set tags from comma-separated string.
+* New `nwr_array` iterator.
+* Support for the PROJ library has now been declared deprecated. The old
+  PROJ API (up to version PROJ 6) is currently still available, but will
+  be removed in a future version. Support for the new PROJ API will not be
+  in libosmium. See https://github.com/osmcode/osmium-proj for some code
+  that might help you if you need this.
+
+### Changed
+
+* Check how much space is available in file system before resizing memory
+  mapped file (not on Windows). This means we can, at least in some cases,
+  show an error message instead of crashing the program.
+
+### Fixed
+
+* Parsing coordinates in PBF files did not work correctly if an lat/lon
+  offset was specified (which almost never happens).
+* Make OPL parser more strict: Attributes can only be specified once.
+* Do not close stdout after writing OSM file to it.
+
+## [2.15.4] - 2019-11-28
+
+### Added
+
+* Add osmium::Options::empty() for consistency with STL containers.
+
+### Fixed
+
+* Massive reduction of memory consumption in area assembly code. For some
+  very complex polygons memory usage can drop from multiple gigabytes to just
+  megabytes.
+
+## [2.15.3] - 2019-09-16
+
+### Added
+
+* New header option "sorting" when reading and writing PBFs. If the header
+  option "sorting" is set to `Type_then_ID`, the optional header property
+  `Sort.Type_then_ID` is set on writing to PBF files. When reading PBF files
+  with this header property, the "sorting" header option is set accordingly.
+
+### Fixed
+
+* Do not propagate C++ exception through C code. We are using the Expat
+  XML parser, a C library. It calls callbacks in our code. When those
+  callbacks throw, the exception was propagated through the C code. This
+  did work in the tests, but that behaviour isn't guaranteed (C++
+  standard says it is implementation defined). This fixes it by catching
+  the exception and rethrowing it later.
+
+## [2.15.2] - 2019-08-16
+
+### Added
+
+* Instead of handler classes, the `apply` function can now also take
+  lambdas (or objects from classes implementing `operator()`).
+* Add swap, copy constructor and assignment operator to IdSetDense.
+
+### Changed
+
+* Enable use of the old proj API in proj version 6. This is a stopgap
+  solution until we find a better one.
+* Better error messages when there is an error parsing a timestamp.
+* Cleaned up a lot of code based on clang-tidy warnings.
+* Ignore <bbox> or <bounds> subelement of <way> or <relation>. <bounds>
+  elements are created by Overpass API as subelements of ways or relations
+  when the "out bb" format is used. <bbox> subelements turn up in files
+  downloaded from http://download.openstreetmap.fr/replication . Libosmium
+  used to throw an error  like "Unknown element in <way>: bbox". With this
+  commit, these subelements are ignored, ie. there is no error any more,
+  but the data is not read.
+* Add swap, copy constructor and assignment operator to IdSetDense.
+* Update included catch.hpp to 1.12.2.
+* Retire use of `OSMIUM_NORETURN` macro. Use `[[noreturn]]` instead.
+
+### Fixed
+
+* Do not build areas with more than 100 locations where rings touch.
+  Places where rings touch are unusual for normal multipolygons and the
+  algorithm in libosmium that assembles multipolygons does not handle
+  them well. If there are too many touching points it becomes very slow.
+  This is not a problem for almost all multipolygons. As I am writing
+  this there are only three relations in the OSM database with more than
+  100 touching points, all of them rather weird boundaries in the US.
+  With this commit libosmium will simply ignore those areas to keep the
+  processing speed within reasonable bounds.
+
+
+## [2.15.1] - 2019-02-26
+
+### Added
+
+* More tests.
+* CMake config: also find clang-tidy-7.
+
+### Changed
+
+* Example and benchmark programs now don't crash with exceptions any more
+  but report them properly.
+
+### Fixed
+
+* Compile with NDEBUG in RelWithDebInfo mode.
+* Correctly throw exception in `multimap::dump_as_list()`.
+* Integer truncation on 32 bit systems in `MemoryUsage`.
+* Exception specification on some functions.
+* Forwarding references that might have hidden copy/move constructors.
+
+
+## [2.15.0] - 2018-12-07
+
+### Added
+
+* Function `dump_as_array()` to dump sparse array indexes.
+* Set the `xml_josm_upload` header option when reading XML files.
+* New function `OSMObject::remove_tags()` marks tags on OSM objects as
+  removed.
+* More tests.
+
+### Changed
+
+* When reading OSM files Libosmium now has less memory overhead, especially
+  when reading PBF files. This works by using more, but smaller buffers.
+* The `TagsFilter` class is now based on the `TagsFilterBase` template
+  class which allows setting the result type. This allows the filter to
+  return more data depending on the rule that matched.
+* Use enums for many constants instead of (static) const(expr) variables.
+* Make `chunk_bits` in `IdSetDense` configurable.
+* Hardcode `%lld` format instead of using `<cinttypes>` PRI macro.
+* Update included gdalcpp to version 1.2.0.
+
+### Fixed
+
+* The gzip/bzip2 compression code was overhauled and is better tested now.
+  This fixes some bugs on Windows.
+
+
+## [2.14.2] - 2018-07-23
+
+### Fixed
+
+* PBF reader and writer depended on byte order of system architecture.
+* Removed an unreliable test that didn't work on some architectures.
+
+
+## [2.14.1] - 2018-07-23
+
+### Changed
+
+* Libosmium now needs the newest Protozero version 1.6.3.
+* Removes dependency on the utfcpp library for conversions between Unicode
+  code points and UTF-8. We have our own functions for this now. This also
+  gives us more control on where errors are thrown in this code.
+* Add support for using the CRC32 implementation from the zlib library in
+  addition to the one from Boost. It is significantly faster and means we
+  have one less dependency, because zlib is needed anyway in almost all
+  programs using Osmium due to its use in the PBF format. Set macro
+  `OSMIUM_TEST_CRC_USE_BOOST` before compiling the tests, if you want to
+  run the tests with the boost library code, otherwise it will use the
+  zlib code. Note that to use this you have to change your software slightly,
+  see the documentation of the `CRC_zlib` class for details.
+* Add a `clear_user()` function to OSMObject and Changeset which allows
+  removing the user name of an entity without re-creating it in a new buffer.
+* In Osmium the 0 value of the Timestamp is used to denote the "invalid"
+  Timestamp, and its output using the `to_iso()` function is the empty
+  string. But this is the wrong output for OSM XML files, where a
+  timestamp that's not set should still be output as
+  1970-01-01T00:00:00Z. This version introduces a new `to_is_all()`
+  function which will do this and uses that function in the XML writer.
+* Use `protozero::byteswap_inplace` instead of `htonl`/`ntohl`. Makes the
+  code simpler and also works on Windows.
+* Marked `MultipolygonCollector` class as deprecated. Use the
+  `MultipolygonManager` class introduced in 2.13.0 instead.
+* Lots of code cleanups especially around `assert`s. Libosmium checks out
+  clean with `clang-tidy` now. Some documentation updates.
+
+### Fixed
+
+* Fix compilation error when `fileno()` is a macro (as in OpenBSD 6.3).
+* Make `Box` output consistent with the output of a single `Location`
+  and avoids problems with some locales.
+
+
 ## [2.14.0] - 2018-03-31
 
 ### Added
@@ -823,7 +1253,22 @@ This project adheres to [Semantic Versioning](https://semver.org/).
   Doxygen (up to version 1.8.8). This version contains a workaround to fix
   this.
 
-[unreleased]: https://github.com/osmcode/libosmium/compare/v2.14.0...HEAD
+[unreleased]: https://github.com/osmcode/libosmium/compare/v2.18.0...HEAD
+[2.18.0]: https://github.com/osmcode/libosmium/compare/v2.17.3...v2.18.0
+[2.17.3]: https://github.com/osmcode/libosmium/compare/v2.17.2...v2.17.3
+[2.17.2]: https://github.com/osmcode/libosmium/compare/v2.17.1...v2.17.2
+[2.17.1]: https://github.com/osmcode/libosmium/compare/v2.17.0...v2.17.1
+[2.17.0]: https://github.com/osmcode/libosmium/compare/v2.16.0...v2.17.0
+[2.16.0]: https://github.com/osmcode/libosmium/compare/v2.15.6...v2.16.0
+[2.15.6]: https://github.com/osmcode/libosmium/compare/v2.15.5...v2.15.6
+[2.15.5]: https://github.com/osmcode/libosmium/compare/v2.15.4...v2.15.5
+[2.15.4]: https://github.com/osmcode/libosmium/compare/v2.15.3...v2.15.4
+[2.15.3]: https://github.com/osmcode/libosmium/compare/v2.15.2...v2.15.3
+[2.15.2]: https://github.com/osmcode/libosmium/compare/v2.15.1...v2.15.2
+[2.15.1]: https://github.com/osmcode/libosmium/compare/v2.15.0...v2.15.1
+[2.15.0]: https://github.com/osmcode/libosmium/compare/v2.14.2...v2.15.0
+[2.14.2]: https://github.com/osmcode/libosmium/compare/v2.14.1...v2.14.2
+[2.14.1]: https://github.com/osmcode/libosmium/compare/v2.14.0...v2.14.1
 [2.14.0]: https://github.com/osmcode/libosmium/compare/v2.13.1...v2.14.0
 [2.13.1]: https://github.com/osmcode/libosmium/compare/v2.13.0...v2.13.1
 [2.13.0]: https://github.com/osmcode/libosmium/compare/v2.12.2...v2.13.0
diff --git a/third_party/libosmium/CMakeLists.txt b/third_party/libosmium/CMakeLists.txt
index a8409133f..11d756692 100644
--- a/third_party/libosmium/CMakeLists.txt
+++ b/third_party/libosmium/CMakeLists.txt
@@ -6,25 +6,40 @@
 #
 #-----------------------------------------------------------------------------
 
-cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
+cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
 
+#-----------------------------------------------------------------------------
+#
+#  Configurations
+#
+#-----------------------------------------------------------------------------
+
+set(CMAKE_CXX_FLAGS_COVERAGE
+    "-g -O0 -fno-inline-functions -fno-inline --coverage ${extra_coverage_flags_}"
+    CACHE STRING "Flags used by the compiler during coverage builds.")
+
+set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
+    "--coverage"
+    CACHE STRING "Flags used by the linker during coverage builds.")
+
+set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel;Dev;Coverage"
+    CACHE STRING
+    "List of available configuration types"
+    FORCE)
+
+
 #-----------------------------------------------------------------------------
 #
 #  Project version
 #
 #-----------------------------------------------------------------------------
 
-set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel;Dev;Coverage"
-    CACHE STRING
-    "List of available configuration types"
-    FORCE)
-
 project(libosmium)
 
 set(LIBOSMIUM_VERSION_MAJOR 2)
-set(LIBOSMIUM_VERSION_MINOR 14)
+set(LIBOSMIUM_VERSION_MINOR 18)
 set(LIBOSMIUM_VERSION_PATCH 0)
 
 set(LIBOSMIUM_VERSION
@@ -62,10 +77,11 @@ option(BUILD_BENCHMARKS "compile benchmark programs" ${dev_build})
 option(BUILD_DATA_TESTS "compile data tests, please run them with ctest" ${data_test_build})
 
 option(INSTALL_GDALCPP   "also install gdalcpp headers" OFF)
-option(INSTALL_UTFCPP    "also install utfcpp headers" OFF)
 
 option(WITH_PROFILING    "add flags needed for profiling" OFF)
 
+option(WITH_PROJ         "build/test with proj" ON)
+
 
 #-----------------------------------------------------------------------------
 #
@@ -101,14 +117,6 @@ endif()
 #    set(extra_coverage_flags_ "-fkeep-inline-functions")
 #endif()
 
-set(CMAKE_CXX_FLAGS_COVERAGE
-    "-g -O0 -fno-inline-functions -fno-inline --coverage ${extra_coverage_flags_}"
-    CACHE STRING "Flags used by the compiler during coverage builds.")
-
-set(CMAKE_EXE_LINKER_FLAGS_COVERAGE
-    "--coverage"
-    CACHE STRING "Flags used by the linker during coverage builds.")
-
 if(CMAKE_BUILD_TYPE STREQUAL "Coverage")
     if(BUILD_EXAMPLES OR BUILD_HEADERS OR BUILD_BENCHMARKS)
         message(WARNING "Coverage builds don't work for anything but the tests")
@@ -161,7 +169,11 @@ set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 include_directories(${OSMIUM_INCLUDE_DIR})
 
-find_package(Osmium COMPONENTS io gdal geos proj sparsehash)
+if(WITH_PROJ)
+    find_package(Osmium COMPONENTS lz4 io gdal geos proj)
+else()
+    find_package(Osmium COMPONENTS lz4 io gdal geos)
+endif()
 
 # The find_package put the directory where it found the libosmium includes
 # into OSMIUM_INCLUDE_DIRS. We remove it again, because we want to make
@@ -200,11 +212,13 @@ endif()
 #
 #-----------------------------------------------------------------------------
 if(MSVC)
-    set(USUAL_COMPILE_OPTIONS "/Ox")
+    set(DEV_COMPILE_OPTIONS "/Ox")
+    set(RWD_COMPILE_OPTIONS "/Ox /DNDEBUG")
     # do not show warnings caused by missing .pdb files for libraries
     set(USUAL_LINK_OPTIONS "/debug /ignore:4099")
 else()
-    set(USUAL_COMPILE_OPTIONS "-O3 -g")
+    set(DEV_COMPILE_OPTIONS "-O3 -g")
+    set(RWD_COMPILE_OPTIONS "-O3 -g -DNDEBUG")
     set(USUAL_LINK_OPTIONS "")
 endif()
 
@@ -212,7 +226,7 @@ if(WIN32)
     add_definitions(-DWIN32 -D_WIN32 -DMSWIN32 -DBGDWIN32)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEV "${USUAL_COMPILE_OPTIONS}"
+set(CMAKE_CXX_FLAGS_DEV "${DEV_COMPILE_OPTIONS}"
     CACHE STRING "Flags used by the compiler during developer builds."
     FORCE)
 
@@ -224,7 +238,7 @@ mark_as_advanced(
     CMAKE_EXE_LINKER_FLAGS_DEV
 )
 
-set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${USUAL_COMPILE_OPTIONS}"
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${RWD_COMPILE_OPTIONS}"
     CACHE STRING "Flags used by the compiler during RELWITHDEBINFO builds."
     FORCE)
 
@@ -318,9 +332,6 @@ if(CPPCHECK)
         --force
         -Uassert -DPROTOZERO_STRICT_API -DPROTOZERO_USE_BUILTIN_BSWAP -UPROTOZERO_USE_VIEW)
 
-    # cpp doesn't find system includes for some reason, suppress that report
-    set(CPPCHECK_OPTIONS ${CPPCHECK_OPTIONS} --suppress=missingIncludeSystem)
-
     file(GLOB_RECURSE ALL_INCLUDES   include/osmium/*.hpp)
     file(GLOB         ALL_EXAMPLES   examples/*.cpp)
     file(GLOB         ALL_BENCHMARKS benchmarks/*.cpp)
@@ -390,14 +401,14 @@ if(BUILD_HEADERS)
     file(MAKE_DIRECTORY header_check)
 
     foreach(hpp ${ALL_HPPS})
-        if(GDAL_FOUND OR NOT ((hpp STREQUAL "osmium/area/problem_reporter_ogr.hpp") OR (hpp STREQUAL "osmium/geom/ogr.hpp")))
+        if((GDAL_FOUND AND PROJ_FOUND) OR NOT ((hpp STREQUAL "osmium/area/problem_reporter_ogr.hpp") OR (hpp STREQUAL "osmium/geom/ogr.hpp") OR (hpp STREQUAL "osmium/geom/projection.hpp")))
             string(REPLACE ".hpp" "" tmp ${hpp})
             string(REPLACE "/" "__" libname ${tmp})
 
             # Create a dummy .cpp file that includes the header file we want to
             # check.
             set(DUMMYCPP ${CMAKE_BINARY_DIR}/header_check/${libname}.cpp)
-            file(WRITE ${DUMMYCPP} "#include <${hpp}> // IWYU pragma: keep\n")
+            file(WRITE ${DUMMYCPP} "#define OSMIUM_UTIL_COMPATIBILITY_HPP\n#define OSMIUM_DEPRECATED\n#define OSMIUM_EXPORT\n#include <${hpp}> // IWYU pragma: keep\n")
 
             # There is no way in CMake to just compile but not link a C++ file,
             # so we pretend to build a library here.
@@ -416,7 +427,7 @@ endif()
 #
 #-----------------------------------------------------------------------------
 message(STATUS "Looking for clang-tidy")
-find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-6.0 clang-tidy-5.0)
+find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-14 clang-tidy-13 clang-tidy-12 clang-tidy-11)
 
 if(CLANG_TIDY)
     message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}")
@@ -459,6 +470,7 @@ if(CLANG_TIDY)
     add_custom_target(clang-tidy
         ${CLANG_TIDY}
         -p ${CMAKE_BINARY_DIR}
+        "-extra-arg=-Wno-#pragma-messages"
         ${CT_CHECK_FILES}
     )
 else()
@@ -480,11 +492,6 @@ if(INSTALL_GDALCPP)
     install(FILES include/gdalcpp.hpp DESTINATION include)
 endif()
 
-if(INSTALL_UTFCPP)
-    install(FILES include/utf8.h DESTINATION include)
-    install(DIRECTORY include/utf8 DESTINATION include)
-endif()
-
 
 #-----------------------------------------------------------------------------
 #
diff --git a/third_party/libosmium/NOTES_FOR_DEVELOPERS.md b/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
index 7ffca5ec5..9bc9a5004 100644
--- a/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
+++ b/third_party/libosmium/NOTES_FOR_DEVELOPERS.md
@@ -89,11 +89,11 @@ between compilers due to different C++11 support.
 
 ## Operating systems
 
-Usually all code must work on Linux, OSX, and Windows. Execptions are allowed
+Usually all code must work on Linux, macOS, and Windows. Execptions are allowed
 for some minor functionality, but please discuss this first.
 
 When writing code and tests, care must be taken that everything works with the
-CR line ending convention used on Linux and OSX and the CRLF line ending used
+CR line ending convention used on Linux and macOS and the CRLF line ending used
 on Windows. Note that `git` can be run with different settings regarding line
 ending rewritings on different machines making things more difficult. Some
 files have been "forced" to LF line endings using `.gitattributes` files.
@@ -136,15 +136,8 @@ directory, some data tests in `test/osm-testdata` and tests of the examples in
 `test/examples`. They are built by the default cmake config. Run `ctest` to
 run them. We can always use more tests.
 
-Tests are run automatically using the Travis (Linux/Mac) and Appveyor (Windows)
-services. We automatically create coverage reports on Codevoc.io. Note that
-the coverage percentages reported are not always accurate, because code that
-is not used in tests at all will not necessarily end up in the binary and
-the code coverage tool will not know it is there.
-
-[![Travis Build Status](https://secure.travis-ci.org/osmcode/libosmium.svg)](https://travis-ci.org/osmcode/libosmium)
-[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/osmcode/libosmium?svg=true)](https://ci.appveyor.com/project/Mapbox/libosmium)
-[![Coverage Status](https://codecov.io/gh/osmcode/libosmium/branch/master/graph/badge.svg)](https://codecov.io/gh/osmcode/libosmium)
+Tests are run automatically using Github Actions (Linux/macOS) and Appveyor
+(Windows) services.
 
 
 ## Documenting the code
diff --git a/third_party/libosmium/README.md b/third_party/libosmium/README.md
index 91d8f507c..7430673d0 100644
--- a/third_party/libosmium/README.md
+++ b/third_party/libosmium/README.md
@@ -1,17 +1,17 @@
 # Libosmium
 
-http://osmcode.org/libosmium
+https://osmcode.org/libosmium
 
 A fast and flexible C++ library for working with OpenStreetMap data.
 
-Libosmium works on Linux, Mac OSX and Windows.
+Libosmium works on Linux, macOS and Windows.
 
-[![Travis Build Status](https://secure.travis-ci.org/osmcode/libosmium.svg)](https://travis-ci.org/osmcode/libosmium)
-[![Appveyor Build Status](https://ci.appveyor.com/api/projects/status/github/osmcode/libosmium?svg=true)](https://ci.appveyor.com/project/Mapbox/libosmium)
+[![Github Build Status](https://github.com/osmcode/libosmium/workflows/CI/badge.svg?branch=master)](https://github.com/osmcode/libosmium/actions)
+[![Appveyor Build status](https://ci.appveyor.com/api/projects/status/yy099a4vxcb604rn/branch/master?svg=true)](https://ci.appveyor.com/project/lonvia/libosmium-eq41p/branch/master)
 [![Coverage Status](https://codecov.io/gh/osmcode/libosmium/branch/master/graph/badge.svg)](https://codecov.io/gh/osmcode/libosmium)
 [![Packaging status](https://repology.org/badge/tiny-repos/libosmium.svg)](https://repology.org/metapackage/libosmium)
 
-Please see the [Libosmium manual](http://osmcode.org/libosmium/manual.html)
+Please see the [Libosmium manual](https://osmcode.org/libosmium/manual.html)
 for more details than this README can provide.
 
 
@@ -26,13 +26,12 @@ different libraries. You DO NOT NEED to install all of them, just install those
 you need for your programs.
 
 For details see the [list of
-dependencies](http://osmcode.org/libosmium/manual.html#dependencies) in the
+dependencies](https://osmcode.org/libosmium/manual.html#dependencies) in the
 manual.
 
 The following external (header-only) libraries are included in the libosmium
 repository:
 * [gdalcpp](https://github.com/joto/gdalcpp)
-* [utfcpp](http://utfcpp.sourceforge.net/)
 
 Note that [protozero](https://github.com/mapbox/protozero) was included in
 earlier versions of libosmium, but isn't any more.
@@ -69,8 +68,8 @@ cmake:
 
 This will build the examples and tests. Call `ctest` to run the tests.
 
-For more detals see the
-[Building Libosmium](http://osmcode.org/libosmium/manual.html#building-libosmium)
+For more details see the
+[Building Libosmium](https://osmcode.org/libosmium/manual.html#building-libosmium)
 chapter in the manual.
 
 
@@ -85,7 +84,7 @@ git submodule update --init
 This will enable additional tests.
 
 See the
-[Libosmium Manual](http://osmcode.org/libosmium/manual.html#running-tests)
+[Libosmium Manual](https://osmcode.org/libosmium/manual.html#running-tests)
 for instructions.
 
 
@@ -93,12 +92,12 @@ for instructions.
 
 If you have been using the old version of Osmium at
 https://github.com/joto/osmium you might want to read about the [changes
-needed](http://osmcode.org/libosmium/manual.html#changes-from-old-versions-of-osmium).
+needed](https://osmcode.org/libosmium/manual.html#changes-from-old-versions-of-osmium).
 
 
 ## License
 
-Libosmium is available under the Boost Software License. See LICENSE.txt.
+Libosmium is available under the Boost Software License. See LICENSE.
 
 
 ## Authors
diff --git a/third_party/libosmium/appveyor.yml b/third_party/libosmium/appveyor.yml
index 2ac3e2546..a05590b05 100644
--- a/third_party/libosmium/appveyor.yml
+++ b/third_party/libosmium/appveyor.yml
@@ -4,25 +4,29 @@
 #
 #-----------------------------------------------------------------------------
 
-environment:
-  matrix:
-  - config: MSYS2
-    autocrlf: true
-  - config: Debug
-    autocrlf: true
-  - config: Release
-    autocrlf: true
-  - config: Debug
-    autocrlf: false
-  - config: Release
-    autocrlf: false
+image: Visual Studio 2017
+
+platform: x64
 
 clone_depth: 1
 
-# Operating system (build VM template)
-os: Visual Studio 2015
+#-----------------------------------------------------------------------------
 
-platform: x64
+environment:
+  matrix:
+  - config: Debug
+    autocrlf: true
+  - config: Release
+    autocrlf: true
+  - config: Debug
+    autocrlf: false
+  - config: Release
+    autocrlf: false
+  - config: MSYS2
+    autocrlf: true
+    APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+
+#-----------------------------------------------------------------------------
 
 # scripts that are called at very beginning, before repo cloning
 init:
@@ -54,6 +58,6 @@ build_script:
 
 # remove garbage VS messages
 # https://help.appveyor.com/discussions/problems/4569-the-target-_convertpdbfiles-listed-in-a-beforetargets-attribute-at-c-does-not-exist-in-the-project-and-will-be-ignored
-before_build:
-  - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
+#before_build:
+#  - del "C:\Program Files (x86)\MSBuild\14.0\Microsoft.Common.targets\ImportAfter\Xamarin.Common.targets"
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
index 65051b0f9..14aab4342 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_count.cpp
@@ -36,19 +36,26 @@ struct CountHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
+    try {
+        const std::string input_filename{argv[1]};
 
-    osmium::io::Reader reader{input_filename};
+        osmium::io::Reader reader{input_filename};
 
-    CountHandler handler;
-    osmium::apply(reader, handler);
-    reader.close();
+        CountHandler handler;
+        osmium::apply(reader, handler);
+        reader.close();
 
-    std::cout << "Nodes: "     << handler.nodes     << '\n';
-    std::cout << "Ways: "      << handler.ways      << '\n';
-    std::cout << "Relations: " << handler.relations << '\n';
+        std::cout << "Nodes: "     << handler.nodes     << '\n';
+        std::cout << "Ways: "      << handler.ways      << '\n';
+        std::cout << "Relations: " << handler.relations << '\n';
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
index 12d5c8201..e3d303ce9 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_count_tag.cpp
@@ -39,17 +39,24 @@ struct CountHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
+    try {
+        const std::string input_filename{argv[1]};
 
-    osmium::io::Reader reader{input_filename};
+        osmium::io::Reader reader{input_filename};
 
-    CountHandler handler;
-    osmium::apply(reader, handler);
-    reader.close();
+        CountHandler handler;
+        osmium::apply(reader, handler);
+        reader.close();
 
-    std::cout << "r_all=" << handler.all << " r_counter=" << handler.counter << '\n';
+        std::cout << "r_all=" << handler.all << " r_counter=" << handler.counter << '\n';
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
index e89898246..70fe210da 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_index_map.cpp
@@ -21,20 +21,27 @@ using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE FORMAT\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
-    const std::string location_store{argv[2]};
+    try {
+        const std::string input_filename{argv[1]};
+        const std::string location_store{argv[2]};
 
-    osmium::io::Reader reader{input_filename};
+        osmium::io::Reader reader{input_filename};
 
-    const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
-    std::unique_ptr<index_type> index = map_factory.create_map(location_store);
-    location_handler_type location_handler{*index};
-    location_handler.ignore_errors();
+        const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
+        std::unique_ptr<index_type> index = map_factory.create_map(location_store);
+        location_handler_type location_handler{*index};
+        location_handler.ignore_errors();
 
-    osmium::apply(reader, location_handler);
-    reader.close();
+        osmium::apply(reader, location_handler);
+        reader.close();
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
index f9672c305..153b047e0 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_mercator.cpp
@@ -28,15 +28,22 @@ struct GeomHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
+    try {
+        const std::string input_filename{argv[1]};
 
-    osmium::io::Reader reader{input_filename};
+        osmium::io::Reader reader{input_filename};
 
-    GeomHandler handler;
-    osmium::apply(reader, handler);
-    reader.close();
+        GeomHandler handler;
+        osmium::apply(reader, handler);
+        reader.close();
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
index 1a689b187..c2b9c145e 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp
@@ -41,104 +41,111 @@ using dynamic_location_handler_type = osmium::handler::NodeLocationsForWays<dyna
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
+    try {
+        const std::string input_filename{argv[1]};
 
-    osmium::memory::Buffer buffer{osmium::io::read_file(input_filename)};
+        osmium::memory::Buffer buffer{osmium::io::read_file(input_filename)};
 
-    const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
+        const auto& map_factory = osmium::index::MapFactory<osmium::unsigned_object_id_type, osmium::Location>::instance();
 
-    const auto buffer_size = buffer.committed() / (1024 * 1024); // buffer size in MBytes
-    const int runs = std::max(10, static_cast<int>(5000ull / buffer_size));
+        const auto buffer_size = buffer.committed() / (1024UL * 1024UL); // buffer size in MBytes
+        const int runs = std::max(10, static_cast<int>(5000ULL / buffer_size));
 
-    std::cout << "input: filename=" << input_filename << " buffer_size=" << buffer_size << "MBytes\n";
-    std::cout << "runs: " << runs << "\n";
+        std::cout << "input: filename=" << input_filename << " buffer_size=" << buffer_size << "MBytes\n";
+        std::cout << "runs: " << runs << "\n";
 
-    double static_min = std::numeric_limits<double>::max();
-    double static_sum = 0;
-    double static_max = 0;
+        double static_min = std::numeric_limits<double>::max();
+        double static_sum = 0;
+        double static_max = 0;
 
-    double dynamic_min = std::numeric_limits<double>::max();
-    double dynamic_sum = 0;
-    double dynamic_max = 0;
+        double dynamic_min = std::numeric_limits<double>::max();
+        double dynamic_sum = 0;
+        double dynamic_max = 0;
 
-    for (int i = 0; i < runs; ++i) {
+        for (int i = 0; i < runs; ++i) {
 
-        {
-            // static index
-            osmium::memory::Buffer tmp_buffer{buffer.committed()};
-            for (const auto& item : buffer) {
-                tmp_buffer.add_item(item);
-                tmp_buffer.commit();
+            {
+                // static index
+                osmium::memory::Buffer tmp_buffer{buffer.committed()};
+                for (const auto& item : buffer) {
+                    tmp_buffer.add_item(item);
+                    tmp_buffer.commit();
+                }
+
+                static_index_type static_index;
+                static_location_handler_type static_location_handler{static_index};
+
+                const auto start = std::chrono::steady_clock::now();
+                osmium::apply(tmp_buffer, static_location_handler);
+                const auto end = std::chrono::steady_clock::now();
+
+                const double duration = std::chrono::duration<double, std::milli>(end - start).count();
+
+                if (duration < static_min) {
+                    static_min = duration;
+                }
+                if (duration > static_max) {
+                    static_max = duration;
+                }
+                static_sum += duration;
             }
 
-            static_index_type static_index;
-            static_location_handler_type static_location_handler{static_index};
+            {
+                // dynamic index
+                osmium::memory::Buffer tmp_buffer{buffer.committed()};
+                for (const auto& item : buffer) {
+                    tmp_buffer.add_item(item);
+                    tmp_buffer.commit();
+                }
 
-            const auto start = std::chrono::steady_clock::now();
-            osmium::apply(tmp_buffer, static_location_handler);
-            const auto end = std::chrono::steady_clock::now();
+                std::unique_ptr<dynamic_index_type> index = map_factory.create_map(location_store);
+                dynamic_location_handler_type dynamic_location_handler{*index};
+                dynamic_location_handler.ignore_errors();
 
-            const double duration = std::chrono::duration<double, std::milli>(end - start).count();
+                const auto start = std::chrono::steady_clock::now();
+                osmium::apply(tmp_buffer, dynamic_location_handler);
+                const auto end = std::chrono::steady_clock::now();
 
-            if (duration < static_min) {
-                static_min = duration;
+                const double duration = std::chrono::duration<double, std::milli>(end - start).count();
+
+                if (duration < dynamic_min) {
+                    dynamic_min = duration;
+                }
+                if (duration > dynamic_max) {
+                    dynamic_max = duration;
+                }
+                dynamic_sum += duration;
             }
-            if (duration > static_max) {
-                static_max = duration;
-            }
-            static_sum += duration;
         }
 
-        {
-            // dynamic index
-            osmium::memory::Buffer tmp_buffer{buffer.committed()};
-            for (const auto& item : buffer) {
-                tmp_buffer.add_item(item);
-                tmp_buffer.commit();
-            }
+        const double static_avg = static_sum / runs;
+        const double dynamic_avg = dynamic_sum / runs;
 
-            std::unique_ptr<dynamic_index_type> index = map_factory.create_map(location_store);
-            dynamic_location_handler_type dynamic_location_handler{*index};
-            dynamic_location_handler.ignore_errors();
+        std::cout << "static  min=" << static_min << "ms avg=" << static_avg << "ms max=" << static_max << "ms\n";
+        std::cout << "dynamic min=" << dynamic_min << "ms avg=" << dynamic_avg << "ms max=" << dynamic_max << "ms\n";
 
-            const auto start = std::chrono::steady_clock::now();
-            osmium::apply(tmp_buffer, dynamic_location_handler);
-            const auto end = std::chrono::steady_clock::now();
+        const double rfactor = 100.0;
+        const double diff_min = std::round((dynamic_min - static_min) * rfactor) / rfactor;
+        const double diff_avg = std::round((dynamic_avg - static_avg) * rfactor) / rfactor;
+        const double diff_max = std::round((dynamic_max - static_max) * rfactor) / rfactor;
 
-            const double duration = std::chrono::duration<double, std::milli>(end - start).count();
+        const double prfactor = 10.0;
+        const double percent_min = std::round((100.0 * diff_min / static_min) * prfactor) / prfactor;
+        const double percent_avg = std::round((100.0 * diff_avg / static_avg) * prfactor) / prfactor;
+        const double percent_max = std::round((100.0 * diff_max / static_max) * prfactor) / prfactor;
 
-            if (duration < dynamic_min) {
-                dynamic_min = duration;
-            }
-            if (duration > dynamic_max) {
-                dynamic_max = duration;
-            }
-            dynamic_sum += duration;
-        }
+        std::cout << "difference:";
+        std::cout << " min=" << diff_min << "ms (" << percent_min << "%)";
+        std::cout << " avg=" << diff_avg << "ms (" << percent_avg << "%)";
+        std::cout << " max=" << diff_max << "ms (" << percent_max << "%)\n";
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 
-    const double static_avg = static_sum / runs;
-    const double dynamic_avg = dynamic_sum / runs;
-
-    std::cout << "static  min=" << static_min << "ms avg=" << static_avg << "ms max=" << static_max << "ms\n";
-    std::cout << "dynamic min=" << dynamic_min << "ms avg=" << dynamic_avg << "ms max=" << dynamic_max << "ms\n";
-
-    const double rfactor = 100.0;
-    const double diff_min = std::round((dynamic_min - static_min) * rfactor) / rfactor;
-    const double diff_avg = std::round((dynamic_avg - static_avg) * rfactor) / rfactor;
-    const double diff_max = std::round((dynamic_max - static_max) * rfactor) / rfactor;
-
-    const double prfactor = 10.0;
-    const double percent_min = std::round((100.0 * diff_min / static_min) * prfactor) / prfactor;
-    const double percent_avg = std::round((100.0 * diff_avg / static_avg) * prfactor) / prfactor;
-    const double percent_max = std::round((100.0 * diff_max / static_max) * prfactor) / prfactor;
-
-    std::cout << "difference:";
-    std::cout << " min=" << diff_min << "ms (" << percent_min << "%)";
-    std::cout << " avg=" << diff_avg << "ms (" << percent_avg << "%)";
-    std::cout << " max=" << diff_max << "ms (" << percent_max << "%)\n";
+    return 0;
 }
 
diff --git a/third_party/libosmium/benchmarks/osmium_benchmark_write_pbf.cpp b/third_party/libosmium/benchmarks/osmium_benchmark_write_pbf.cpp
index 632dd26eb..9c9f026ef 100644
--- a/third_party/libosmium/benchmarks/osmium_benchmark_write_pbf.cpp
+++ b/third_party/libosmium/benchmarks/osmium_benchmark_write_pbf.cpp
@@ -14,22 +14,29 @@
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " INPUT-FILE OUTPUT-FILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    std::string input_filename{argv[1]};
-    std::string output_filename{argv[2]};
+    try {
+        std::string input_filename{argv[1]};
+        std::string output_filename{argv[2]};
 
-    osmium::io::Reader reader{input_filename};
-    osmium::io::File output_file{output_filename, "pbf"};
-    osmium::io::Header header;
-    osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow};
+        osmium::io::Reader reader{input_filename};
+        osmium::io::File output_file{output_filename, "pbf"};
+        osmium::io::Header header;
+        osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow};
 
-    while (osmium::memory::Buffer buffer = reader.read()) {
-        writer(std::move(buffer));
+        while (osmium::memory::Buffer buffer = reader.read()) { // NOLINT(bugprone-use-after-move) Bug in clang-tidy https://bugs.llvm.org/show_bug.cgi?id=36516
+            writer(std::move(buffer));
+        }
+
+        writer.close();
+        reader.close();
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 
-    writer.close();
-    reader.close();
+    return 0;
 }
 
diff --git a/third_party/libosmium/build-appveyor.bat b/third_party/libosmium/build-appveyor.bat
index 74ea0c91a..80c0550f6 100644
--- a/third_party/libosmium/build-appveyor.bat
+++ b/third_party/libosmium/build-appveyor.bat
@@ -46,7 +46,7 @@ SET CMAKE_CMD=cmake .. -LA -G "Visual Studio 14 Win64" ^
 -DOsmium_DEBUG=TRUE ^
 -DCMAKE_BUILD_TYPE=%config% ^
 -DBUILD_HEADERS=OFF ^
--DBOOST_ROOT=C:/Libraries/boost_1_63_0 ^
+-DBOOST_ROOT=C:/Libraries/boost_1_67_0 ^
 -DZLIB_INCLUDE_DIR=C:/projects/zlib-vc140-static-64.1.2.11/lib/native/include ^
 -DZLIB_LIBRARY=C:/projects/zlib-vc140-static-64.1.2.11/lib/native/libs/x64/static/%config%/zlibstatic.lib ^
 -DEXPAT_INCLUDE_DIR=C:/projects/expat.v140.2.2.5/build/native/include ^
@@ -68,7 +68,7 @@ msbuild libosmium.sln ^
 /p:PlatformToolset=v140 %avlogger%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
-ctest --output-on-failure -C %config% -E testdata-overview
+ctest --output-on-failure -C %config%
 IF %ERRORLEVEL% NEQ 0 GOTO ERROR
 
 GOTO DONE
diff --git a/third_party/libosmium/build-msys2.bat b/third_party/libosmium/build-msys2.bat
index a4f0f7a1c..bf2f23186 100644
--- a/third_party/libosmium/build-msys2.bat
+++ b/third_party/libosmium/build-msys2.bat
@@ -9,13 +9,18 @@ SET "PATH=C:\msys64\mingw64\bin;C:\msys64\usr\bin;%PATH%"
 echo %PATH%
 
 echo "Installing MSYS2 packages..."
-bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-geos mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-cppcheck mingw-w64-x86_64-doxygen mingw-w64-x86_64-gdb mingw-w64-x86_64-sparsehash mingw-w64-x86_64-gdal mingw-w64-x86_64-ruby mingw-w64-x86_64-libspatialite mingw-w64-x86_64-spatialite-tools mingw-w64-x86_64-clang-tools-extra"
-bash -lc "pacman -S --needed --noconfirm mingw-w64-x86_64-postgresql mingw-w64-x86_64-netcdf mingw-w64-x86_64-crypto++"
+bash -lc "pacman -Sy --needed --noconfirm mingw-w64-x86_64-gcc mingw-w64-x86_64-geos mingw-w64-x86_64-cmake mingw-w64-x86_64-boost mingw-w64-x86_64-cppcheck mingw-w64-x86_64-doxygen mingw-w64-x86_64-gdb mingw-w64-x86_64-gdal mingw-w64-x86_64-ruby mingw-w64-x86_64-libspatialite mingw-w64-x86_64-spatialite-tools mingw-w64-x86_64-clang-tools-extra"
+bash -lc "pacman -Sy --needed --noconfirm mingw-w64-x86_64-postgresql mingw-w64-x86_64-netcdf mingw-w64-x86_64-crypto++"
 call C:\msys64\mingw64\bin\gem.cmd install json
 
+REM Workaround for problem with spatialite (see https://github.com/osmcode/libosmium/issues/262)
+copy /y C:\msys64\mingw64\bin\libreadline8.dll C:\msys64\mingw64\bin\libreadline7.dll
+
 echo "Setting PROJ_LIB variable for correct PROJ.4 working"
 set PROJ_LIB=c:\msys64\mingw64\share\proj
 
+set CXXFLAGS=-Wno-stringop-overflow
+
 echo "Generating makefiles"
 mkdir build
 cd build
diff --git a/third_party/libosmium/cmake/FindGem.cmake b/third_party/libosmium/cmake/FindGem.cmake
index 5d78a9026..9927ea814 100644
--- a/third_party/libosmium/cmake/FindGem.cmake
+++ b/third_party/libosmium/cmake/FindGem.cmake
@@ -149,7 +149,7 @@ if(DEFINED GEM_INCLUDE_DIRS)
     LIST(REMOVE_DUPLICATES GEM_INCLUDE_DIRS)
 endif()
 
-find_package_handle_standard_args(GEM
+find_package_handle_standard_args(Gem
     REQUIRED_VARS ${components_found_vars}
     FAIL_MESSAGE "Could not find all required gems")
 
diff --git a/third_party/libosmium/cmake/FindLZ4.cmake b/third_party/libosmium/cmake/FindLZ4.cmake
new file mode 100644
index 000000000..8c94e3bcd
--- /dev/null
+++ b/third_party/libosmium/cmake/FindLZ4.cmake
@@ -0,0 +1,38 @@
+find_path(LZ4_INCLUDE_DIR
+  NAMES lz4.h
+  DOC "lz4 include directory")
+mark_as_advanced(LZ4_INCLUDE_DIR)
+find_library(LZ4_LIBRARY
+  NAMES lz4 liblz4
+  DOC "lz4 library")
+mark_as_advanced(LZ4_LIBRARY)
+
+if (LZ4_INCLUDE_DIR)
+  file(STRINGS "${LZ4_INCLUDE_DIR}/lz4.h" _lz4_version_lines
+    REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)")
+  string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}")
+  string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}")
+  set(LZ4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}")
+  unset(_lz4_version_major)
+  unset(_lz4_version_minor)
+  unset(_lz4_version_release)
+  unset(_lz4_version_lines)
+endif ()
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(LZ4
+  REQUIRED_VARS LZ4_LIBRARY LZ4_INCLUDE_DIR
+  VERSION_VAR LZ4_VERSION)
+
+if (LZ4_FOUND)
+  set(LZ4_INCLUDE_DIRS "${LZ4_INCLUDE_DIR}")
+  set(LZ4_LIBRARIES "${LZ4_LIBRARY}")
+
+  if (NOT TARGET LZ4::LZ4)
+    add_library(LZ4::LZ4 UNKNOWN IMPORTED)
+    set_target_properties(LZ4::LZ4 PROPERTIES
+      IMPORTED_LOCATION "${LZ4_LIBRARY}"
+      INTERFACE_INCLUDE_DIRECTORIES "${LZ4_INCLUDE_DIR}")
+  endif ()
+endif ()
diff --git a/third_party/libosmium/cmake/FindOsmium.cmake b/third_party/libosmium/cmake/FindOsmium.cmake
index 9eaf7349e..651c09a72 100644
--- a/third_party/libosmium/cmake/FindOsmium.cmake
+++ b/third_party/libosmium/cmake/FindOsmium.cmake
@@ -33,7 +33,8 @@
 #      geos       - include if you want to use any of the GEOS functions
 #      gdal       - include if you want to use any of the OGR functions
 #      proj       - include if you want to use any of the Proj.4 functions
-#      sparsehash - include if you use the sparsehash index
+#      sparsehash - include if you use the sparsehash index (deprecated!)
+#      lz4        - include support for LZ4 compression of PBF files
 #
 #    You can check for success with something like this:
 #
@@ -71,6 +72,9 @@ find_path(OSMIUM_INCLUDE_DIR osmium/version.hpp
 
 # Check libosmium version number
 if(Osmium_FIND_VERSION)
+    if(NOT EXISTS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp")
+        message(FATAL_ERROR "Missing ${OSMIUM_INCLUDE_DIR}/osmium/version.hpp. Either your libosmium version is too old, or libosmium wasn't found in the place you said.")
+    endif()
     file(STRINGS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp" _libosmium_version_define REGEX "#define LIBOSMIUM_VERSION_STRING")
     if("${_libosmium_version_define}" MATCHES "#define LIBOSMIUM_VERSION_STRING \"([0-9.]+)\"")
         set(_libosmium_version "${CMAKE_MATCH_1}")
@@ -111,16 +115,23 @@ endif()
 if(Osmium_USE_PBF)
     find_package(ZLIB)
     find_package(Threads)
-    find_package(Protozero 1.5.1)
+    find_package(Protozero 1.6.3)
+
+    if(Osmium_USE_LZ4)
+        find_package(LZ4 REQUIRED)
+        add_definitions(-DOSMIUM_WITH_LZ4)
+    endif()
 
     list(APPEND OSMIUM_EXTRA_FIND_VARS ZLIB_FOUND Threads_FOUND PROTOZERO_INCLUDE_DIR)
     if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_FOUND)
         list(APPEND OSMIUM_PBF_LIBRARIES
             ${ZLIB_LIBRARIES}
+            ${LZ4_LIBRARIES}
             ${CMAKE_THREAD_LIBS_INIT}
         )
         list(APPEND OSMIUM_INCLUDE_DIRS
             ${ZLIB_INCLUDE_DIR}
+            ${LZ4_INCLUDE_DIRS}
             ${PROTOZERO_INCLUDE_DIR}
         )
     else()
@@ -213,6 +224,7 @@ endif()
 #----------------------------------------------------------------------
 # Component 'sparsehash'
 if(Osmium_USE_SPARSEHASH)
+    message(WARNING "Osmium: Use of Google SparseHash is deprecated. Please switch to a different index type.")
     find_path(SPARSEHASH_INCLUDE_DIR google/sparsetable)
 
     list(APPEND OSMIUM_EXTRA_FIND_VARS SPARSEHASH_INCLUDE_DIR)
@@ -324,7 +336,7 @@ if(MSVC)
     add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_WARNINGS)
 endif()
 
-if(APPLE)
+if(APPLE AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
 # following only available from cmake 2.8.12:
 #   add_compile_options(-stdlib=libc++)
 # so using this instead:
diff --git a/third_party/libosmium/cmake/build.bat b/third_party/libosmium/cmake/build.bat
deleted file mode 100644
index 5ffab124e..000000000
--- a/third_party/libosmium/cmake/build.bat
+++ /dev/null
@@ -1,15 +0,0 @@
-call "%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64
-set CMAKE_PREFIX_PATH=C:\PROJ
-set VERSION=Debug
-set TESTS=ON
-set ALLHPPS=ON
-set PREFIX=d:\libs18d
-set BOOST_ROOT=d:\boost
-
-cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=%PREFIX% -DBOOST_ROOT=%BOOST_ROOT% -DBoost_USE_STATIC_LIBS=ON -DBUILD_TESTING=%TESTS% -DBUILD_TRY_HPPS=%ALLHPPS$ -T CTP_Nov2013
-msbuild /clp:Verbosity=minimal /nologo libosmium.sln /flp1:logfile=build_errors.txt;errorsonly /flp2:logfile=build_warnings.txt;warningsonly
-set PATH=%PATH%;%PREFIX%/bin
-
-del test\osm-testdata\*.db
-del test\osm-testdata\*.json
-if "%TESTS%"=="ON" ctest -VV >build_tests.log
diff --git a/third_party/libosmium/doc/doc.md b/third_party/libosmium/doc/doc.md
index 309f23f9c..db9b43cc9 100644
--- a/third_party/libosmium/doc/doc.md
+++ b/third_party/libosmium/doc/doc.md
@@ -4,7 +4,7 @@ data.
 
 This is the API documentation that was automatically created from the
 source code. For more information about the Osmium Library see
-http://osmcode.org/libosmium .
+https://osmcode.org/libosmium .
 
 Osmium is free software and available under the Boost Software License.
 The source code is available at https://github.com/osmcode/libosmium .
diff --git a/third_party/libosmium/examples/CMakeLists.txt b/third_party/libosmium/examples/CMakeLists.txt
index c1498cc35..38a00d61c 100644
--- a/third_party/libosmium/examples/CMakeLists.txt
+++ b/third_party/libosmium/examples/CMakeLists.txt
@@ -25,6 +25,7 @@ set(EXAMPLES
     read
     read_with_progress
     road_length
+    tags_filter
     tiles
     CACHE STRING "Example programs"
 )
diff --git a/third_party/libosmium/examples/README.md b/third_party/libosmium/examples/README.md
index 282d03d44..16b78b8a1 100644
--- a/third_party/libosmium/examples/README.md
+++ b/third_party/libosmium/examples/README.md
@@ -29,6 +29,7 @@ them.
 
 * `osmium_area_test`
 * `osmium_create_pois`
+* `osmium_tags_filter`
 
 ## Even more advanced examples
 
diff --git a/third_party/libosmium/examples/osmium_amenity_list.cpp b/third_party/libosmium/examples/osmium_amenity_list.cpp
index 7e8d79a9e..17b2bede7 100644
--- a/third_party/libosmium/examples/osmium_amenity_list.cpp
+++ b/third_party/libosmium/examples/osmium_amenity_list.cpp
@@ -25,7 +25,6 @@
 */
 
 #include <cstdio>   // for std::printf
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cerr
 #include <string>   // for std::string
 
@@ -58,12 +57,12 @@ using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 class AmenityHandler : public osmium::handler::Handler {
 
     // Print info about one amenity to stdout.
-    void print_amenity(const char* type, const char* name, const osmium::geom::Coordinates& c) {
+    static void print_amenity(const char* type, const char* name, const osmium::geom::Coordinates& c) {
         std::printf("%8.4f,%8.4f %-15s %s\n", c.x, c.y, type, name ? name : "");
     }
 
     // Calculate the center point of a NodeRefList.
-    osmium::geom::Coordinates calc_center(const osmium::NodeRefList& nr_list) {
+    static osmium::geom::Coordinates calc_center(const osmium::NodeRefList& nr_list) {
         // Coordinates simply store an X and Y coordinate pair as doubles.
         // (Unlike osmium::Location which stores them more efficiently as
         // 32 bit integers.) Use Coordinates when you want to do calculations
@@ -83,7 +82,9 @@ class AmenityHandler : public osmium::handler::Handler {
 
 public:
 
-    void node(const osmium::Node& node) {
+    // The callback functions can be either static or not depending on whether
+    // you need to access any member variables of the handler.
+    static void node(const osmium::Node& node) {
         // Getting a tag value can be expensive, because a list of tags has
         // to be gone through and each tag has to be checked. So we store the
         // result and reuse it.
@@ -93,7 +94,9 @@ public:
         }
     }
 
-    void area(const osmium::Area& area) {
+    // The callback functions can be either static or not depending on whether
+    // you need to access any member variables of the handler.
+    static void area(const osmium::Area& area) {
         const char* amenity = area.tags()["amenity"];
         if (amenity) {
             // Use the center of the first outer ring. Because we set
@@ -110,62 +113,68 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // The input file
-    const osmium::io::File input_file{argv[1]};
+    try {
+        // The input file
+        const osmium::io::File input_file{argv[1]};
 
-    // Configuration for the multipolygon assembler. We disable the option to
-    // create empty areas when invalid multipolygons are encountered. This
-    // means areas created have a valid geometry and invalid multipolygons
-    // are simply ignored.
-    osmium::area::Assembler::config_type assembler_config;
-    assembler_config.create_empty_areas = false;
+        // Configuration for the multipolygon assembler. We disable the option to
+        // create empty areas when invalid multipolygons are encountered. This
+        // means areas created have a valid geometry and invalid multipolygons
+        // are simply ignored.
+        osmium::area::Assembler::config_type assembler_config;
+        assembler_config.create_empty_areas = false;
 
-    // Initialize the MultipolygonManager. Its job is to collect all
-    // relations and member ways needed for each area. It then calls an
-    // instance of the osmium::area::Assembler class (with the given config)
-    // to actually assemble one area.
-    osmium::area::MultipolygonManager<osmium::area::Assembler> mp_manager{assembler_config};
+        // Initialize the MultipolygonManager. Its job is to collect all
+        // relations and member ways needed for each area. It then calls an
+        // instance of the osmium::area::Assembler class (with the given config)
+        // to actually assemble one area.
+        osmium::area::MultipolygonManager<osmium::area::Assembler> mp_manager{assembler_config};
 
-    // We read the input file twice. In the first pass, only relations are
-    // read and fed into the multipolygon manager.
-    std::cerr << "Pass 1...\n";
-    osmium::relations::read_relations(input_file, mp_manager);
-    std::cerr << "Pass 1 done\n";
+        // We read the input file twice. In the first pass, only relations are
+        // read and fed into the multipolygon manager.
+        std::cerr << "Pass 1...\n";
+        osmium::relations::read_relations(input_file, mp_manager);
+        std::cerr << "Pass 1 done\n";
 
-    // The index storing all node locations.
-    index_type index;
+        // The index storing all node locations.
+        index_type index;
 
-    // The handler that stores all node locations in the index and adds them
-    // to the ways.
-    location_handler_type location_handler{index};
+        // The handler that stores all node locations in the index and adds them
+        // to the ways.
+        location_handler_type location_handler{index};
 
-    // If a location is not available in the index, we ignore it. It might
-    // not be needed (if it is not part of a multipolygon relation), so why
-    // create an error?
-    location_handler.ignore_errors();
+        // If a location is not available in the index, we ignore it. It might
+        // not be needed (if it is not part of a multipolygon relation), so why
+        // create an error?
+        location_handler.ignore_errors();
 
-    // Create our handler.
-    AmenityHandler data_handler;
+        // Create our handler.
+        AmenityHandler data_handler;
 
-    // On the second pass we read all objects and run them first through the
-    // node location handler and then the multipolygon manager. The manager
-    // will put the areas it has created into the "buffer" which are then
-    // fed through our handler.
-    //
-    // The read_meta::no option disables reading of meta data (such as version
-    // numbers, timestamps, etc.) which are not needed in this case. Disabling
-    // this can speed up your program.
-    std::cerr << "Pass 2...\n";
-    osmium::io::Reader reader{input_file, osmium::io::read_meta::no};
+        // On the second pass we read all objects and run them first through the
+        // node location handler and then the multipolygon manager. The manager
+        // will put the areas it has created into the "buffer" which are then
+        // fed through our handler.
+        //
+        // The read_meta::no option disables reading of meta data (such as version
+        // numbers, timestamps, etc.) which are not needed in this case. Disabling
+        // this can speed up your program.
+        std::cerr << "Pass 2...\n";
+        osmium::io::Reader reader{input_file, osmium::io::read_meta::no};
 
-    osmium::apply(reader, location_handler, data_handler, mp_manager.handler([&data_handler](const osmium::memory::Buffer& area_buffer) {
-        osmium::apply(area_buffer, data_handler);
-    }));
+        osmium::apply(reader, location_handler, data_handler, mp_manager.handler([&data_handler](const osmium::memory::Buffer& area_buffer) {
+            osmium::apply(area_buffer, data_handler);
+        }));
 
-    reader.close();
-    std::cerr << "Pass 2 done\n";
+        reader.close();
+        std::cerr << "Pass 2 done\n";
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_area_test.cpp b/third_party/libosmium/examples/osmium_area_test.cpp
index 5a29472e5..4df749d6c 100644
--- a/third_party/libosmium/examples/osmium_area_test.cpp
+++ b/third_party/libosmium/examples/osmium_area_test.cpp
@@ -25,7 +25,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <cstring>  // for std::strcmp
 #include <iostream> // for std::cout, std::cerr
 
@@ -93,106 +92,113 @@ void print_help() {
 
 void print_usage(const char* prgname) {
     std::cerr << "Usage: " << prgname << " [OPTIONS] OSMFILE\n";
-    std::exit(1);
 }
 
 int main(int argc, char* argv[]) {
     if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
                      !std::strcmp(argv[1], "--help"))) {
         print_help();
-        std::exit(0);
+        return 0;
     }
 
     if (argc != 3) {
         print_usage(argv[0]);
+        return 1;
     }
 
-    // Initialize an empty DynamicHandler. Later it will be associated
-    // with one of the handlers. You can think of the DynamicHandler as
-    // a kind of "variant handler" or a "pointer handler" pointing to the
-    // real handler.
-    osmium::handler::DynamicHandler handler;
+    try {
+        // Initialize an empty DynamicHandler. Later it will be associated
+        // with one of the handlers. You can think of the DynamicHandler as
+        // a kind of "variant handler" or a "pointer handler" pointing to the
+        // real handler.
+        osmium::handler::DynamicHandler handler;
 
-    if (!std::strcmp(argv[1], "-w") || !std::strcmp(argv[1], "--dump-wkt")) {
-        handler.set<WKTDump>();
-    } else if (!std::strcmp(argv[1], "-o") || !std::strcmp(argv[1], "--dump-objects")) {
-        handler.set<osmium::handler::Dump>(std::cout);
-    } else {
-        print_usage(argv[0]);
-    }
-
-    osmium::io::File input_file{argv[2]};
-
-    // Configuration for the multipolygon assembler. Here the default settings
-    // are used, but you could change multiple settings.
-    osmium::area::Assembler::config_type assembler_config;
-
-    // Set up a filter matching only forests. This will be used to only build
-    // areas with matching tags.
-    osmium::TagsFilter filter{false};
-    filter.add_rule(true, "landuse", "forest");
-    filter.add_rule(true, "natural", "wood");
-
-    // Initialize the MultipolygonManager. Its job is to collect all
-    // relations and member ways needed for each area. It then calls an
-    // instance of the osmium::area::Assembler class (with the given config)
-    // to actually assemble one area. The filter parameter is optional, if
-    // it is not set, all areas will be built.
-    osmium::area::MultipolygonManager<osmium::area::Assembler> mp_manager{assembler_config, filter};
-
-    // We read the input file twice. In the first pass, only relations are
-    // read and fed into the multipolygon manager.
-    std::cerr << "Pass 1...\n";
-    osmium::relations::read_relations(input_file, mp_manager);
-    std::cerr << "Pass 1 done\n";
-
-    // Output the amount of main memory used so far. All multipolygon relations
-    // are in memory now.
-    std::cerr << "Memory:\n";
-    osmium::relations::print_used_memory(std::cerr, mp_manager.used_memory());
-
-    // The index storing all node locations.
-    index_type index;
-
-    // The handler that stores all node locations in the index and adds them
-    // to the ways.
-    location_handler_type location_handler{index};
-
-    // If a location is not available in the index, we ignore it. It might
-    // not be needed (if it is not part of a multipolygon relation), so why
-    // create an error?
-    location_handler.ignore_errors();
-
-    // On the second pass we read all objects and run them first through the
-    // node location handler and then the multipolygon collector. The collector
-    // will put the areas it has created into the "buffer" which are then
-    // fed through our "handler".
-    std::cerr << "Pass 2...\n";
-    osmium::io::Reader reader{input_file};
-    osmium::apply(reader, location_handler, mp_manager.handler([&handler](osmium::memory::Buffer&& buffer) {
-        osmium::apply(buffer, handler);
-    }));
-    reader.close();
-    std::cerr << "Pass 2 done\n";
-
-    // Output the amount of main memory used so far. All complete multipolygon
-    // relations have been cleaned up.
-    std::cerr << "Memory:\n";
-    osmium::relations::print_used_memory(std::cerr, mp_manager.used_memory());
-
-    // If there were multipolgyon relations in the input, but some of their
-    // members are not in the input file (which often happens for extracts)
-    // this will write the IDs of the incomplete relations to stderr.
-    std::vector<osmium::object_id_type> incomplete_relations_ids;
-    mp_manager.for_each_incomplete_relation([&](const osmium::relations::RelationHandle& handle){
-        incomplete_relations_ids.push_back(handle->id());
-    });
-    if (!incomplete_relations_ids.empty()) {
-        std::cerr << "Warning! Some member ways missing for these multipolygon relations:";
-        for (const auto id : incomplete_relations_ids) {
-            std::cerr << " " << id;
+        if (!std::strcmp(argv[1], "-w") || !std::strcmp(argv[1], "--dump-wkt")) {
+            handler.set<WKTDump>();
+        } else if (!std::strcmp(argv[1], "-o") || !std::strcmp(argv[1], "--dump-objects")) {
+            handler.set<osmium::handler::Dump>(std::cout);
+        } else {
+            print_usage(argv[0]);
+            return 1;
         }
-        std::cerr << "\n";
+
+        osmium::io::File input_file{argv[2]};
+
+        // Configuration for the multipolygon assembler. Here the default settings
+        // are used, but you could change multiple settings.
+        osmium::area::Assembler::config_type assembler_config;
+
+        // Set up a filter matching only forests. This will be used to only build
+        // areas with matching tags.
+        osmium::TagsFilter filter{false};
+        filter.add_rule(true, "landuse", "forest");
+        filter.add_rule(true, "natural", "wood");
+
+        // Initialize the MultipolygonManager. Its job is to collect all
+        // relations and member ways needed for each area. It then calls an
+        // instance of the osmium::area::Assembler class (with the given config)
+        // to actually assemble one area. The filter parameter is optional, if
+        // it is not set, all areas will be built.
+        osmium::area::MultipolygonManager<osmium::area::Assembler> mp_manager{assembler_config, filter};
+
+        // We read the input file twice. In the first pass, only relations are
+        // read and fed into the multipolygon manager.
+        std::cerr << "Pass 1...\n";
+        osmium::relations::read_relations(input_file, mp_manager);
+        std::cerr << "Pass 1 done\n";
+
+        // Output the amount of main memory used so far. All multipolygon relations
+        // are in memory now.
+        std::cerr << "Memory:\n";
+        osmium::relations::print_used_memory(std::cerr, mp_manager.used_memory());
+
+        // The index storing all node locations.
+        index_type index;
+
+        // The handler that stores all node locations in the index and adds them
+        // to the ways.
+        location_handler_type location_handler{index};
+
+        // If a location is not available in the index, we ignore it. It might
+        // not be needed (if it is not part of a multipolygon relation), so why
+        // create an error?
+        location_handler.ignore_errors();
+
+        // On the second pass we read all objects and run them first through the
+        // node location handler and then the multipolygon collector. The collector
+        // will put the areas it has created into the "buffer" which are then
+        // fed through our "handler".
+        std::cerr << "Pass 2...\n";
+        osmium::io::Reader reader{input_file};
+        osmium::apply(reader, location_handler, mp_manager.handler([&handler](osmium::memory::Buffer&& buffer) {
+            osmium::apply(buffer, handler);
+        }));
+        reader.close();
+        std::cerr << "Pass 2 done\n";
+
+        // Output the amount of main memory used so far. All complete multipolygon
+        // relations have been cleaned up.
+        std::cerr << "Memory:\n";
+        osmium::relations::print_used_memory(std::cerr, mp_manager.used_memory());
+
+        // If there were multipolgyon relations in the input, but some of their
+        // members are not in the input file (which often happens for extracts)
+        // this will write the IDs of the incomplete relations to stderr.
+        std::vector<osmium::object_id_type> incomplete_relations_ids;
+        mp_manager.for_each_incomplete_relation([&](const osmium::relations::RelationHandle& handle){
+            incomplete_relations_ids.push_back(handle->id());
+        });
+        if (!incomplete_relations_ids.empty()) {
+            std::cerr << "Warning! Some member ways missing for these multipolygon relations:";
+            for (const auto id : incomplete_relations_ids) {
+                std::cerr << " " << id;
+            }
+            std::cerr << "\n";
+        }
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 }
 
diff --git a/third_party/libosmium/examples/osmium_change_tags.cpp b/third_party/libosmium/examples/osmium_change_tags.cpp
index e00ee0339..4348d17dd 100644
--- a/third_party/libosmium/examples/osmium_change_tags.cpp
+++ b/third_party/libosmium/examples/osmium_change_tags.cpp
@@ -22,7 +22,6 @@
 
 */
 
-#include <cstdlib>   // for std::exit
 #include <cstring>   // for std::strcmp
 #include <exception> // for std::exception
 #include <iostream>  // for std::cout, std::cerr
@@ -66,7 +65,7 @@ class RewriteHandler : public osmium::handler::Handler {
     // Copy all tags with two changes:
     // * Do not copy "created_by" tags
     // * Change "landuse=forest" into "natural=wood"
-    void copy_tags(osmium::builder::Builder& parent, const osmium::TagList& tags) {
+    static void copy_tags(osmium::builder::Builder& parent, const osmium::TagList& tags) {
 
         // The TagListBuilder is used to create a list of tags. The parameter
         // to create it is a reference to the builder of the object that
@@ -150,7 +149,7 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " INFILE OUTFILE\n";
-        std::exit(1);
+        return 1;
     }
 
     // Get input and output file names from command line.
@@ -196,8 +195,8 @@ int main(int argc, char* argv[]) {
         reader.close();
     } catch (const std::exception& e) {
         // All exceptions used by the Osmium library derive from std::exception.
-        std::cerr << e.what() << "\n";
-        std::exit(1);
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 }
 
diff --git a/third_party/libosmium/examples/osmium_convert.cpp b/third_party/libosmium/examples/osmium_convert.cpp
index d28663b89..63c0440ce 100644
--- a/third_party/libosmium/examples/osmium_convert.cpp
+++ b/third_party/libosmium/examples/osmium_convert.cpp
@@ -17,7 +17,6 @@
 
 */
 
-#include <cstdlib>   // for std::exit
 #include <cstring>   // for std::strcmp
 #include <exception> // for std::exception
 #include <iostream>  // for std::cout, std::cerr
@@ -53,18 +52,18 @@ void print_help() {
 
 void print_usage(const char* prgname) {
     std::cerr << "Usage: " << prgname << " [OPTIONS] [INFILE [OUTFILE]]\n";
-    std::exit(0);
 }
 
 int main(int argc, char* argv[]) {
     if (argc == 1) {
         print_usage(argv[0]);
+        return 0;
     }
 
     if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
                      !std::strcmp(argv[1], "--help"))) {
         print_help();
-        std::exit(0);
+        return 0;
     }
 
     // Input and output format are empty by default. Later this will mean that
@@ -83,6 +82,7 @@ int main(int argc, char* argv[]) {
                 input_format = argv[i];
             } else {
                 print_usage(argv[0]);
+                return 1;
             }
         } else if (!std::strncmp(argv[i], "--from-format=", 14)) {
             input_format = argv[i] + 14;
@@ -92,6 +92,7 @@ int main(int argc, char* argv[]) {
                 output_format = argv[i];
             } else {
                 print_usage(argv[0]);
+                return 1;
             }
         } else if (!std::strncmp(argv[i], "--to-format=", 12)) {
             output_format = argv[i] + 12;
@@ -101,6 +102,7 @@ int main(int argc, char* argv[]) {
             output_file_name = argv[i];
         } else {
             print_usage(argv[0]);
+            return 1;
         }
     }
 
@@ -135,7 +137,7 @@ int main(int argc, char* argv[]) {
         // a time. This is much easier and faster than copying each object
         // in the file. Buffers are moved around, so there is no cost for
         // copying in memory.
-        while (osmium::memory::Buffer buffer = reader.read()) {
+        while (osmium::memory::Buffer buffer = reader.read()) { // NOLINT(bugprone-use-after-move) Bug in clang-tidy https://bugs.llvm.org/show_bug.cgi?id=36516
             writer(std::move(buffer));
         }
 
@@ -147,8 +149,8 @@ int main(int argc, char* argv[]) {
         reader.close();
     } catch (const std::exception& e) {
         // All exceptions used by the Osmium library derive from std::exception.
-        std::cerr << e.what() << "\n";
-        std::exit(1);
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 }
 
diff --git a/third_party/libosmium/examples/osmium_count.cpp b/third_party/libosmium/examples/osmium_count.cpp
index 130b98a0c..71361ccfe 100644
--- a/third_party/libosmium/examples/osmium_count.cpp
+++ b/third_party/libosmium/examples/osmium_count.cpp
@@ -18,7 +18,6 @@
 */
 
 #include <cstdint>  // for std::uint64_t
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cout, std::cerr
 
 // Allow any format of input files (XML, PBF, ...)
@@ -63,33 +62,39 @@ struct CountHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // The Reader is initialized here with an osmium::io::File, but could
-    // also be directly initialized with a file name.
-    osmium::io::File input_file{argv[1]};
-    osmium::io::Reader reader{input_file};
+    try {
+        // The Reader is initialized here with an osmium::io::File, but could
+        // also be directly initialized with a file name.
+        osmium::io::File input_file{argv[1]};
+        osmium::io::Reader reader{input_file};
 
-    // Create an instance of our own CountHandler and push the data from the
-    // input file through it.
-    CountHandler handler;
-    osmium::apply(reader, handler);
+        // Create an instance of our own CountHandler and push the data from the
+        // input file through it.
+        CountHandler handler;
+        osmium::apply(reader, handler);
 
-    // You do not have to close the Reader explicitly, but because the
-    // destructor can't throw, you will not see any errors otherwise.
-    reader.close();
+        // You do not have to close the Reader explicitly, but because the
+        // destructor can't throw, you will not see any errors otherwise.
+        reader.close();
 
-    std::cout << "Nodes: "     << handler.nodes << "\n";
-    std::cout << "Ways: "      << handler.ways << "\n";
-    std::cout << "Relations: " << handler.relations << "\n";
+        std::cout << "Nodes: "     << handler.nodes << "\n";
+        std::cout << "Ways: "      << handler.ways << "\n";
+        std::cout << "Relations: " << handler.relations << "\n";
 
-    // Because of the huge amount of OSM data, some Osmium-based programs
-    // (though not this one) can use huge amounts of data. So checking actual
-    // memore usage is often useful and can be done easily with this class.
-    // (Currently only works on Linux, not OSX and Windows.)
-    osmium::MemoryUsage memory;
+        // Because of the huge amount of OSM data, some Osmium-based programs
+        // (though not this one) can use huge amounts of data. So checking actual
+        // memore usage is often useful and can be done easily with this class.
+        // (Currently only works on Linux, not macOS and Windows.)
+        osmium::MemoryUsage memory;
 
-    std::cout << "\nMemory used: " << memory.peak() << " MBytes\n";
+        std::cout << "\nMemory used: " << memory.peak() << " MBytes\n";
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_create_pois.cpp b/third_party/libosmium/examples/osmium_create_pois.cpp
index dedbdb88a..44de48da1 100644
--- a/third_party/libosmium/examples/osmium_create_pois.cpp
+++ b/third_party/libosmium/examples/osmium_create_pois.cpp
@@ -19,7 +19,6 @@
 
 */
 
-#include <cstdlib>   // for std::exit
 #include <cstring>   // for std::strcmp
 #include <ctime>     // for std::time
 #include <exception> // for std::exception
@@ -37,7 +36,7 @@
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OUTFILE\n";
-        std::exit(1);
+        return 1;
     }
 
     // Get output file name from command line.
@@ -93,8 +92,8 @@ int main(int argc, char* argv[]) {
         writer.close();
     } catch (const std::exception& e) {
         // All exceptions used by the Osmium library derive from std::exception.
-        std::cerr << e.what() << "\n";
-        std::exit(1);
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 }
 
diff --git a/third_party/libosmium/examples/osmium_debug.cpp b/third_party/libosmium/examples/osmium_debug.cpp
index ed6859612..d511fc8d1 100644
--- a/third_party/libosmium/examples/osmium_debug.cpp
+++ b/third_party/libosmium/examples/osmium_debug.cpp
@@ -17,7 +17,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cout, std::cerr
 #include <string>   // for std::string
 
@@ -34,51 +33,57 @@ int main(int argc, char* argv[]) {
     if (argc < 2 || argc > 3) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE [TYPES]\n";
         std::cerr << "TYPES can be any combination of 'n', 'w', 'r', and 'c' to indicate what types of OSM entities you want (default: all).\n";
-        std::exit(1);
+        return 1;
     }
 
-    // Default is all entity types: nodes, ways, relations, and changesets
-    osmium::osm_entity_bits::type read_types = osmium::osm_entity_bits::all;
+    try {
+        // Default is all entity types: nodes, ways, relations, and changesets
+        osmium::osm_entity_bits::type read_types = osmium::osm_entity_bits::all;
 
-    // Get entity types from command line if there is a 2nd argument.
-    if (argc == 3) {
-        read_types = osmium::osm_entity_bits::nothing;
-        std::string types = argv[2];
-        if (types.find('n') != std::string::npos) {
-            read_types |= osmium::osm_entity_bits::node;
+        // Get entity types from command line if there is a 2nd argument.
+        if (argc == 3) {
+            read_types = osmium::osm_entity_bits::nothing;
+            std::string types = argv[2];
+            if (types.find('n') != std::string::npos) {
+                read_types |= osmium::osm_entity_bits::node;
+            }
+            if (types.find('w') != std::string::npos) {
+                read_types |= osmium::osm_entity_bits::way;
+            }
+            if (types.find('r') != std::string::npos) {
+                read_types |= osmium::osm_entity_bits::relation;
+            }
+            if (types.find('c') != std::string::npos) {
+                read_types |= osmium::osm_entity_bits::changeset;
+            }
         }
-        if (types.find('w') != std::string::npos) {
-            read_types |= osmium::osm_entity_bits::way;
-        }
-        if (types.find('r') != std::string::npos) {
-            read_types |= osmium::osm_entity_bits::relation;
-        }
-        if (types.find('c') != std::string::npos) {
-            read_types |= osmium::osm_entity_bits::changeset;
+
+        // Initialize Reader with file name and the types of entities we want to
+        // read.
+        osmium::io::Reader reader{argv[1], read_types};
+
+        // The file header can contain metadata such as the program that generated
+        // the file and the bounding box of the data.
+        osmium::io::Header header = reader.header();
+        std::cout << "HEADER:\n  generator=" << header.get("generator") << "\n";
+
+        for (const auto& bbox : header.boxes()) {
+            std::cout << "  bbox=" << bbox << "\n";
         }
+
+        // Initialize Dump handler.
+        osmium::handler::Dump dump{std::cout};
+
+        // Read from input and send everything to Dump handler.
+        osmium::apply(reader, dump);
+
+        // You do not have to close the Reader explicitly, but because the
+        // destructor can't throw, you will not see any errors otherwise.
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
-
-    // Initialize Reader with file name and the types of entities we want to
-    // read.
-    osmium::io::Reader reader{argv[1], read_types};
-
-    // The file header can contain metadata such as the program that generated
-    // the file and the bounding box of the data.
-    osmium::io::Header header = reader.header();
-    std::cout << "HEADER:\n  generator=" << header.get("generator") << "\n";
-
-    for (const auto& bbox : header.boxes()) {
-        std::cout << "  bbox=" << bbox << "\n";
-    }
-
-    // Initialize Dump handler.
-    osmium::handler::Dump dump{std::cout};
-
-    // Read from input and send everything to Dump handler.
-    osmium::apply(reader, dump);
-
-    // You do not have to close the Reader explicitly, but because the
-    // destructor can't throw, you will not see any errors otherwise.
-    reader.close();
 }
 
diff --git a/third_party/libosmium/examples/osmium_dump_internal.cpp b/third_party/libosmium/examples/osmium_dump_internal.cpp
index 39523fa54..e655813bc 100644
--- a/third_party/libosmium/examples/osmium_dump_internal.cpp
+++ b/third_party/libosmium/examples/osmium_dump_internal.cpp
@@ -29,7 +29,6 @@
 */
 
 #include <cerrno>      // for errno
-#include <cstdlib>     // for std::exit
 #include <cstring>     // for std::strerror
 #include <iostream>    // for std::cout, std::cerr
 #include <string>      // for std::string
@@ -73,8 +72,7 @@ public:
     explicit IndexFile(const std::string& filename) :
         m_fd(::open(filename.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666)) { // NOLINT(hicpp-signed-bitwise)
         if (m_fd < 0) {
-            std::cerr << "Can't open index file '" << filename << "': " << std::strerror(errno) << "\n";
-            std::exit(2);
+            throw std::system_error{errno, std::system_category(), "Can't open index file '" + filename};
         }
 #ifdef _WIN32
         _setmode(m_fd, _O_BINARY);
@@ -102,95 +100,101 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE DIR\n";
-        std::exit(2);
+        return 2;
     }
 
-    const std::string input_file_name{argv[1]};
-    const std::string output_dir{argv[2]};
+    try {
+        const std::string input_file_name{argv[1]};
+        const std::string output_dir{argv[2]};
 
-    // Create output directory. Ignore the error if it already exists.
+        // Create output directory. Ignore the error if it already exists.
 #ifndef _WIN32
-    const int result = ::mkdir(output_dir.c_str(), 0777);
+        const int result = ::mkdir(output_dir.c_str(), 0777);
 #else
-    const int result = mkdir(output_dir.c_str());
+        const int result = mkdir(output_dir.c_str());
 #endif
-    if (result == -1 && errno != EEXIST) {
-        std::cerr << "Problem creating directory '" << output_dir << "': " << std::strerror(errno) << "\n";
-        std::exit(2);
-    }
+        if (result == -1 && errno != EEXIST) {
+            std::cerr << "Problem creating directory '" << output_dir << "': " << std::strerror(errno) << "\n";
+            return 2;
+        }
 
-    // Create the output file which will contain our serialized OSM data
-    const std::string data_file{output_dir + "/data.osm.ser"};
-    const int data_fd = ::open(data_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
-    if (data_fd < 0) {
-        std::cerr << "Can't open data file '" << data_file << "': " << std::strerror(errno) << "\n";
-        std::exit(2);
-    }
+        // Create the output file which will contain our serialized OSM data
+        const std::string data_file{output_dir + "/data.osm.ser"};
+        const int data_fd = ::open(data_file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
+        if (data_fd < 0) {
+            std::cerr << "Can't open data file '" << data_file << "': " << std::strerror(errno) << "\n";
+            return 2;
+        }
 
 #ifdef _WIN32
-    _setmode(data_fd, _O_BINARY);
+        _setmode(data_fd, _O_BINARY);
 #endif
 
-    // These indexes store the offset in the data file where each node, way,
-    // or relation is stored.
-    offset_index_type node_index;
-    offset_index_type way_index;
-    offset_index_type relation_index;
+        // These indexes store the offset in the data file where each node, way,
+        // or relation is stored.
+        offset_index_type node_index;
+        offset_index_type way_index;
+        offset_index_type relation_index;
 
-    // This handler will dump the internal data to disk using the given file
-    // descriptor while updating the indexes.
-    osmium::handler::DiskStore disk_store_handler{data_fd, node_index, way_index, relation_index};
+        // This handler will dump the internal data to disk using the given file
+        // descriptor while updating the indexes.
+        osmium::handler::DiskStore disk_store_handler{data_fd, node_index, way_index, relation_index};
 
-    // These indexes store the mapping from node id to the ids of the ways
-    // containing this node, and from node/way/relation ids to the ids of the
-    // relations containing those objects.
-    map_type map_node2way;
-    map_type map_node2relation;
-    map_type map_way2relation;
-    map_type map_relation2relation;
+        // These indexes store the mapping from node id to the ids of the ways
+        // containing this node, and from node/way/relation ids to the ids of the
+        // relations containing those objects.
+        map_type map_node2way;
+        map_type map_node2relation;
+        map_type map_way2relation;
+        map_type map_relation2relation;
 
-    // This handler will update the map indexes.
-    osmium::handler::ObjectRelations object_relations_handler{map_node2way, map_node2relation, map_way2relation, map_relation2relation};
+        // This handler will update the map indexes.
+        osmium::handler::ObjectRelations object_relations_handler{map_node2way, map_node2relation, map_way2relation, map_relation2relation};
 
-    // Read OSM data buffer by buffer.
-    osmium::io::Reader reader{input_file_name};
+        // Read OSM data buffer by buffer.
+        osmium::io::Reader reader{input_file_name};
 
-    while (osmium::memory::Buffer buffer = reader.read()) {
-        // Write buffer to disk and update indexes.
-        disk_store_handler(buffer);
+        while (osmium::memory::Buffer buffer = reader.read()) {
+            // Write buffer to disk and update indexes.
+            disk_store_handler(buffer);
 
-        // Update object relation index maps.
-        osmium::apply(buffer, object_relations_handler);
+            // Update object relation index maps.
+            osmium::apply(buffer, object_relations_handler);
+        }
+
+        reader.close();
+
+        // Write out node, way, and relation offset indexes to disk.
+        IndexFile nodes_idx{output_dir + "/nodes.idx"};
+        node_index.dump_as_list(nodes_idx.fd());
+
+        IndexFile ways_idx{output_dir + "/ways.idx"};
+        way_index.dump_as_list(ways_idx.fd());
+
+        IndexFile relations_idx{output_dir + "/relations.idx"};
+        relation_index.dump_as_list(relations_idx.fd());
+
+        // Sort the maps (so later binary search will work on them) and write
+        // them to disk.
+        map_node2way.sort();
+        IndexFile node2way_idx{output_dir + "/node2way.map"};
+        map_node2way.dump_as_list(node2way_idx.fd());
+
+        map_node2relation.sort();
+        IndexFile node2relation_idx{output_dir + "/node2rel.map"};
+        map_node2relation.dump_as_list(node2relation_idx.fd());
+
+        map_way2relation.sort();
+        IndexFile way2relation_idx{output_dir + "/way2rel.map"};
+        map_way2relation.dump_as_list(way2relation_idx.fd());
+
+        map_relation2relation.sort();
+        IndexFile relation2relation_idx{output_dir + "/rel2rel.map"};
+        map_relation2relation.dump_as_list(relation2relation_idx.fd());
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
-
-    reader.close();
-
-    // Write out node, way, and relation offset indexes to disk.
-    IndexFile nodes_idx{output_dir + "/nodes.idx"};
-    node_index.dump_as_list(nodes_idx.fd());
-
-    IndexFile ways_idx{output_dir + "/ways.idx"};
-    way_index.dump_as_list(ways_idx.fd());
-
-    IndexFile relations_idx{output_dir + "/relations.idx"};
-    relation_index.dump_as_list(relations_idx.fd());
-
-    // Sort the maps (so later binary search will work on them) and write
-    // them to disk.
-    map_node2way.sort();
-    IndexFile node2way_idx{output_dir + "/node2way.map"};
-    map_node2way.dump_as_list(node2way_idx.fd());
-
-    map_node2relation.sort();
-    IndexFile node2relation_idx{output_dir + "/node2rel.map"};
-    map_node2relation.dump_as_list(node2relation_idx.fd());
-
-    map_way2relation.sort();
-    IndexFile way2relation_idx{output_dir + "/way2rel.map"};
-    map_way2relation.dump_as_list(way2relation_idx.fd());
-
-    map_relation2relation.sort();
-    IndexFile relation2relation_idx{output_dir + "/rel2rel.map"};
-    map_relation2relation.dump_as_list(relation2relation_idx.fd());
 }
 
diff --git a/third_party/libosmium/examples/osmium_filter_discussions.cpp b/third_party/libosmium/examples/osmium_filter_discussions.cpp
index c4d092a0a..089b28ab2 100644
--- a/third_party/libosmium/examples/osmium_filter_discussions.cpp
+++ b/third_party/libosmium/examples/osmium_filter_discussions.cpp
@@ -22,7 +22,6 @@
 */
 
 #include <algorithm> // for std::copy_if
-#include <cstdlib>   // for std::exit
 #include <iostream>  // for std::cout, std::cerr
 
 // We want to read OSM files in XML format
@@ -43,50 +42,56 @@
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cout << "Usage: " << argv[0] << " INFILE OUTFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // The input file, deduce file format from file suffix.
-    osmium::io::File input_file{argv[1]};
+    try {
+        // The input file, deduce file format from file suffix.
+        osmium::io::File input_file{argv[1]};
 
-    // The output file, force XML OSM file format.
-    osmium::io::File output_file{argv[2], "osm"};
+        // The output file, force XML OSM file format.
+        osmium::io::File output_file{argv[2], "osm"};
 
-    // Initialize Reader for the input file.
-    // Read only changesets (will ignore nodes, ways, and
-    // relations if there are any).
-    osmium::io::Reader reader{input_file, osmium::osm_entity_bits::changeset};
+        // Initialize Reader for the input file.
+        // Read only changesets (will ignore nodes, ways, and
+        // relations if there are any).
+        osmium::io::Reader reader{input_file, osmium::osm_entity_bits::changeset};
 
-    // Get the header from the input file.
-    osmium::io::Header header = reader.header();
+        // Get the header from the input file.
+        osmium::io::Header header = reader.header();
 
-    // Set the "generator" on the header to ourselves.
-    header.set("generator", "osmium_filter_discussions");
+        // Set the "generator" on the header to ourselves.
+        header.set("generator", "osmium_filter_discussions");
 
-    // Initialize writer for the output file. Use the header from the input
-    // file for the output file. This will copy over some header information.
-    // The last parameter will tell the writer that it is allowed to overwrite
-    // an existing file. Without it, it will refuse to do so.
-    osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow};
+        // Initialize writer for the output file. Use the header from the input
+        // file for the output file. This will copy over some header information.
+        // The last parameter will tell the writer that it is allowed to overwrite
+        // an existing file. Without it, it will refuse to do so.
+        osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow};
 
-    // Create range of input iterators that will iterator over all changesets
-    // delivered from input file through the "reader".
-    auto input_range = osmium::io::make_input_iterator_range<osmium::Changeset>(reader);
+        // Create range of input iterators that will iterator over all changesets
+        // delivered from input file through the "reader".
+        auto input_range = osmium::io::make_input_iterator_range<osmium::Changeset>(reader);
 
-    // Create an output iterator writing through the "writer" object to the
-    // output file.
-    auto output_iterator = osmium::io::make_output_iterator(writer);
+        // Create an output iterator writing through the "writer" object to the
+        // output file.
+        auto output_iterator = osmium::io::make_output_iterator(writer);
 
-    // Copy all changesets from input to output that have at least one comment.
-    std::copy_if(input_range.begin(), input_range.end(), output_iterator, [](const osmium::Changeset& changeset) {
-        return changeset.num_comments() > 0;
-    });
+        // Copy all changesets from input to output that have at least one comment.
+        std::copy_if(input_range.begin(), input_range.end(), output_iterator, [](const osmium::Changeset& changeset) {
+            return changeset.num_comments() > 0;
+        });
 
-    // Explicitly close the writer and reader. Will throw an exception if
-    // there is a problem. If you wait for the destructor to close the writer
-    // and reader, you will not notice the problem, because destructors must
-    // not throw.
-    writer.close();
-    reader.close();
+        // Explicitly close the writer and reader. Will throw an exception if
+        // there is a problem. If you wait for the destructor to close the writer
+        // and reader, you will not notice the problem, because destructors must
+        // not throw.
+        writer.close();
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_index_lookup.cpp b/third_party/libosmium/examples/osmium_index_lookup.cpp
index 2f428bf7c..d58a743ed 100644
--- a/third_party/libosmium/examples/osmium_index_lookup.cpp
+++ b/third_party/libosmium/examples/osmium_index_lookup.cpp
@@ -70,7 +70,7 @@ public:
     IndexAccess(IndexAccess&&) = delete;
     IndexAccess& operator=(IndexAccess&&) = delete;
 
-    virtual ~IndexAccess() = default;
+    virtual ~IndexAccess() noexcept = default;
 
     virtual void dump() const = 0;
 
@@ -97,6 +97,14 @@ public:
         IndexAccess<TValue>(fd) {
     }
 
+    IndexAccessDense(const IndexAccessDense&) = default;
+    IndexAccessDense& operator=(const IndexAccessDense&) = default;
+
+    IndexAccessDense(IndexAccessDense&&) noexcept = default;
+    IndexAccessDense& operator=(IndexAccessDense&&) noexcept = default;
+
+    ~IndexAccessDense() noexcept override = default;
+
     void dump() const override {
         index_type index{this->fd()};
 
@@ -136,6 +144,14 @@ public:
         IndexAccess<TValue>(fd) {
     }
 
+    IndexAccessSparse(const IndexAccessSparse&) = default;
+    IndexAccessSparse& operator=(const IndexAccessSparse&) = default;
+
+    IndexAccessSparse(IndexAccessSparse&&) noexcept = default;
+    IndexAccessSparse& operator=(IndexAccessSparse&&) noexcept = default;
+
+    ~IndexAccessSparse() noexcept override = default;
+
     void dump() const override {
         index_type index{this->fd()};
 
@@ -182,7 +198,7 @@ class Options {
     bool m_array_format = false;
     bool m_list_format = false;
 
-    void print_help() {
+    static void print_help() {
         std::cout << "Usage: osmium_index_lookup [OPTIONS]\n\n"
                   << "-h, --help        Print this help message\n"
                   << "-a, --array=FILE  Read given index file in array format\n"
@@ -193,7 +209,7 @@ class Options {
         ;
     }
 
-    void print_usage(const char* prgname) {
+    static void print_usage(const char* prgname) {
         std::cout << "Usage: " << prgname << " [OPTIONS]\n\n";
         std::exit(0);
     }
@@ -338,7 +354,7 @@ int main(int argc, char* argv[]) {
     if (fd < 0) {
         std::cerr << "Can not open file '" << options.filename()
                   << "': " << std::strerror(errno) << '\n';
-        std::exit(2);
+        return 2;
     }
 
 #ifdef _WIN32
@@ -363,8 +379,9 @@ int main(int argc, char* argv[]) {
         const auto index = create<std::size_t>(options.dense_format(), fd);
         return run(*index, options);
     } catch (const std::exception& e) {
-        std::cerr << "Error: " << e.what() << '\n';
-        std::exit(1);
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
 }
 
diff --git a/third_party/libosmium/examples/osmium_location_cache_create.cpp b/third_party/libosmium/examples/osmium_location_cache_create.cpp
index d1b381082..7afa8b8a3 100644
--- a/third_party/libosmium/examples/osmium_location_cache_create.cpp
+++ b/third_party/libosmium/examples/osmium_location_cache_create.cpp
@@ -25,7 +25,6 @@
 */
 
 #include <cerrno>      // for errno
-#include <cstdlib>     // for std::exit
 #include <cstring>     // for strerror
 #include <fcntl.h>     // for open
 #include <iostream>    // for std::cout, std::cerr
@@ -62,33 +61,39 @@ using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " OSM_FILE CACHE_FILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string input_filename{argv[1]};
-    const std::string cache_filename{argv[2]};
+    try {
+        const std::string input_filename{argv[1]};
+        const std::string cache_filename{argv[2]};
 
-    // Construct Reader reading only nodes
-    osmium::io::Reader reader{input_filename, osmium::osm_entity_bits::node};
+        // Construct Reader reading only nodes
+        osmium::io::Reader reader{input_filename, osmium::osm_entity_bits::node};
 
-    // Initialize location index on disk creating a new file.
-    const int fd = ::open(cache_filename.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
-    if (fd == -1) {
-        std::cerr << "Can not open location cache file '" << cache_filename << "': " << std::strerror(errno) << "\n";
-        std::exit(1);
-    }
+        // Initialize location index on disk creating a new file.
+        const int fd = ::open(cache_filename.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0666); // NOLINT(hicpp-signed-bitwise)
+        if (fd == -1) {
+            std::cerr << "Can not open location cache file '" << cache_filename << "': " << std::strerror(errno) << "\n";
+            return 1;
+        }
 #ifdef _WIN32
-    _setmode(fd, _O_BINARY);
+        _setmode(fd, _O_BINARY);
 #endif
-    index_type index{fd};
+        index_type index{fd};
 
-    // The handler that stores all node locations in the index.
-    location_handler_type location_handler{index};
+        // The handler that stores all node locations in the index.
+        location_handler_type location_handler{index};
 
-    // Feed all nodes through the location handler.
-    osmium::apply(reader, location_handler);
+        // Feed all nodes through the location handler.
+        osmium::apply(reader, location_handler);
 
-    // Explicitly close input so we get notified of any errors.
-    reader.close();
+        // Explicitly close input so we get notified of any errors.
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_location_cache_use.cpp b/third_party/libosmium/examples/osmium_location_cache_use.cpp
index 6af0fe67a..533499670 100644
--- a/third_party/libosmium/examples/osmium_location_cache_use.cpp
+++ b/third_party/libosmium/examples/osmium_location_cache_use.cpp
@@ -25,7 +25,6 @@
 */
 
 #include <cerrno>      // for errno
-#include <cstdlib>     // for std::exit
 #include <cstring>     // for strerror
 #include <fcntl.h>     // for open
 #include <iostream>    // for std::cout, std::cerr
@@ -63,7 +62,9 @@ using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
 // ID and all nodes IDs and locations in those ways.
 struct MyHandler : public osmium::handler::Handler {
 
-    void way(const osmium::Way& way) {
+    // The callback functions can be either static or not depending on whether
+    // you need to access any member variables of the handler.
+    static void way(const osmium::Way& way) {
         std::cout << "way " << way.id() << "\n";
         for (const auto& nr : way.nodes()) {
             std::cout << "  node " << nr.ref() << " " << nr.location() << "\n";
@@ -75,34 +76,40 @@ struct MyHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 3) {
         std::cerr << "Usage: " << argv[0] << " OSM_FILE CACHE_FILE\n";
-        std::exit(1);
-    }
-
-    const std::string input_filename{argv[1]};
-    const std::string cache_filename{argv[2]};
-
-    // Construct Reader reading only ways
-    osmium::io::Reader reader{input_filename, osmium::osm_entity_bits::way};
-
-    // Initialize location index on disk using an existing file
-    const int fd = ::open(cache_filename.c_str(), O_RDWR);
-    if (fd == -1) {
-        std::cerr << "Can not open location cache file '" << cache_filename << "': " << std::strerror(errno) << "\n";
         return 1;
     }
+
+    try {
+        const std::string input_filename{argv[1]};
+        const std::string cache_filename{argv[2]};
+
+        // Construct Reader reading only ways
+        osmium::io::Reader reader{input_filename, osmium::osm_entity_bits::way};
+
+        // Initialize location index on disk using an existing file
+        const int fd = ::open(cache_filename.c_str(), O_RDWR);
+        if (fd == -1) {
+            std::cerr << "Can not open location cache file '" << cache_filename << "': " << std::strerror(errno) << "\n";
+            return 1;
+        }
 #ifdef _WIN32
-    _setmode(fd, _O_BINARY);
+        _setmode(fd, _O_BINARY);
 #endif
-    index_type index{fd};
+        index_type index{fd};
 
-    // The handler that adds node locations from the index to the ways.
-    location_handler_type location_handler{index};
+        // The handler that adds node locations from the index to the ways.
+        location_handler_type location_handler{index};
 
-    // Feed all ways through the location handler and then our own handler.
-    MyHandler handler;
-    osmium::apply(reader, location_handler, handler);
+        // Feed all ways through the location handler and then our own handler.
+        MyHandler handler;
+        osmium::apply(reader, location_handler, handler);
 
-    // Explicitly close input so we get notified of any errors.
-    reader.close();
+        // Explicitly close input so we get notified of any errors.
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_pub_names.cpp b/third_party/libosmium/examples/osmium_pub_names.cpp
index dbc37c332..087eec715 100644
--- a/third_party/libosmium/examples/osmium_pub_names.cpp
+++ b/third_party/libosmium/examples/osmium_pub_names.cpp
@@ -18,7 +18,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <cstring>  // for std::strncmp
 #include <iostream> // for std::cout, std::cerr
 
@@ -33,7 +32,7 @@
 
 class NamesHandler : public osmium::handler::Handler {
 
-    void output_pubs(const osmium::OSMObject& object) {
+    static void output_pubs(const osmium::OSMObject& object) {
         const osmium::TagList& tags = object.tags();
         if (tags.has_tag("amenity", "pub")) {
 
@@ -57,13 +56,17 @@ class NamesHandler : public osmium::handler::Handler {
 
 public:
 
+    // The callback functions can be either static or not depending on whether
+    // you need to access any member variables of the handler.
     // Nodes can be tagged amenity=pub.
-    void node(const osmium::Node& node) {
+    static void node(const osmium::Node& node) {
         output_pubs(node);
     }
 
+    // The callback functions can be either static or not depending on whether
+    // you need to access any member variables of the handler.
     // Ways can be tagged amenity=pub, too (typically buildings).
-    void way(const osmium::Way& way) {
+    static void way(const osmium::Way& way) {
         output_pubs(way);
     }
 
@@ -72,18 +75,24 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // Construct the handler defined above
-    NamesHandler names_handler;
+    try {
+        // Construct the handler defined above
+        NamesHandler names_handler;
 
-    // Initialize the reader with the filename from the command line and
-    // tell it to only read nodes and ways. We are ignoring multipolygon
-    // relations in this simple example.
-    osmium::io::Reader reader{argv[1], osmium::osm_entity_bits::node | osmium::osm_entity_bits::way};
+        // Initialize the reader with the filename from the command line and
+        // tell it to only read nodes and ways. We are ignoring multipolygon
+        // relations in this simple example.
+        osmium::io::Reader reader{argv[1], osmium::osm_entity_bits::node | osmium::osm_entity_bits::way};
 
-    // Apply input data to our own handler
-    osmium::apply(reader, names_handler);
+        // Apply input data to our own handler
+        osmium::apply(reader, names_handler);
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_read.cpp b/third_party/libosmium/examples/osmium_read.cpp
index 9f391c874..bf0203fbd 100644
--- a/third_party/libosmium/examples/osmium_read.cpp
+++ b/third_party/libosmium/examples/osmium_read.cpp
@@ -13,7 +13,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cerr
 
 // Allow any format of input files (XML, PBF, ...)
@@ -22,21 +21,27 @@
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // The Reader is initialized here with an osmium::io::File, but could
-    // also be directly initialized with a file name.
-    osmium::io::File input_file{argv[1]};
-    osmium::io::Reader reader{input_file};
+    try {
+        // The Reader is initialized here with an osmium::io::File, but could
+        // also be directly initialized with a file name.
+        osmium::io::File input_file{argv[1]};
+        osmium::io::Reader reader{input_file};
 
-    // OSM data comes in buffers, read until there are no more.
-    while (osmium::memory::Buffer buffer = reader.read()) {
-        // do nothing
+        // OSM data comes in buffers, read until there are no more.
+        while (osmium::memory::Buffer buffer = reader.read()) {
+            // do nothing
+        }
+
+        // You do not have to close the Reader explicitly, but because the
+        // destructor can't throw, you will not see any errors otherwise.
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
-
-    // You do not have to close the Reader explicitly, but because the
-    // destructor can't throw, you will not see any errors otherwise.
-    reader.close();
 }
 
diff --git a/third_party/libosmium/examples/osmium_read_with_progress.cpp b/third_party/libosmium/examples/osmium_read_with_progress.cpp
index 415e78de8..9cf752d1f 100644
--- a/third_party/libosmium/examples/osmium_read_with_progress.cpp
+++ b/third_party/libosmium/examples/osmium_read_with_progress.cpp
@@ -16,7 +16,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cerr
 
 // Allow any format of input files (XML, PBF, ...)
@@ -29,28 +28,34 @@
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // The Reader is initialized here with an osmium::io::File, but could
-    // also be directly initialized with a file name.
-    osmium::io::File input_file{argv[1]};
-    osmium::io::Reader reader{input_file};
+    try {
+        // The Reader is initialized here with an osmium::io::File, but could
+        // also be directly initialized with a file name.
+        osmium::io::File input_file{argv[1]};
+        osmium::io::Reader reader{input_file};
 
-    // Initialize progress bar, enable it only if STDERR is a TTY.
-    osmium::ProgressBar progress{reader.file_size(), osmium::isatty(2)};
+        // Initialize progress bar, enable it only if STDERR is a TTY.
+        osmium::ProgressBar progress{reader.file_size(), osmium::isatty(2)};
 
-    // OSM data comes in buffers, read until there are no more.
-    while (osmium::memory::Buffer buffer = reader.read()) {
-        // Update progress bar for each buffer.
-        progress.update(reader.offset());
+        // OSM data comes in buffers, read until there are no more.
+        while (osmium::memory::Buffer buffer = reader.read()) {
+            // Update progress bar for each buffer.
+            progress.update(reader.offset());
+        }
+
+        // Progress bar is done.
+        progress.done();
+
+        // You do not have to close the Reader explicitly, but because the
+        // destructor can't throw, you will not see any errors otherwise.
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
     }
-
-    // Progress bar is done.
-    progress.done();
-
-    // You do not have to close the Reader explicitly, but because the
-    // destructor can't throw, you will not see any errors otherwise.
-    reader.close();
 }
 
diff --git a/third_party/libosmium/examples/osmium_road_length.cpp b/third_party/libosmium/examples/osmium_road_length.cpp
index 4aced95f8..2b2a44a99 100644
--- a/third_party/libosmium/examples/osmium_road_length.cpp
+++ b/third_party/libosmium/examples/osmium_road_length.cpp
@@ -20,7 +20,6 @@
 
 */
 
-#include <cstdlib>  // for std::exit
 #include <iostream> // for std::cout, std::cerr
 
 // Allow any format of input files (XML, PBF, ...)
@@ -65,28 +64,34 @@ struct RoadLengthHandler : public osmium::handler::Handler {
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " OSMFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    // Initialize the reader with the filename from the command line and
-    // tell it to only read nodes and ways.
-    osmium::io::Reader reader{argv[1], osmium::osm_entity_bits::node | osmium::osm_entity_bits::way};
+    try {
+        // Initialize the reader with the filename from the command line and
+        // tell it to only read nodes and ways.
+        osmium::io::Reader reader{argv[1], osmium::osm_entity_bits::node | osmium::osm_entity_bits::way};
 
-    // The index to hold node locations.
-    index_type index;
+        // The index to hold node locations.
+        index_type index;
 
-    // The location handler will add the node locations to the index and then
-    // to the ways
-    location_handler_type location_handler{index};
+        // The location handler will add the node locations to the index and then
+        // to the ways
+        location_handler_type location_handler{index};
 
-    // Our handler defined above
-    RoadLengthHandler road_length_handler;
+        // Our handler defined above
+        RoadLengthHandler road_length_handler;
 
-    // Apply input data to first the location handler and then our own handler
-    osmium::apply(reader, location_handler, road_length_handler);
+        // Apply input data to first the location handler and then our own handler
+        osmium::apply(reader, location_handler, road_length_handler);
 
-    // Output the length. The haversine function calculates it in meters,
-    // so we first devide by 1000 to get kilometers.
-    std::cout << "Length: " << road_length_handler.length / 1000 << " km\n";
+        // Output the length. The haversine function calculates it in meters,
+        // so we first devide by 1000 to get kilometers.
+        std::cout << "Length: " << road_length_handler.length / 1000 << " km\n";
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
 }
 
diff --git a/third_party/libosmium/examples/osmium_tags_filter.cpp b/third_party/libosmium/examples/osmium_tags_filter.cpp
new file mode 100644
index 000000000..ea62ba73c
--- /dev/null
+++ b/third_party/libosmium/examples/osmium_tags_filter.cpp
@@ -0,0 +1,171 @@
+/*
+
+  EXAMPLE osmium_filter
+
+  Filter OSM files
+
+  DEMONSTRATES USE OF:
+  * file input and output
+  * file types
+  * Osmium buffers
+  * Tags filter
+
+  SIMPLER EXAMPLES you might want to understand first:
+  * osmium_convert
+
+  LICENSE
+  The code in this example file is released into the Public Domain.
+
+*/
+
+#include <cstring>   // for std::strcmp
+#include <exception> // for std::exception
+#include <iostream>  // for std::cout, std::cerr
+#include <string>    // for std::string
+
+// Allow any format of input files (XML, PBF, ...)
+#include <osmium/io/any_input.hpp>
+
+// Allow any format of output files (XML, PBF, ...)
+#include <osmium/io/any_output.hpp>
+
+#include <osmium/tags/taglist.hpp>
+#include <osmium/tags/tags_filter.hpp>
+
+void print_help() {
+    std::cout << "osmium_filter [OPTIONS] [INFILE [OUTFILE]]\n\n" \
+              << "If INFILE or OUTFILE is not given stdin/stdout is assumed.\n" \
+              << "File format is autodetected from file name suffix.\n" \
+              << "Use -f and -t options to force file format.\n" \
+              << "\nFile types:\n" \
+              << "  osm        normal OSM file\n" \
+              << "  osc        OSM change file\n" \
+              << "  osh        OSM file with history information\n" \
+              << "\nFile format:\n" \
+              << "  (default)  XML encoding\n" \
+              << "  pbf        binary PBF encoding\n" \
+              << "  opl        OPL encoding\n" \
+              << "\nFile compression\n" \
+              << "  gz         compressed with gzip\n" \
+              << "  bz2        compressed with bzip2\n" \
+              << "\nOptions:\n" \
+              << "  -h, --help                This help message\n" \
+              << "  -f, --from-format=FORMAT  Input format\n" \
+              << "  -t, --to-format=FORMAT    Output format\n";
+}
+
+void print_usage(const char* prgname) {
+    std::cerr << "Usage: " << prgname << " [OPTIONS] [INFILE [OUTFILE]]\n";
+}
+
+int main(int argc, char* argv[]) {
+    if (argc == 1) {
+        print_usage(argv[0]);
+        return 0;
+    }
+
+    if (argc > 1 && (!std::strcmp(argv[1], "-h") ||
+                     !std::strcmp(argv[1], "--help"))) {
+        print_help();
+        return 0;
+    }
+
+    // Input and output format are empty by default. Later this will mean that
+    // the format should be taken from the input and output file suffix,
+    // respectively.
+    std::string input_format;
+    std::string output_format;
+
+    std::string input_file_name;
+    std::string output_file_name;
+
+    for (int i = 1; i < argc; ++i) {
+        if (!std::strcmp(argv[i], "-f") || !std::strcmp(argv[i], "--from-format")) {
+            ++i;
+            if (i < argc) {
+                input_format = argv[i];
+            } else {
+                print_usage(argv[0]);
+                return 1;
+            }
+        } else if (!std::strncmp(argv[i], "--from-format=", 14)) {
+            input_format = argv[i] + 14;
+        } else if (!std::strcmp(argv[i], "-t") || !std::strcmp(argv[i], "--to-format")) {
+            ++i;
+            if (i < argc) {
+                output_format = argv[i];
+            } else {
+                print_usage(argv[0]);
+                return 1;
+            }
+        } else if (!std::strncmp(argv[i], "--to-format=", 12)) {
+            output_format = argv[i] + 12;
+        } else if (input_file_name.empty()) {
+            input_file_name = argv[i];
+        } else if (output_file_name.empty()) {
+            output_file_name = argv[i];
+        } else {
+            print_usage(argv[0]);
+            return 1;
+        }
+    }
+
+    // This declares the input and output files using either the suffix of
+    // the file names or the format in the 2nd argument. It does not yet open
+    // the files.
+    const osmium::io::File input_file{input_file_name, input_format};
+    const osmium::io::File output_file{output_file_name, output_format};
+
+    // Input and output files can be OSM data files (without history) or
+    // OSM history files. History files are detected if they use the '.osh'
+    // file suffix.
+    if (  input_file.has_multiple_object_versions() &&
+        !output_file.has_multiple_object_versions()) {
+        std::cerr << "Warning! You are converting from an OSM file with (potentially) several versions of the same object to one that is not marked as such.\n";
+    }
+
+    try {
+        // Initialize Reader
+        osmium::io::Reader reader{input_file};
+
+        // Get header from input file and change the "generator" setting to
+        // ourselves.
+        osmium::io::Header header = reader.header();
+        header.set("generator", "osmium_convert");
+
+        // Initialize Writer using the header from above and tell it that it
+        // is allowed to overwrite a possibly existing file.
+        osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow};
+
+        // Match highway=primary or highway=secondary
+        osmium::TagsFilter filter1{false};
+        filter1.add_rule(true, "highway", "primary");
+        filter1.add_rule(true, "highway", "secondary");
+
+        // Match oneway=yes
+        osmium::TagsFilter filter2{false};
+        filter2.add_rule(true, "oneway", "yes");
+
+        // Get all object matching both filters
+        while (osmium::memory::Buffer buffer = reader.read()) { // NOLINT(bugprone-use-after-move) Bug in clang-tidy https://bugs.llvm.org/show_bug.cgi?id=36516
+            for (const auto& object : buffer.select<osmium::OSMObject>()) {
+                if (osmium::tags::match_any_of(object.tags(), filter1) &&
+                    osmium::tags::match_any_of(object.tags(), filter2)) {
+                    writer(object);
+                }
+            }
+        }
+
+        // Explicitly close the writer and reader. Will throw an exception if
+        // there is a problem. If you wait for the destructor to close the writer
+        // and reader, you will not notice the problem, because destructors must
+        // not throw.
+        writer.close();
+        reader.close();
+    } catch (const std::exception& e) {
+        // All exceptions used by the Osmium library derive from std::exception.
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+}
+
diff --git a/third_party/libosmium/examples/osmium_tiles.cpp b/third_party/libosmium/examples/osmium_tiles.cpp
index 52a1a1f5d..27c1721be 100644
--- a/third_party/libosmium/examples/osmium_tiles.cpp
+++ b/third_party/libosmium/examples/osmium_tiles.cpp
@@ -15,7 +15,7 @@
 
 */
 
-#include <cstdlib>  // for std::exit, std::atoi, std::atof
+#include <cstdlib>  // for std::atoi, std::atof
 #include <iostream> // for std::cout, std::cerr
 
 // The Location contains a longitude and latitude and is usually used inside
@@ -33,14 +33,14 @@
 int main(int argc, char* argv[]) {
     if (argc != 4) {
         std::cerr << "Usage: " << argv[0] << " ZOOM LON LAT\n";
-        std::exit(1);
+        return 1;
     }
 
     const int zoom = std::atoi(argv[1]); // NOLINT(cert-err34-c)
 
     if (zoom < 0 || zoom > 30) {
         std::cerr << "ERROR: Zoom must be between 0 and 30\n";
-        std::exit(1);
+        return 1;
     }
 
     osmium::Location location{};
@@ -49,14 +49,14 @@ int main(int argc, char* argv[]) {
         location.set_lat(argv[3]);
     } catch (const osmium::invalid_location&) {
         std::cerr << "ERROR: Location is invalid\n";
-        std::exit(1);
+        return 1;
     }
 
     // A location can store some invalid locations, ie locations outside the
     // -180 to 180 and -90 to 90 degree range. This function checks for that.
     if (!location.valid()) {
         std::cerr << "ERROR: Location is invalid\n";
-        std::exit(1);
+        return 1;
     }
 
     std::cout << "WGS84:    lon=" << location.lon() << " lat=" << location.lat() << "\n";
diff --git a/third_party/libosmium/include/gdalcpp.hpp b/third_party/libosmium/include/gdalcpp.hpp
index 4f3d48096..45b5cea2a 100644
--- a/third_party/libosmium/include/gdalcpp.hpp
+++ b/third_party/libosmium/include/gdalcpp.hpp
@@ -5,11 +5,11 @@
 
 C++11 wrapper classes for GDAL/OGR.
 
-Version 1.1.1
+Version 1.3.0
 
 https://github.com/joto/gdalcpp
 
-Copyright 2015 Jochen Topf <jochen@topf.org>
+Copyright 2015-2021 Jochen Topf <jochen@topf.org>
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -37,17 +37,25 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <algorithm>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
 #include <gdal_priv.h>
 #include <gdal_version.h>
 #include <ogr_api.h>
 #include <ogrsf_frmts.h>
 
+#include <cstdint>
+#include <algorithm>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if defined(_MSC_VER)
+# define GDALCPP_EXPORT __declspec(dllexport)
+#else
+# define GDALCPP_EXPORT __attribute__ ((visibility("default")))
+#endif
+
 namespace gdalcpp {
 
 #if GDAL_VERSION_MAJOR >= 2
@@ -61,7 +69,7 @@ namespace gdalcpp {
     /**
      * Exception thrown for all errors in this class.
      */
-    class gdal_error : public std::runtime_error {
+    class GDALCPP_EXPORT gdal_error : public std::runtime_error {
 
         std::string m_driver;
         std::string m_dataset;
@@ -85,23 +93,23 @@ namespace gdalcpp {
             m_error(error) {
         }
 
-        const std::string& driver() const {
+        const std::string& driver() const noexcept {
             return m_driver;
         }
 
-        const std::string& dataset() const {
+        const std::string& dataset() const noexcept {
             return m_dataset;
         }
 
-        const std::string& layer() const {
+        const std::string& layer() const noexcept {
             return m_layer;
         }
 
-        const std::string& field() const {
+        const std::string& field() const noexcept {
             return m_field;
         }
 
-        OGRErr error() const {
+        OGRErr error() const noexcept {
             return m_error;
         }
 
@@ -111,18 +119,26 @@ namespace gdalcpp {
 
         struct init_wrapper {
 #if GDAL_VERSION_MAJOR >= 2
-            init_wrapper() { GDALAllRegister(); }
+            init_wrapper() noexcept {
+                GDALAllRegister();
+            }
 #else
-            init_wrapper() { OGRRegisterAll(); }
-            ~init_wrapper() { OGRCleanupAll(); }
+            init_wrapper() noexcept {
+                OGRRegisterAll();
+            }
+            ~init_wrapper() noexcept {
+                OGRCleanupAll();
+            }
 #endif
-        };
+        }; // struct init_wrapper
 
         struct init_library {
+
             init_library() {
                 static init_wrapper iw;
             }
-        };
+
+        }; // struct init_library
 
         class Driver : private init_library {
 
@@ -138,11 +154,13 @@ namespace gdalcpp {
                 m_driver(OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName(driver_name.c_str())) {
 #endif
                 if (!m_driver) {
-                    throw gdal_error(std::string("unknown driver: '") + driver_name + "'", OGRERR_NONE, driver_name);
+                    throw gdal_error{std::string{"unknown driver: '"} + driver_name + "'",
+                                     OGRERR_NONE,
+                                     driver_name};
                 }
             }
 
-            gdal_driver_type& get() const {
+            gdal_driver_type& get() const noexcept {
                 return *m_driver;
             }
 
@@ -155,14 +173,14 @@ namespace gdalcpp {
 
             Options(const std::vector<std::string>& options) :
                 m_options(options),
-                m_ptrs(new const char*[options.size()+1]) {
+                m_ptrs(new const char*[options.size() + 1]) {
                 std::transform(m_options.begin(), m_options.end(), m_ptrs.get(), [&](const std::string& s) {
                     return s.data();
                 });
                 m_ptrs[options.size()] = nullptr;
             }
 
-            char** get() const {
+            char** get() const noexcept {
                 return const_cast<char**>(m_ptrs.get());
             }
 
@@ -178,33 +196,37 @@ namespace gdalcpp {
 
         SRS() :
             m_spatial_reference() {
-            auto result = m_spatial_reference.SetWellKnownGeogCS("WGS84");
+            const auto result = m_spatial_reference.SetWellKnownGeogCS("CRS84");
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("can not initialize spatial reference system WGS84"), result);
+                throw gdal_error{std::string{"can not initialize spatial reference system WGS84"},
+                                 result};
             }
         }
 
         explicit SRS(int epsg) :
             m_spatial_reference() {
-            auto result = m_spatial_reference.importFromEPSG(epsg);
+            const auto result = m_spatial_reference.importFromEPSG(epsg);
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("can not initialize spatial reference system for EPSG:") + std::to_string(epsg), result);
+                throw gdal_error{std::string{"can not initialize spatial reference system for EPSG:"} + std::to_string(epsg),
+                                 result};
             }
         }
 
         explicit SRS(const char* name) :
             m_spatial_reference() {
-            auto result = m_spatial_reference.importFromProj4(name);
+            const auto result = m_spatial_reference.importFromProj4(name);
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("can not initialize spatial reference system '") + name + "'", result);
+                throw gdal_error{std::string{"can not initialize spatial reference system '"} + name + "'",
+                                 result};
             }
         }
 
         explicit SRS(const std::string& name) :
             m_spatial_reference() {
-            auto result = m_spatial_reference.importFromProj4(name.c_str());
+            const auto result = m_spatial_reference.importFromProj4(name.c_str());
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("can not initialize spatial reference system '") + name + "'", result);
+                throw gdal_error{std::string{"can not initialize spatial reference system '"} + name + "'",
+                                 result};
             }
         }
 
@@ -212,11 +234,11 @@ namespace gdalcpp {
             m_spatial_reference(spatial_reference) {
         }
 
-        OGRSpatialReference& get() {
+        OGRSpatialReference& get() noexcept {
             return m_spatial_reference;
         }
 
-        const OGRSpatialReference& get() const {
+        const OGRSpatialReference& get() const noexcept {
             return m_spatial_reference;
         }
 
@@ -257,11 +279,14 @@ namespace gdalcpp {
             m_dataset(detail::Driver(driver_name).get().CreateDataSource(dataset_name.c_str(), m_options.get())) {
 #endif
             if (!m_dataset) {
-                throw gdal_error(std::string("failed to create dataset '") + dataset_name + "'", OGRERR_NONE, driver_name, dataset_name);
+                throw gdal_error{std::string{"failed to create dataset '"} + dataset_name + "'",
+                                 OGRERR_NONE,
+                                 driver_name,
+                                 dataset_name};
             }
         }
 
-        ~Dataset() {
+        ~Dataset() noexcept {
             try {
                 if (m_edit_count > 0) {
                     commit_transaction();
@@ -270,24 +295,24 @@ namespace gdalcpp {
             }
         }
 
-        const std::string& driver_name() const {
+        const std::string& driver_name() const noexcept {
             return m_driver_name;
         }
 
-        const std::string& dataset_name() const {
+        const std::string& dataset_name() const noexcept {
             return m_dataset_name;
         }
 
-        gdal_dataset_type& get() const {
+        gdal_dataset_type& get() const noexcept {
             return *m_dataset;
         }
 
-        SRS& srs() {
+        SRS& srs() noexcept {
             return m_srs;
         }
 
         void exec(const char* sql) {
-            auto result = m_dataset->ExecuteSQL(sql, nullptr, nullptr);
+            const auto result = m_dataset->ExecuteSQL(sql, nullptr, nullptr);
             if (result) {
                 m_dataset->ReleaseResultSet(result);
             }
@@ -334,7 +359,7 @@ namespace gdalcpp {
             }
         }
 
-        Dataset& enable_auto_transactions(uint64_t edits = 100000) {
+        Dataset& enable_auto_transactions(uint64_t edits = 100000) noexcept {
             m_max_edit_count = edits;
             return *this;
         }
@@ -362,20 +387,23 @@ namespace gdalcpp {
             m_dataset(dataset),
             m_layer(dataset.get().CreateLayer(layer_name.c_str(), &dataset.srs().get(), type, m_options.get())) {
             if (!m_layer) {
-                throw gdal_error(std::string("failed to create layer '") + layer_name + "'", OGRERR_NONE,
-                    dataset.driver_name(), dataset.dataset_name(), layer_name);
+                throw gdal_error{std::string{"failed to create layer '"} + layer_name + "'",
+                                 OGRERR_NONE,
+                                 dataset.driver_name(),
+                                 dataset.dataset_name(),
+                                 layer_name};
             }
         }
 
-        OGRLayer& get() {
+        OGRLayer& get() noexcept {
             return *m_layer;
         }
 
-        const OGRLayer& get() const {
+        const OGRLayer& get() const noexcept {
             return *m_layer;
         }
 
-        Dataset& dataset() const {
+        Dataset& dataset() const noexcept {
             return m_dataset;
         }
 
@@ -389,8 +417,12 @@ namespace gdalcpp {
             field.SetPrecision(precision);
 
             if (m_layer->CreateField(&field) != OGRERR_NONE) {
-                throw gdal_error(std::string("failed to create field '") + field_name + "' in layer '" + name() + "'", OGRERR_NONE,
-                    m_dataset.driver_name(), m_dataset.dataset_name(), name(), field_name);
+                throw gdal_error{std::string{"failed to create field '"} + field_name + "' in layer '" + name() + "'",
+                                 OGRERR_NONE,
+                                 m_dataset.driver_name(),
+                                 m_dataset.dataset_name(),
+                                 name(),
+                                 field_name};
             }
 
             return *this;
@@ -398,18 +430,25 @@ namespace gdalcpp {
 
         void create_feature(OGRFeature* feature) {
             dataset().prepare_edit();
-            OGRErr result = m_layer->CreateFeature(feature);
+            const auto result = m_layer->CreateFeature(feature);
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("creating feature in layer '") + name() + "' failed", result, dataset().driver_name(), dataset().dataset_name());
+                throw gdal_error{std::string{"creating feature in layer '"} + name() + "' failed",
+                                 result,
+                                 dataset().driver_name(),
+                                 dataset().dataset_name()};
             }
             dataset().finalize_edit();
         }
 
         Layer& start_transaction() {
 #if GDAL_VERSION_MAJOR < 2
-            OGRErr result = m_layer->StartTransaction();
+            const auto result = m_layer->StartTransaction();
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("starting transaction on layer '") + name() + "' failed", result, m_dataset.driver_name(), m_dataset.dataset_name(), name());
+                throw gdal_error{std::string{"starting transaction on layer '"} + name() + "' failed",
+                                 result,
+                                 m_dataset.driver_name(),
+                                 m_dataset.dataset_name(),
+                                 name()};
             }
 #endif
             return *this;
@@ -417,9 +456,13 @@ namespace gdalcpp {
 
         Layer& commit_transaction() {
 #if GDAL_VERSION_MAJOR < 2
-            OGRErr result = m_layer->CommitTransaction();
+            const auto result = m_layer->CommitTransaction();
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("committing transaction on layer '") + name() + "' failed", result, m_dataset.driver_name(), m_dataset.dataset_name(), name());
+                throw gdal_error{std::string{"committing transaction on layer '"} + name() + "' failed",
+                                 result,
+                                 m_dataset.driver_name(),
+                                 m_dataset.dataset_name(),
+                                 name()};
             }
 #endif
             return *this;
@@ -446,11 +489,14 @@ namespace gdalcpp {
             m_layer(layer),
             m_feature(OGRFeature::CreateFeature(m_layer.get().GetLayerDefn())) {
             if (!m_feature) {
-                throw std::bad_alloc();
+                throw std::bad_alloc{};
             }
-            OGRErr result = m_feature->SetGeometryDirectly(geometry.release());
+            const auto result = m_feature->SetGeometryDirectly(geometry.release());
             if (result != OGRERR_NONE) {
-                throw gdal_error(std::string("setting feature geometry in layer '") + m_layer.name() + "' failed", result, m_layer.dataset().driver_name(), m_layer.dataset().dataset_name());
+                throw gdal_error{std::string{"setting feature geometry in layer '"} + m_layer.name() + "' failed",
+                                 result,
+                                 m_layer.dataset().driver_name(),
+                                 m_layer.dataset().dataset_name()};
             }
         }
 
@@ -458,13 +504,13 @@ namespace gdalcpp {
             m_layer.create_feature(m_feature.get());
         }
 
-        template <class T>
+        template <typename T>
         Feature& set_field(int n, T&& arg) {
             m_feature->SetField(n, std::forward<T>(arg));
             return *this;
         }
 
-        template <class T>
+        template <typename T>
         Feature& set_field(const char* name, T&& arg) {
             m_feature->SetField(name, std::forward<T>(arg));
             return *this;
@@ -474,4 +520,6 @@ namespace gdalcpp {
 
 } // namespace gdalcpp
 
+#undef GDALCPP_EXPORT
+
 #endif // GDALCPP_HPP
diff --git a/third_party/libosmium/include/osmium/area/assembler.hpp b/third_party/libosmium/include/osmium/area/assembler.hpp
index 29fd6a596..cc9ac2c62 100644
--- a/third_party/libosmium/include/osmium/area/assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/assembler_config.hpp b/third_party/libosmium/include/osmium/area/assembler_config.hpp
index fce53badb..1a999d3a9 100644
--- a/third_party/libosmium/include/osmium/area/assembler_config.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler_config.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/util/compatibility.hpp>
-
 namespace osmium {
 
     namespace area {
@@ -135,16 +133,6 @@ namespace osmium {
                 debug_level(d) {
             }
 
-            /**
-             * Enable or disable debug output to stderr. This is for Osmium
-             * developers only.
-             *
-             * @deprecated Set debug_level directly.
-             */
-            OSMIUM_DEPRECATED void enable_debug_output(bool d = true) {
-                debug_level = d;
-            }
-
         }; // struct AssemblerConfig
 
     } // namespace area
diff --git a/third_party/libosmium/include/osmium/area/assembler_legacy.hpp b/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
index 2531ad863..0ca48735c 100644
--- a/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
+++ b/third_party/libosmium/include/osmium/area/assembler_legacy.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -72,10 +72,6 @@ namespace osmium {
          */
         class AssemblerLegacy : public detail::BasicAssemblerWithTags {
 
-            void add_tags_to_area(osmium::builder::AreaBuilder& builder, const osmium::Way& way) const {
-                builder.add_item(way.tags());
-            }
-
             void add_common_tags(osmium::builder::TagListBuilder& tl_builder, std::set<const osmium::Way*>& ways) const {
                 std::map<std::string, std::size_t> counter;
                 for (const osmium::Way* way : ways) {
@@ -166,7 +162,7 @@ namespace osmium {
 
                 const bool area_okay = create_rings();
                 if (area_okay || config().create_empty_areas) {
-                    add_tags_to_area(builder, way);
+                    builder.add_item(way.tags());
                 }
                 if (area_okay) {
                     add_rings_to_area(builder);
@@ -340,8 +336,11 @@ namespace osmium {
                                     osmium::tags::KeyFilter::iterator way_fi_end(std::cref(filter()), way.tags().cend(), way.tags().cend());
                                     osmium::tags::KeyFilter::iterator area_fi_begin(std::cref(filter()), area_tags.cbegin(), area_tags.cend());
                                     osmium::tags::KeyFilter::iterator area_fi_end(std::cref(filter()), area_tags.cend(), area_tags.cend());
-
-                                    if (!std::equal(way_fi_begin, way_fi_end, area_fi_begin) || d != std::distance(area_fi_begin, area_fi_end)) {
+#ifdef __cpp_lib_robust_nonmodifying_seq_ops
+                                    if (!std::equal(way_fi_begin, way_fi_end, area_fi_begin, area_fi_end)) {
+#else
+                                    if (d != std::distance(area_fi_begin, area_fi_end) || !std::equal(way_fi_begin, way_fi_end, area_fi_begin)) {
+#endif
                                         ways_that_should_be_areas.push_back(&way);
                                     } else {
                                         ++stats().inner_with_same_tags;
diff --git a/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp b/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
index 485d22239..0fa8feb43 100644
--- a/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/basic_assembler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -51,6 +51,7 @@ DEALINGS IN THE SOFTWARE.
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
+#include <exception>
 #include <iostream>
 #include <iterator>
 #include <list>
@@ -103,9 +104,19 @@ namespace osmium {
              */
             class BasicAssembler {
 
+                static constexpr const std::size_t max_split_locations = 100ULL;
+
+                // Maximum recursion depth, stops complex multipolygons from
+                // breaking everything.
+                enum : unsigned {
+                    max_depth = 20U
+                };
+
                 struct slocation {
 
-                    static constexpr const uint32_t invalid_item = 1u << 30u;
+                    enum {
+                        invalid_item = 1U << 30U
+                    };
 
                     uint32_t item : 31;
                     uint32_t reverse : 1;
@@ -185,7 +196,7 @@ namespace osmium {
                                 ++m_stats.wrong_role;
                                 if (debug()) {
                                     std::cerr << "      Segment " << *segment << " from way " << segment->way()->id() << " has role '" << segment->role_name()
-                                            << "', but should have role '" << (ring.is_outer() ? "outer" : "inner") << "'\n";
+                                              << "', but should have role '" << (ring.is_outer() ? "outer" : "inner") << "'\n";
                                 }
                                 if (m_config.problem_reporter) {
                                     if (ring.is_outer()) {
@@ -269,7 +280,7 @@ namespace osmium {
 
                 using rings_stack = std::vector<rings_stack_element>;
 
-                void remove_duplicates(rings_stack& outer_rings) {
+                static void remove_duplicates(rings_stack& outer_rings) {
                     while (true) {
                         const auto it = std::adjacent_find(outer_rings.begin(), outer_rings.end());
                         if (it == outer_rings.end()) {
@@ -315,7 +326,7 @@ namespace osmium {
                             const int64_t ay = a.y();
                             const int64_t by = b.y();
                             const int64_t ly = end_location.y();
-                            const auto z = (bx - ax)*(ly - ay) - (by - ay)*(lx - ax);
+                            const auto z = (bx - ax) * (ly - ay) - (by - ay) * (lx - ax);
                             if (debug()) {
                                 std::cerr << "      Segment z=" << z << '\n';
                             }
@@ -342,7 +353,7 @@ namespace osmium {
                             const int64_t ay = a.y();
                             const int64_t by = b.y();
                             const int64_t ly = location.y();
-                            const auto z = (bx - ax)*(ly - ay) - (by - ay)*(lx - ax);
+                            const auto z = (bx - ax) * (ly - ay) - (by - ay) * (lx - ax);
 
                             if (z >= 0) {
                                 nesting += segment->is_reverse() ? -1 : 1;
@@ -350,7 +361,8 @@ namespace osmium {
                                     std::cerr << "        Segment is below (nesting=" << nesting << ")\n";
                                 }
                                 if (segment->ring()->is_outer()) {
-                                    const double y = ay + (by - ay) * (lx - ax) / double(bx - ax);
+                                    const double y = static_cast<double>(ay) +
+                                                     static_cast<double>((by - ay) * (lx - ax)) / static_cast<double>(bx - ax);
                                     if (debug()) {
                                         std::cerr << "        Segment belongs to outer ring (y=" << y << " ring=" << *segment->ring() << ")\n";
                                     }
@@ -373,7 +385,7 @@ namespace osmium {
                     }
                     assert(!outer_rings.empty());
 
-                    std::sort(outer_rings.rbegin(), outer_rings.rend());
+                    std::stable_sort(outer_rings.rbegin(), outer_rings.rend());
                     if (debug()) {
                         for (const auto& o : outer_rings) {
                             std::cerr << "        y=" << o.y() << " " << o.ring() << "\n";
@@ -396,7 +408,7 @@ namespace osmium {
                     return std::find(m_split_locations.cbegin(), m_split_locations.cend(), location) != m_split_locations.cend();
                 }
 
-                uint32_t add_new_ring(slocation& node) {
+                uint32_t add_new_ring(const slocation& node) {
                     NodeRefSegment* segment = &m_segment_list[node.item];
                     assert(!segment->is_done());
 
@@ -454,7 +466,7 @@ namespace osmium {
                     return nodes;
                 }
 
-                uint32_t add_new_ring_complex(slocation& node) {
+                uint32_t add_new_ring_complex(const slocation& node) {
                     NodeRefSegment* segment = &m_segment_list[node.item];
                     assert(!segment->is_done());
 
@@ -500,7 +512,12 @@ namespace osmium {
                 void create_locations_list() {
                     m_locations.reserve(m_segment_list.size() * 2);
 
-                    for (uint32_t n = 0; n < m_segment_list.size(); ++n) {
+                    // static_cast is okay here: The 32bit limit is way past
+                    // anything that makes sense here and even if there are
+                    // 2^32 segments here, it would simply not go through
+                    // all of them not building the multipolygon correctly.
+                    assert(m_segment_list.size() < std::numeric_limits<uint32_t>::max());
+                    for (uint32_t n = 0; n < static_cast<uint32_t>(m_segment_list.size()); ++n) {
                         m_locations.emplace_back(n, false);
                         m_locations.emplace_back(n, true);
                     }
@@ -536,7 +553,7 @@ namespace osmium {
                         return;
                     }
 
-                    std::sort(rings.begin(), rings.end(), [](ProtoRing* a, ProtoRing* b) {
+                    std::stable_sort(rings.begin(), rings.end(), [](ProtoRing* a, ProtoRing* b) {
                         return a->min_segment() < b->min_segment();
                     });
 
@@ -576,7 +593,7 @@ namespace osmium {
                             }
                             ++m_stats.open_rings;
                         } else {
-                            if (loc == previous_location && (m_split_locations.empty() || m_split_locations.back() != previous_location )) {
+                            if (loc == previous_location && (m_split_locations.empty() || m_split_locations.back() != previous_location)) {
                                 m_split_locations.push_back(previous_location);
                             }
                             ++it;
@@ -602,7 +619,7 @@ namespace osmium {
                     }
                 }
 
-                std::vector<location_to_ring_map> create_location_to_ring_map(open_ring_its_type& open_ring_its) {
+                std::vector<location_to_ring_map> create_location_to_ring_map(open_ring_its_type& open_ring_its) const {
                     std::vector<location_to_ring_map> xrings;
                     xrings.reserve(open_ring_its.size() * 2);
 
@@ -614,7 +631,7 @@ namespace osmium {
                         xrings.emplace_back((*it)->get_node_ref_stop().location(), it, false);
                     }
 
-                    std::sort(xrings.begin(), xrings.end());
+                    std::stable_sort(xrings.begin(), xrings.end());
 
                     return xrings;
                 }
@@ -679,7 +696,7 @@ namespace osmium {
                 }
 
                 bool there_are_open_rings() const noexcept {
-                    return std::any_of(m_rings.cbegin(), m_rings.cend(), [](const ProtoRing& ring){
+                    return std::any_of(m_rings.cbegin(), m_rings.cend(), [](const ProtoRing& ring) {
                         return !ring.closed();
                     });
                 }
@@ -703,7 +720,15 @@ namespace osmium {
 
                 };
 
-                void find_candidates(std::vector<candidate>& candidates, std::unordered_set<osmium::Location>& loc_done, const std::vector<location_to_ring_map>& xrings, candidate& cand) {
+                struct exceeded_max_depth : public std::exception {};
+
+                using location_set = std::vector<osmium::Location>;
+
+                void find_candidates(std::vector<candidate>& candidates, location_set& loc_done, const std::vector<location_to_ring_map>& xrings, const candidate& cand, unsigned depth = 0) {
+                    if (depth > max_depth) {
+                        throw exceeded_max_depth{};
+                    }
+
                     if (debug()) {
                         std::cerr << "      find_candidates sum=" << cand.sum << " start=" << cand.start_location << " stop=" << cand.stop_location << "\n";
                         for (const auto& ring : cand.rings) {
@@ -741,14 +766,32 @@ namespace osmium {
                                 if (debug()) {
                                     std::cerr << "          found candidate\n";
                                 }
-                                candidates.push_back(c);
-                            } else if (loc_done.count(c.stop_location) == 0) {
-                                if (debug()) {
-                                    std::cerr << "          recurse...\n";
+
+                                if (candidates.empty()) {
+                                    candidates.push_back(c);
+                                } else if (candidates.size() == 1) {
+                                    // add new candidate to vector, keep sorted
+                                    if (std::abs(c.sum) < std::abs(candidates.front().sum)) {
+                                        candidates.insert(candidates.begin(), c);
+                                    } else {
+                                        candidates.push_back(c);
+                                    }
+                                } else {
+                                    // add new candidate if it has either smallest or largest area
+                                    if (std::abs(c.sum) < std::abs(candidates.front().sum)) {
+                                        candidates.front() = c;
+                                    } else if (std::abs(c.sum) > std::abs(candidates.back().sum)) {
+                                        candidates.back() = c;
+                                    }
                                 }
-                                loc_done.insert(c.stop_location);
-                                find_candidates(candidates, loc_done, xrings, c);
-                                loc_done.erase(c.stop_location);
+                            } else if (std::find(loc_done.cbegin(), loc_done.cend(), c.stop_location) == loc_done.cend()) {
+                                if (debug()) {
+                                    std::cerr << "          recurse... (depth=" << depth << " candidates.size=" << candidates.size() << " loc_done.size=" << loc_done.size() << ")\n";
+                                }
+                                loc_done.push_back(c.stop_location);
+                                find_candidates(candidates, loc_done, xrings, c, depth + 1);
+                                assert(!loc_done.empty() && loc_done.back() == c.stop_location);
+                                loc_done.pop_back();
                                 if (debug()) {
                                     std::cerr << "          ...back\n";
                                 }
@@ -790,16 +833,23 @@ namespace osmium {
                         ring.reset();
                     }
 
-                    candidate cand{*ring_min, false};
+                    const candidate cand{*ring_min, false};
 
                     // Locations we have visited while finding candidates, used
                     // to detect loops.
-                    std::unordered_set<osmium::Location> loc_done;
+                    location_set loc_done;
 
-                    loc_done.insert(cand.stop_location);
+                    loc_done.push_back(cand.stop_location);
 
                     std::vector<candidate> candidates;
-                    find_candidates(candidates, loc_done, xrings, cand);
+                    try {
+                        find_candidates(candidates, loc_done, xrings, cand);
+                    } catch (const exceeded_max_depth&) {
+                        if (m_config.debug_level > 0) {
+                            std::cerr << "    Exceeded max depth (" << static_cast<unsigned>(max_depth) << ")\n";
+                        }
+                        return false;
+                    }
 
                     if (candidates.empty()) {
                         if (debug()) {
@@ -819,35 +869,29 @@ namespace osmium {
 
                     if (debug()) {
                         std::cerr << "    Found candidates:\n";
-                        for (const auto& cand : candidates) {
-                            std::cerr << "      sum=" << cand.sum << "\n";
-                            for (const auto& ring : cand.rings) {
+                        for (const auto& c : candidates) {
+                            std::cerr << "      sum=" << c.sum << "\n";
+                            for (const auto& ring : c.rings) {
                                 std::cerr << "        " << ring.first.ring() << (ring.second ? " reverse" : "") << "\n";
                             }
                         }
                     }
 
                     // Find the candidate with the smallest/largest area
-                    const auto chosen_cand = ring_min_is_outer ?
-                        std::min_element(candidates.cbegin(), candidates.cend(), [](const candidate& lhs, const candidate& rhs) {
-                            return std::abs(lhs.sum) < std::abs(rhs.sum);
-                        }) :
-                        std::max_element(candidates.cbegin(), candidates.cend(), [](const candidate& lhs, const candidate& rhs) {
-                            return std::abs(lhs.sum) < std::abs(rhs.sum);
-                        });
+                    const auto chosen_cand = ring_min_is_outer ? candidates.front() : candidates.back();
 
                     if (debug()) {
-                        std::cerr << "    Decided on: sum=" << chosen_cand->sum << "\n";
-                        for (const auto& ring : chosen_cand->rings) {
+                        std::cerr << "    Decided on: sum=" << chosen_cand.sum << "\n";
+                        for (const auto& ring : chosen_cand.rings) {
                             std::cerr << "        " << ring.first.ring() << (ring.second ? " reverse" : "") << "\n";
                         }
                     }
 
                     // Join all (open) rings in the candidate to get one closed ring.
-                    assert(chosen_cand->rings.size() > 1);
-                    const auto& first_ring = chosen_cand->rings.front().first;
+                    assert(chosen_cand.rings.size() > 1);
+                    const auto& first_ring = chosen_cand.rings.front().first;
                     const ProtoRing& remaining_ring = first_ring.ring();
-                    for (auto it = std::next(chosen_cand->rings.begin()); it != chosen_cand->rings.end(); ++it) {
+                    for (auto it = std::next(chosen_cand.rings.begin()); it != chosen_cand.rings.end(); ++it) {
                         merge_two_rings(open_ring_its, first_ring, it->first);
                     }
 
@@ -863,11 +907,11 @@ namespace osmium {
                     auto count_remaining = m_segment_list.size();
                     for (const osmium::Location& location : m_split_locations) {
                         const auto locs = make_range(std::equal_range(m_locations.begin(),
-                                                                    m_locations.end(),
-                                                                    slocation{},
-                                                                    [this, &location](const slocation& lhs, const slocation& rhs) {
-                            return lhs.location(m_segment_list, location) < rhs.location(m_segment_list, location);
-                        }));
+                                                                      m_locations.end(),
+                                                                      slocation{},
+                                                                      [this, &location](const slocation& lhs, const slocation& rhs) {
+                                                                          return lhs.location(m_segment_list, location) < rhs.location(m_segment_list, location);
+                                                                      }));
                         for (auto& loc : locs) {
                             if (!m_segment_list[loc.item].is_done()) {
                                 count_remaining -= add_new_ring_complex(loc);
@@ -1066,28 +1110,38 @@ namespace osmium {
                     // whether there were any split locations or not. If there
                     // are no splits, we use the faster "simple algorithm", if
                     // there are, we use the slower "complex algorithm".
-                    osmium::Timer timer_simple_case;
-                    osmium::Timer timer_complex_case;
+                    osmium::Timer timer;
                     if (m_split_locations.empty()) {
                         if (debug()) {
                             std::cerr << "  No split locations -> using simple algorithm\n";
                         }
                         ++m_stats.area_simple_case;
 
-                        timer_simple_case.start();
+                        timer.start();
                         create_rings_simple_case();
-                        timer_simple_case.stop();
+                        timer.stop();
+                    } else if (m_split_locations.size() > max_split_locations) {
+                        if (m_config.debug_level > 0) {
+                            std::cerr << "  Ignoring polygon with "
+                                      << m_split_locations.size()
+                                      << " split locations (>"
+                                      << max_split_locations
+                                      << ")\n";
+                        }
+                        return false;
                     } else {
-                        if (debug()) {
-                            std::cerr << "  Found split locations -> using complex algorithm\n";
+                        if (m_config.debug_level > 0) {
+                            std::cerr << "  Found "
+                                      << m_split_locations.size()
+                                      << " split locations -> using complex algorithm\n";
                         }
                         ++m_stats.area_touching_rings_case;
 
-                        timer_complex_case.start();
+                        timer.start();
                         if (!create_rings_complex_case()) {
                             return false;
                         }
-                        timer_complex_case.stop();
+                        timer.stop();
                     }
 
                     // If the assembler was so configured, now check whether the
@@ -1098,7 +1152,7 @@ namespace osmium {
                         timer_roles.stop();
                     }
 
-                    m_stats.outer_rings = std::count_if(m_rings.cbegin(), m_rings.cend(), [](const ProtoRing& ring){
+                    m_stats.outer_rings = std::count_if(m_rings.cbegin(), m_rings.cend(), [](const ProtoRing& ring) {
                         return ring.is_outer();
                     });
                     m_stats.inner_rings = m_rings.size() - m_stats.outer_rings;
@@ -1112,11 +1166,9 @@ namespace osmium {
                                                 ' ' << timer_split.elapsed_microseconds();
 
                     if (m_split_locations.empty()) {
-                        std::cout << ' ' << timer_simple_case.elapsed_microseconds() <<
-                                    " 0";
+                        std::cout << ' ' << timer.elapsed_microseconds() << " 0";
                     } else {
-                        std::cout << " 0" <<
-                                    ' ' << timer_complex_case.elapsed_microseconds();
+                        std::cout << " 0" << ' ' << timer.elapsed_microseconds();
                     }
 
                     std::cout <<
diff --git a/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp b/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
index 821e914de..fa7aad110 100644
--- a/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/basic_assembler_with_tags.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -56,13 +56,13 @@ namespace osmium {
                         return false;
                     }
                     return stats().duplicate_nodes ||
-                        stats().duplicate_segments ||
-                        stats().intersections ||
-                        stats().open_rings ||
-                        stats().short_ways ||
-                        stats().touching_rings ||
-                        stats().ways_in_multiple_rings ||
-                        stats().wrong_role;
+                           stats().duplicate_segments ||
+                           stats().intersections ||
+                           stats().open_rings ||
+                           stats().short_ways ||
+                           stats().touching_rings ||
+                           stats().ways_in_multiple_rings ||
+                           stats().wrong_role;
                 }
 
                 static void copy_tags_without_type(osmium::builder::AreaBuilder& builder, const osmium::TagList& tags) {
diff --git a/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp b/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
index dc3782dbe..3db137f1a 100644
--- a/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/node_ref_segment.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -38,6 +38,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/node_ref.hpp>
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstdint>
 #include <iosfwd>
@@ -101,14 +102,10 @@ namespace osmium {
                 NodeRefSegment() noexcept = default;
 
                 NodeRefSegment(const osmium::NodeRef& nr1, const osmium::NodeRef& nr2, role_type role, const osmium::Way* way) noexcept :
-                    m_first(nr1),
-                    m_second(nr2),
+                    m_first(nr1.location() < nr2.location() ? nr1 : nr2),
+                    m_second(nr1.location() < nr2.location() ? nr2 : nr1),
                     m_way(way),
                     m_role(role) {
-                    if (nr2.location() < nr1.location()) {
-                        using std::swap;
-                        swap(m_first, m_second);
-                    }
                 }
 
                 /**
@@ -195,7 +192,7 @@ namespace osmium {
                 }
 
                 const char* role_name() const noexcept {
-                    static const char* names[] = { "unknown", "outer", "inner", "empty" };
+                    static const std::array<const char*, 4> names = {{"unknown", "outer", "inner", "empty"}};
                     return names[int(m_role)];
                 }
 
@@ -205,7 +202,7 @@ namespace osmium {
 
                 /**
                  * The "determinant" of this segment. Used for calculating
-                 * the winding order or a ring.
+                 * the winding order of a ring.
                  */
                 int64_t det() const noexcept {
                     const vec a{start()};
@@ -222,7 +219,7 @@ namespace osmium {
             }
 
             inline bool operator!=(const NodeRefSegment& lhs, const NodeRefSegment& rhs) noexcept {
-                return ! (lhs == rhs);
+                return !(lhs == rhs);
             }
 
             /**
@@ -348,13 +345,14 @@ namespace osmium {
                         osmium::Location location;
                     };
 
-                    seg_loc sl[4];
-                    sl[0] = {0, s1.first().location() };
-                    sl[1] = {0, s1.second().location()};
-                    sl[2] = {1, s2.first().location() };
-                    sl[3] = {1, s2.second().location()};
+                    std::array<seg_loc, 4> sl = {{
+                        {0, s1.first().location()},
+                        {0, s1.second().location()},
+                        {1, s2.first().location()},
+                        {1, s2.second().location()},
+                    }};
 
-                    std::sort(sl, sl+4, [](const seg_loc& lhs, const seg_loc& rhs) {
+                    std::sort(sl.begin(), sl.end(), [](const seg_loc& lhs, const seg_loc& rhs) {
                         return lhs.location < rhs.location;
                     });
 
diff --git a/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp b/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
index 6be29f94d..9c3f41c18 100644
--- a/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/proto_ring.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -196,12 +196,14 @@ namespace osmium {
                 }
 
                 void join_forward(ProtoRing& other) {
+                    m_segments.reserve(m_segments.size() + other.m_segments.size());
                     for (NodeRefSegment* segment : other.m_segments) {
                         add_segment_back(segment);
                     }
                 }
 
                 void join_backward(ProtoRing& other) {
+                    m_segments.reserve(m_segments.size() + other.m_segments.size());
                     for (auto it = other.m_segments.rbegin(); it != other.m_segments.rend(); ++it) {
                         (*it)->reverse();
                         add_segment_back(*it);
diff --git a/third_party/libosmium/include/osmium/area/detail/segment_list.hpp b/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
index 776507b46..4a4fe76f8 100644
--- a/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/segment_list.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -147,14 +147,14 @@ namespace osmium {
                     m_debug(debug) {
                 }
 
-                ~SegmentList() noexcept = default;
-
                 SegmentList(const SegmentList&) = delete;
                 SegmentList(SegmentList&&) = delete;
 
                 SegmentList& operator=(const SegmentList&) = delete;
                 SegmentList& operator=(SegmentList&&) = delete;
 
+                ~SegmentList() noexcept = default;
+
                 /// The number of segments in the list.
                 std::size_t size() const noexcept {
                     return m_segments.size();
@@ -181,7 +181,7 @@ namespace osmium {
                     return m_segments[n];
                 }
 
-                NodeRefSegment& operator[](std::size_t n) noexcept {
+                NodeRefSegment& operator[](const std::size_t n) noexcept {
                     assert(n < m_segments.size());
                     return m_segments[n];
                 }
@@ -206,7 +206,7 @@ namespace osmium {
                  * Enable or disable debug output to stderr. This is used
                  * for debugging libosmium itself.
                  */
-                void enable_debug_output(bool debug = true) noexcept {
+                void enable_debug_output(const bool debug = true) noexcept {
                     m_debug = debug;
                 }
 
@@ -296,14 +296,14 @@ namespace osmium {
                             }
                         }
 
-                        if (it+2 != m_segments.end() && *it == *(it+2)) {
+                        if (it + 2 != m_segments.end() && *it == *(it + 2)) {
                             ++overlapping_segments;
                             if (problem_reporter) {
                                 problem_reporter->report_overlapping_segment(it->first(), it->second());
                             }
                         }
 
-                        m_segments.erase(it, it+2);
+                        m_segments.erase(it, it + 2);
                     }
                 }
 
@@ -323,7 +323,7 @@ namespace osmium {
 
                     for (auto it1 = m_segments.cbegin(); it1 != m_segments.cend() - 1; ++it1) {
                         const NodeRefSegment& s1 = *it1;
-                        for (auto it2 = it1+1; it2 != m_segments.end(); ++it2) {
+                        for (auto it2 = it1 + 1; it2 != m_segments.end(); ++it2) {
                             const NodeRefSegment& s2 = *it2;
 
                             assert(s1 != s2); // erase_duplicate_segments() should have made sure of that
diff --git a/third_party/libosmium/include/osmium/area/detail/vector.hpp b/third_party/libosmium/include/osmium/area/detail/vector.hpp
index dae6c6347..a74e1d624 100644
--- a/third_party/libosmium/include/osmium/area/detail/vector.hpp
+++ b/third_party/libosmium/include/osmium/area/detail/vector.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/geom_assembler.hpp b/third_party/libosmium/include/osmium/area/geom_assembler.hpp
index 4c9fc276e..5dd397764 100644
--- a/third_party/libosmium/include/osmium/area/geom_assembler.hpp
+++ b/third_party/libosmium/include/osmium/area/geom_assembler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -68,8 +68,6 @@ namespace osmium {
                 detail::BasicAssembler(config) {
             }
 
-            ~GeomAssembler() noexcept = default;
-
             /**
              * Assemble an area from the given way.
              *
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp b/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
index d57294120..8f87db3ed 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_collector.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -70,6 +70,8 @@ namespace osmium {
          *
          * @tparam TAssembler Multipolygon Assembler class.
          * @pre The Ids of all objects must be unique in the input data.
+         *
+         * @deprecated Use MultipolygonManager instead.
          */
         template <typename TAssembler>
         class MultipolygonCollector : public osmium::relations::Collector<MultipolygonCollector<TAssembler>, false, true, false> {
@@ -83,8 +85,13 @@ namespace osmium {
 
             area_stats m_stats;
 
-            static constexpr size_t initial_output_buffer_size = 1024 * 1024;
-            static constexpr size_t max_buffer_size_for_flush = 100 * 1024;
+            enum {
+                initial_output_buffer_size = 1024UL * 1024UL
+            };
+
+            enum {
+                max_buffer_size_for_flush = 100UL * 1024UL
+            };
 
             void flush_output_buffer() {
                 if (this->callback()) {
@@ -165,7 +172,7 @@ namespace osmium {
                 }
             }
 
-            void complete_relation(osmium::relations::RelationMeta& relation_meta) {
+            void complete_relation(const osmium::relations::RelationMeta& relation_meta) {
                 const osmium::Relation& relation = this->get_relation(relation_meta);
                 const osmium::memory::Buffer& buffer = this->members_buffer();
 
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp b/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
index dd3c4d875..65dc89988 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_manager.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -63,8 +63,8 @@ namespace osmium {
         /**
          * This class collects all data needed for creating areas from
          * relations tagged with type=multipolygon or type=boundary.
-         * Most of its functionality is derived from the parent class
-         * osmium::relations::Collector.
+         * Most of its functionality is derived from the parent template class
+         * osmium::relations::RelationsManager.
          *
          * The actual assembling of the areas is done by the assembler
          * class given as template argument.
diff --git a/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp b/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
index c611d3447..2f93ebc9b 100644
--- a/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
+++ b/third_party/libosmium/include/osmium/area/multipolygon_manager_legacy.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter.hpp b/third_party/libosmium/include/osmium/area/problem_reporter.hpp
index 36f0833fa..06da1fb64 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -80,7 +80,7 @@ namespace osmium {
             ProblemReporter(ProblemReporter&&) noexcept = default;
             ProblemReporter& operator=(ProblemReporter&&) noexcept = default;
 
-            virtual ~ProblemReporter() = default;
+            virtual ~ProblemReporter() noexcept = default;
 
             /**
              * Set the object the next problem reports will be on.
@@ -93,6 +93,10 @@ namespace osmium {
                 m_object_id = object_id;
             }
 
+            osmium::object_id_type object_id() const noexcept {
+                return m_object_id;
+            }
+
             void set_nodes(size_t nodes) noexcept {
                 m_nodes = nodes;
             }
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
index 2224f66ea..8caecddec 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_exception.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
index 748cf059c..c03096780 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_ogr.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -117,8 +117,7 @@ namespace osmium {
                     .add_field("nodes", OFTInteger, 8)
                     .add_field("id1", OFTReal, 12, 1)
                     .add_field("id2", OFTReal, 12, 1)
-                    .add_field("problem", OFTString, 30)
-                ;
+                    .add_field("problem", OFTString, 30);
 
                 m_layer_lerror
                     .add_field("obj_type", OFTString, 1)
@@ -126,15 +125,13 @@ namespace osmium {
                     .add_field("nodes", OFTInteger, 8)
                     .add_field("id1", OFTReal, 12, 1)
                     .add_field("id2", OFTReal, 12, 1)
-                    .add_field("problem", OFTString, 30)
-                ;
+                    .add_field("problem", OFTString, 30);
 
                 m_layer_ways
                     .add_field("obj_type", OFTString, 1)
                     .add_field("obj_id", OFTInteger, 10)
                     .add_field("way_id", OFTInteger, 10)
-                    .add_field("nodes", OFTInteger, 8)
-                ;
+                    .add_field("nodes", OFTInteger, 8);
             }
 
             void report_duplicate_node(osmium::object_id_type node_id1, osmium::object_id_type node_id2, osmium::Location location) override {
diff --git a/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp b/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
index 09c48d5dc..73f4bb7d6 100644
--- a/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
+++ b/third_party/libosmium/include/osmium/area/problem_reporter_stream.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/area/stats.hpp b/third_party/libosmium/include/osmium/area/stats.hpp
index 780411181..587473f4b 100644
--- a/third_party/libosmium/include/osmium/area/stats.hpp
+++ b/third_party/libosmium/include/osmium/area/stats.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/builder/attr.hpp b/third_party/libosmium/include/osmium/builder/attr.hpp
index 2dd6239ea..4214a39f9 100644
--- a/third_party/libosmium/include/osmium/builder/attr.hpp
+++ b/third_party/libosmium/include/osmium/builder/attr.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -45,6 +45,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/relation.hpp>
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
+#include <osmium/util/string.hpp>
 
 #include <cstddef>
 #include <cstdint>
@@ -226,8 +227,8 @@ namespace osmium {
             OSMIUM_ATTRIBUTE(node_handler, _location, osmium::Location)
                 constexpr explicit _location(const osmium::Location& value) noexcept :
                     type_wrapper(value) {}
-                explicit _location(double lat, double lon) :
-                    type_wrapper(osmium::Location{lat, lon}) {}
+                explicit _location(double lon, double lat) :
+                    type_wrapper(osmium::Location{lon, lat}) {}
             };
 
             OSMIUM_ATTRIBUTE(entity_handler, _user, const char*)
@@ -254,6 +255,10 @@ namespace osmium {
                     m_role(role) {
                 }
 
+                member_type(char type, osmium::object_id_type ref, const char* role = "") noexcept :
+                    member_type(osmium::char_to_item_type(type), ref, role) {
+                }
+
                 constexpr osmium::item_type type() const noexcept {
                     return m_type;
                 }
@@ -282,6 +287,10 @@ namespace osmium {
                     m_role(std::move(role)) {
                 }
 
+                member_type_string(char type, osmium::object_id_type ref, std::string&& role) noexcept :
+                    member_type_string(osmium::char_to_item_type(type), ref, std::move(role)) {
+                }
+
                 osmium::item_type type() const noexcept {
                     return m_type;
                 }
@@ -360,6 +369,15 @@ namespace osmium {
                     type_wrapper(std::make_pair(key, val)) {}
                 explicit _tag(const std::string& key, const std::string& val) :
                     type_wrapper(std::make_pair(key.c_str(), val.c_str())) {}
+                explicit _tag(const char* const key_value) :
+                    type_wrapper(pair_of_cstrings{key_value, nullptr}) {}
+                explicit _tag(const std::string& key_value) :
+                    type_wrapper(pair_of_cstrings{key_value.c_str(), nullptr}) {}
+            };
+
+            OSMIUM_ATTRIBUTE(tags_handler, _t, const char*)
+                explicit _t(const char *tags) :
+                    type_wrapper(tags) {}
             };
 
             template <typename TTagIterator>
@@ -659,7 +677,19 @@ namespace osmium {
                 }
 
                 static void set_value(TagListBuilder& builder, const attr::_tag& tag) {
-                    builder.add_tag(tag.value);
+                    if (tag.value.second != nullptr) {
+                        builder.add_tag(tag.value);
+                        return;
+                    }
+                    const char* key = tag.value.first;
+                    const char* const equal_sign = std::strchr(key, '=');
+                    if (!equal_sign) {
+                        builder.add_tag(key, "");
+                        return;
+                    }
+                    const char* value = equal_sign + 1;
+                    builder.add_tag(key, equal_sign - key,
+                                    value, std::strlen(value));
                 }
 
                 template <typename TIterator>
@@ -669,6 +699,21 @@ namespace osmium {
                     }
                 }
 
+                static void set_value(TagListBuilder& builder, const attr::_t& tags) {
+                    const auto taglist = osmium::split_string(tags.value, ',', true);
+                    for (const auto& tag : taglist) {
+                        const std::size_t pos = tag.find_first_of('=');
+                        if (pos == std::string::npos) {
+                            builder.add_tag(tag, "");
+                        } else {
+                            const char* value = tag.c_str() + pos + 1;
+                            builder.add_tag(tag.c_str(), pos,
+                                            value, tag.size() - pos - 1);
+                        }
+
+                    }
+                }
+
             }; // struct tags_handler
 
             struct nodes_handler {
@@ -764,7 +809,7 @@ namespace osmium {
             template <typename TBuilder, typename THandler, typename... TArgs>
             inline typename std::enable_if<is_handled_by<THandler, TArgs...>::value>::type
             add_list(osmium::builder::Builder& parent, const TArgs&... args) {
-                TBuilder builder(parent.buffer(), &parent);
+                TBuilder builder{parent.buffer(), &parent};
                 (void)std::initializer_list<int>{
                     (THandler::set_value(builder, args), 0)...
                 };
@@ -792,7 +837,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::any_node_handlers, TArgs...>::value, "Attribute not allowed in add_node()");
 
             {
-                NodeBuilder builder(buffer);
+                NodeBuilder builder{buffer};
 
                 detail::add_basic<detail::node_handler>(builder, args...);
                 detail::add_user(builder, args...);
@@ -815,7 +860,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::any_way_handlers, TArgs...>::value, "Attribute not allowed in add_way()");
 
             {
-                WayBuilder builder(buffer);
+                WayBuilder builder{buffer};
 
                 detail::add_basic<detail::object_handler>(builder, args...);
                 detail::add_user(builder, args...);
@@ -839,7 +884,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::any_relation_handlers, TArgs...>::value, "Attribute not allowed in add_relation()");
 
             {
-                RelationBuilder builder(buffer);
+                RelationBuilder builder{buffer};
 
                 detail::add_basic<detail::object_handler>(builder, args...);
                 detail::add_user(builder, args...);
@@ -863,7 +908,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::any_changeset_handlers, TArgs...>::value, "Attribute not allowed in add_changeset()");
 
             {
-                ChangesetBuilder builder(buffer);
+                ChangesetBuilder builder{buffer};
 
                 detail::add_basic<detail::changeset_handler>(builder, args...);
                 detail::add_user(builder, args...);
@@ -887,7 +932,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::any_area_handlers, TArgs...>::value, "Attribute not allowed in add_area()");
 
             {
-                AreaBuilder builder(buffer);
+                AreaBuilder builder{buffer};
 
                 detail::add_basic<detail::object_handler>(builder, args...);
                 detail::add_user(builder, args...);
@@ -914,7 +959,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::nodes_handler, TArgs...>::value, "Attribute not allowed in add_way_node_list()");
 
             {
-                WayNodeListBuilder builder(buffer);
+                WayNodeListBuilder builder{buffer};
                 (void)std::initializer_list<int>{
                     (detail::nodes_handler::set_value(builder, args), 0)...
                 };
@@ -936,7 +981,7 @@ namespace osmium {
             static_assert(detail::are_all_handled_by<detail::tags_handler, TArgs...>::value, "Attribute not allowed in add_tag_list()");
 
             {
-                TagListBuilder builder(buffer);
+                TagListBuilder builder{buffer};
                 (void)std::initializer_list<int>{
                     (detail::tags_handler::set_value(builder, args), 0)...
                 };
diff --git a/third_party/libosmium/include/osmium/builder/builder.hpp b/third_party/libosmium/include/osmium/builder/builder.hpp
index ba0443700..c20b58a71 100644
--- a/third_party/libosmium/include/osmium/builder/builder.hpp
+++ b/third_party/libosmium/include/osmium/builder/builder.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,7 +35,6 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/memory/buffer.hpp>
 #include <osmium/memory/item.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <algorithm>
 #include <cassert>
@@ -65,7 +64,7 @@ namespace osmium {
             explicit Builder(osmium::memory::Buffer& buffer, Builder* parent, osmium::memory::item_size_type size) :
                 m_buffer(buffer),
                 m_parent(parent),
-                m_item_offset(buffer.written()) {
+                m_item_offset(buffer.written() - buffer.committed()) {
                 reserve_space(size);
                 assert(buffer.is_aligned());
                 if (m_parent) {
@@ -80,15 +79,19 @@ namespace osmium {
             }
 
 #ifdef NDEBUG
-            ~Builder() = default;
+            ~Builder() noexcept = default;
 #else
             ~Builder() noexcept {
                 m_buffer.decrement_builder_count();
             }
 #endif
 
-            osmium::memory::Item& item() const {
-                return *reinterpret_cast<osmium::memory::Item*>(m_buffer.data() + m_item_offset);
+            unsigned char* item_pos() const noexcept {
+                return m_buffer.data() + m_buffer.committed() + m_item_offset;
+            }
+
+            osmium::memory::Item& item() const noexcept {
+                return *reinterpret_cast<osmium::memory::Item*>(item_pos());
             }
 
             unsigned char* reserve_space(std::size_t size) {
@@ -183,18 +186,6 @@ namespace osmium {
                 return append(str, static_cast<osmium::memory::item_size_type>(std::strlen(str) + 1));
             }
 
-            /**
-             * Append '\0' to the buffer.
-             *
-             * @deprecated Use append_with_zero() instead.
-             *
-             * @returns The number of bytes appended (always 1).
-             */
-            OSMIUM_DEPRECATED osmium::memory::item_size_type append_zero() {
-                *reserve_space(1) = '\0';
-                return 1;
-            }
-
         public:
 
             Builder(const Builder&) = delete;
@@ -217,15 +208,6 @@ namespace osmium {
                 add_size(item.padded_size());
             }
 
-            /**
-             * @deprecated Use the version of add_item() taking a
-             *             reference instead.
-             */
-            OSMIUM_DEPRECATED void add_item(const osmium::memory::Item* item) {
-                assert(item);
-                add_item(*item);
-            }
-
         }; // class Builder
 
     } // namespace builder
diff --git a/third_party/libosmium/include/osmium/builder/builder_helper.hpp b/third_party/libosmium/include/osmium/builder/builder_helper.hpp
deleted file mode 100644
index b6c929680..000000000
--- a/third_party/libosmium/include/osmium/builder/builder_helper.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-#ifndef OSMIUM_BUILDER_BUILDER_HELPER_HPP
-#define OSMIUM_BUILDER_BUILDER_HELPER_HPP
-
-/*
-
-This file is part of Osmium (http://osmcode.org/libosmium).
-
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-*/
-
-#include <osmium/builder/osm_object_builder.hpp>
-#include <osmium/memory/buffer.hpp>
-#include <osmium/util/compatibility.hpp>
-
-#include <cstddef>
-#include <functional>
-#include <initializer_list>
-#include <map>
-#include <utility>
-
-namespace osmium {
-
-    class NodeRef;
-    class TagList;
-    class WayNodeList;
-
-    namespace builder {
-
-        /**
-         * @deprecated
-         * Use osmium::builder::add_way_node_list() instead.
-         */
-        OSMIUM_DEPRECATED inline const osmium::WayNodeList& build_way_node_list(osmium::memory::Buffer& buffer, const std::initializer_list<osmium::NodeRef>& nodes) {
-            const size_t pos = buffer.committed();
-            {
-                osmium::builder::WayNodeListBuilder wnl_builder(buffer);
-                for (const auto& node_ref : nodes) {
-                    wnl_builder.add_node_ref(node_ref);
-                }
-            }
-            buffer.commit();
-            return buffer.get<const osmium::WayNodeList>(pos);
-        }
-
-        /**
-         * @deprecated
-         * Use osmium::builder::add_tag_list() instead.
-         */
-        OSMIUM_DEPRECATED inline const osmium::TagList& build_tag_list(osmium::memory::Buffer& buffer, const std::initializer_list<std::pair<const char*, const char*>>& tags) {
-            const size_t pos = buffer.committed();
-            {
-                osmium::builder::TagListBuilder tl_builder(buffer);
-                for (const auto& p : tags) {
-                    tl_builder.add_tag(p.first, p.second);
-                }
-            }
-            buffer.commit();
-            return buffer.get<const osmium::TagList>(pos);
-        }
-
-        /**
-         * @deprecated
-         * Use osmium::builder::add_tag_list() instead.
-         */
-        OSMIUM_DEPRECATED inline const osmium::TagList& build_tag_list_from_map(osmium::memory::Buffer& buffer, const std::map<const char*, const char*>& tags) {
-            const size_t pos = buffer.committed();
-            {
-                osmium::builder::TagListBuilder tl_builder(buffer);
-                for (const auto& p : tags) {
-                    tl_builder.add_tag(p.first, p.second);
-                }
-            }
-            buffer.commit();
-            return buffer.get<const osmium::TagList>(pos);
-        }
-
-        /**
-         * @deprecated
-         * Use osmium::builder::add_tag_list() instead.
-         */
-        OSMIUM_DEPRECATED inline const osmium::TagList& build_tag_list_from_func(osmium::memory::Buffer& buffer, const std::function<void(osmium::builder::TagListBuilder&)>& func) {
-            const size_t pos = buffer.committed();
-            {
-                osmium::builder::TagListBuilder tl_builder(buffer);
-                func(tl_builder);
-            }
-            buffer.commit();
-            return buffer.get<const osmium::TagList>(pos);
-        }
-
-    } // namespace builder
-
-} // namespace osmium
-
-#endif // OSMIUM_BUILDER_BUILDER_HELPER_HPP
diff --git a/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp b/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
index dce4d1b01..228089737 100644
--- a/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
+++ b/third_party/libosmium/include/osmium/builder/osm_object_builder.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -48,7 +48,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <algorithm>
 #include <cassert>
@@ -405,18 +404,22 @@ namespace osmium {
 
             constexpr static const std::size_t min_size_for_user = osmium::memory::padded_length(sizeof(string_size_type) + 1);
 
+            void set_user_size(string_size_type size) noexcept {
+                std::memcpy(item_pos() + sizeof(T), &size, sizeof(string_size_type));
+            }
+
         public:
 
             explicit OSMObjectBuilder(osmium::memory::Buffer& buffer, Builder* parent = nullptr) :
                 Builder(buffer, parent, sizeof(T) + min_size_for_user) {
                 new (&item()) T{};
                 add_size(min_size_for_user);
-                std::fill_n(object().data() + sizeof(T), min_size_for_user, 0);
-                object().set_user_size(1);
+                std::memset(object().data() + sizeof(T), 0, min_size_for_user);
+                set_user_size(1);
             }
 
             /**
-             * Get a reference to the object buing built.
+             * Get a reference to the object being built.
              *
              * Note that this reference will be invalidated by every action
              * on the builder that might make the buffer grow. This includes
@@ -427,7 +430,7 @@ namespace osmium {
             }
 
             /**
-             * Get a const reference to the object buing built.
+             * Get a const reference to the object being built.
              *
              * Note that this reference will be invalidated by every action
              * on the builder that might make the buffer grow. This includes
@@ -447,14 +450,14 @@ namespace osmium {
                 const auto size_of_object = sizeof(T) + sizeof(string_size_type);
                 assert(cobject().user_size() == 1 && (size() <= size_of_object + osmium::memory::padded_length(1))
                        && "set_user() must be called at most once and before any sub-builders");
-                const auto available_space = min_size_for_user - sizeof(string_size_type) - 1;
+                constexpr const auto available_space = min_size_for_user - sizeof(string_size_type) - 1;
                 if (length > available_space) {
                     const auto space_needed = osmium::memory::padded_length(length - available_space);
-                    std::fill_n(reserve_space(space_needed), space_needed, 0);
+                    std::memset(reserve_space(space_needed), 0, space_needed);
                     add_size(static_cast<uint32_t>(space_needed));
                 }
-                std::copy_n(user, length, object().data() + size_of_object);
-                object().set_user_size(length + 1);
+                std::memcpy(object().data() + size_of_object, user, length);
+                set_user_size(length + 1);
 
                 return static_cast<TDerived&>(*this);
             }
@@ -484,12 +487,6 @@ namespace osmium {
                 return set_user(user.data(), static_cast<string_size_type>(user.size()));
             }
 
-            /// @deprecated Use set_user(...) instead.
-            template <typename... TArgs>
-            OSMIUM_DEPRECATED void add_user(TArgs&&... args) {
-                set_user(std::forward<TArgs>(args)...);
-            }
-
             OSMIUM_FORWARD(set_id)
             OSMIUM_FORWARD(set_visible)
             OSMIUM_FORWARD(set_deleted)
@@ -608,7 +605,7 @@ namespace osmium {
                 Builder(buffer, parent, sizeof(Changeset) + min_size_for_user) {
                 new (&item()) Changeset{};
                 add_size(min_size_for_user);
-                std::fill_n(object().data() + sizeof(Changeset), min_size_for_user, 0);
+                std::memset(object().data() + sizeof(Changeset), 0, min_size_for_user);
                 object().set_user_size(1);
             }
 
@@ -644,11 +641,6 @@ namespace osmium {
             OSMIUM_FORWARD(set_attribute)
             OSMIUM_FORWARD(set_removed)
 
-            // @deprecated Use set_bounds() instead.
-            OSMIUM_DEPRECATED osmium::Box& bounds() noexcept {
-                return object().bounds();
-            }
-
             ChangesetBuilder& set_bounds(const osmium::Box& box) noexcept {
                 object().bounds() = box;
                 return *this;
@@ -663,13 +655,13 @@ namespace osmium {
             ChangesetBuilder& set_user(const char* user, const string_size_type length) {
                 assert(cobject().user_size() == 1 && (size() <= sizeof(Changeset) + osmium::memory::padded_length(1))
                        && "set_user() must be called at most once and before any sub-builders");
-                const auto available_space = min_size_for_user - 1;
+                constexpr const auto available_space = min_size_for_user - 1;
                 if (length > available_space) {
                     const auto space_needed = osmium::memory::padded_length(length - available_space);
-                    std::fill_n(reserve_space(space_needed), space_needed, 0);
+                    std::memset(reserve_space(space_needed), 0, space_needed);
                     add_size(static_cast<uint32_t>(space_needed));
                 }
-                std::copy_n(user, length, object().data() + sizeof(Changeset));
+                std::memcpy(object().data() + sizeof(Changeset), user, length);
                 object().set_user_size(length + 1);
 
                 return *this;
@@ -700,12 +692,6 @@ namespace osmium {
                 return set_user(user.data(), static_cast<string_size_type>(user.size()));
             }
 
-            /// @deprecated Use set_user(...) instead.
-            template <typename... TArgs>
-            OSMIUM_DEPRECATED void add_user(TArgs&&... args) {
-                set_user(std::forward<TArgs>(args)...);
-            }
-
         }; // class ChangesetBuilder
 
 #undef OSMIUM_FORWARD
diff --git a/third_party/libosmium/include/osmium/diff_handler.hpp b/third_party/libosmium/include/osmium/diff_handler.hpp
index 639a5f45f..4d58be1cb 100644
--- a/third_party/libosmium/include/osmium/diff_handler.hpp
+++ b/third_party/libosmium/include/osmium/diff_handler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -48,13 +48,13 @@ namespace osmium {
 
             DiffHandler() = default;
 
-            void node(const osmium::DiffNode&) const noexcept {
+            void node(const osmium::DiffNode& /*node*/) const noexcept {
             }
 
-            void way(const osmium::DiffWay&) const noexcept {
+            void way(const osmium::DiffWay& /*way*/) const noexcept {
             }
 
-            void relation(const osmium::DiffRelation&) const noexcept {
+            void relation(const osmium::DiffRelation& /*relation*/) const noexcept {
             }
 
         }; // class DiffHandler
diff --git a/third_party/libosmium/include/osmium/diff_iterator.hpp b/third_party/libosmium/include/osmium/diff_iterator.hpp
index 0ea5f8445..6573e14cc 100644
--- a/third_party/libosmium/include/osmium/diff_iterator.hpp
+++ b/third_party/libosmium/include/osmium/diff_iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -49,6 +49,9 @@ namespace osmium {
      * An input iterator wrapping any iterator over OSMObjects. When
      * dereferenced it will yield DiffObject objects pointing to the
      * underlying OSMObjects.
+     *
+     * Note that this class uses a mutable member variable internally.
+     * It can not be used safely in multiple threads!
      */
     template <typename TBasicIterator>
     class DiffIterator {
@@ -88,8 +91,7 @@ namespace osmium {
             m_prev(begin),
             m_curr(begin),
             m_next(begin == end ? begin : ++begin),
-            m_end(std::move(end)),
-            m_diff() {
+            m_end(std::move(end)) {
         }
 
         DiffIterator& operator++() {
diff --git a/third_party/libosmium/include/osmium/diff_visitor.hpp b/third_party/libosmium/include/osmium/diff_visitor.hpp
index 1db5ce295..2e855ad30 100644
--- a/third_party/libosmium/include/osmium/diff_visitor.hpp
+++ b/third_party/libosmium/include/osmium/diff_visitor.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/dynamic_handler.hpp b/third_party/libosmium/include/osmium/dynamic_handler.hpp
index 96906760b..6c2a53784 100644
--- a/third_party/libosmium/include/osmium/dynamic_handler.hpp
+++ b/third_party/libosmium/include/osmium/dynamic_handler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,7 +62,7 @@ namespace osmium {
                 HandlerWrapperBase(HandlerWrapperBase&&) noexcept = default;
                 HandlerWrapperBase& operator=(HandlerWrapperBase&&) noexcept = default;
 
-                virtual ~HandlerWrapperBase() = default;
+                virtual ~HandlerWrapperBase() noexcept = default;
 
                 virtual void node(const osmium::Node& /*node*/) {
                 }
@@ -126,6 +126,14 @@ auto _name_##_dispatch(THandler& handler, const osmium::_type_& object, long) ->
                     m_handler(std::forward<TArgs>(args)...) {
                 }
 
+                HandlerWrapper(const HandlerWrapper&) = default;
+                HandlerWrapper& operator=(const HandlerWrapper&) = default;
+
+                HandlerWrapper(HandlerWrapper&&) noexcept = default;
+                HandlerWrapper& operator=(HandlerWrapper&&) noexcept = default;
+
+                ~HandlerWrapper() noexcept override = default;
+
                 void node(const osmium::Node& node) final {
                     node_dispatch(m_handler, node, 0);
                 }
diff --git a/third_party/libosmium/include/osmium/experimental/flex_reader.hpp b/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
index ead9e36b3..66cf571eb 100644
--- a/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
+++ b/third_party/libosmium/include/osmium/experimental/flex_reader.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -73,7 +73,6 @@ namespace osmium {
                 m_entities((entities & ~osmium::osm_entity_bits::area) | (m_with_areas ? osmium::osm_entity_bits::node | osmium::osm_entity_bits::way : osmium::osm_entity_bits::nothing)),
                 m_location_handler(location_handler),
                 m_reader(file, m_entities),
-                m_assembler_config(),
                 m_collector(m_assembler_config)
             {
                 m_location_handler.ignore_errors();
diff --git a/third_party/libosmium/include/osmium/fwd.hpp b/third_party/libosmium/include/osmium/fwd.hpp
index eede6fbfd..c43be5fff 100644
--- a/third_party/libosmium/include/osmium/fwd.hpp
+++ b/third_party/libosmium/include/osmium/fwd.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/coordinates.hpp b/third_party/libosmium/include/osmium/geom/coordinates.hpp
index f2f926d71..804400256 100644
--- a/third_party/libosmium/include/osmium/geom/coordinates.hpp
+++ b/third_party/libosmium/include/osmium/geom/coordinates.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -74,6 +74,7 @@ namespace osmium {
              * This constructor is not explicit on purpose allowing use of
              * a Location everywhere a Coordinates object is needed.
              */
+            // cppcheck-suppress noExplicitConstructor
             Coordinates(const osmium::Location& location) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
                 x(location.lon()),
                 y(location.lat()) {
diff --git a/third_party/libosmium/include/osmium/geom/factory.hpp b/third_party/libosmium/include/osmium/geom/factory.hpp
index f878931be..704ae4d66 100644
--- a/third_party/libosmium/include/osmium/geom/factory.hpp
+++ b/third_party/libosmium/include/osmium/geom/factory.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -44,6 +44,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/node_ref_list.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
+#include <osmium/util/compatibility.hpp>
 
 #include <cstddef>
 #include <stdexcept>
@@ -56,7 +57,7 @@ namespace osmium {
      * Exception thrown when an invalid geometry is encountered. An example
      * would be a linestring with less than two points.
      */
-    class geometry_error : public std::runtime_error {
+    class OSMIUM_EXPORT geometry_error : public std::runtime_error {
 
         std::string m_message;
         osmium::object_id_type m_id;
@@ -131,11 +132,11 @@ namespace osmium {
                 return Coordinates{location.lon(), location.lat()};
             }
 
-            int epsg() const noexcept {
+            static int epsg() noexcept {
                 return 4326;
             }
 
-            std::string proj_string() const {
+            static std::string proj_string() noexcept {
                 return "+proj=longlat +datum=WGS84 +no_defs";
             }
 
@@ -385,7 +386,7 @@ namespace osmium {
 
                     for (const auto& item : area) {
                         if (item.type() == osmium::item_type::outer_ring) {
-                            auto& ring = static_cast<const osmium::OuterRing&>(item);
+                            const auto& ring = static_cast<const osmium::OuterRing&>(item);
                             if (num_polygons > 0) {
                                 m_impl.multipolygon_polygon_finish();
                             }
@@ -396,7 +397,7 @@ namespace osmium {
                             ++num_rings;
                             ++num_polygons;
                         } else if (item.type() == osmium::item_type::inner_ring) {
-                            auto& ring = static_cast<const osmium::InnerRing&>(item);
+                            const auto& ring = static_cast<const osmium::InnerRing&>(item);
                             m_impl.multipolygon_inner_ring_start();
                             add_points(ring);
                             m_impl.multipolygon_inner_ring_finish();
diff --git a/third_party/libosmium/include/osmium/geom/geojson.hpp b/third_party/libosmium/include/osmium/geom/geojson.hpp
index 2b5218b1b..3d97702d7 100644
--- a/third_party/libosmium/include/osmium/geom/geojson.hpp
+++ b/third_party/libosmium/include/osmium/geom/geojson.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/geos.hpp b/third_party/libosmium/include/osmium/geom/geos.hpp
index c1daa8618..c3c0c4d98 100644
--- a/third_party/libosmium/include/osmium/geom/geos.hpp
+++ b/third_party/libosmium/include/osmium/geom/geos.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -54,7 +54,6 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/factory.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <geos/geom/Coordinate.h>
 #include <geos/geom/CoordinateSequence.h>
@@ -70,20 +69,13 @@ DEALINGS IN THE SOFTWARE.
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <exception>
 #include <iterator>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
-// MSVC doesn't support throw_with_nested yet
-#ifdef _MSC_VER
-# define THROW throw
-#else
-# include <exception>
-# define THROW std::throw_with_nested
-#endif
-
 namespace osmium {
 
     struct geos_geometry_error : public geometry_error {
@@ -123,16 +115,6 @@ namespace osmium {
                     m_geos_factory(&geos_factory) {
                 }
 
-                /**
-                 * @deprecated Do not set SRID explicitly. It will be set to the
-                 *             correct value automatically.
-                 */
-                OSMIUM_DEPRECATED explicit GEOSFactoryImpl(int /* srid */, int srid) :
-                    m_precision_model(new geos::geom::PrecisionModel),
-                    m_our_geos_factory(new geos::geom::GeometryFactory{m_precision_model.get(), srid}),
-                    m_geos_factory(m_our_geos_factory.get()) {
-                }
-
                 explicit GEOSFactoryImpl(int srid) :
                     m_precision_model(new geos::geom::PrecisionModel),
                     m_our_geos_factory(new geos::geom::GeometryFactory{m_precision_model.get(), srid}),
@@ -145,7 +127,7 @@ namespace osmium {
                     try {
                         return point_type{m_geos_factory->createPoint(geos::geom::Coordinate{xy.x, xy.y})};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -155,7 +137,7 @@ namespace osmium {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -163,7 +145,7 @@ namespace osmium {
                     try {
                         m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -171,7 +153,7 @@ namespace osmium {
                     try {
                         return linestring_type{m_geos_factory->createLineString(m_coordinate_sequence.release())};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -195,7 +177,7 @@ namespace osmium {
                         m_polygons.emplace_back(m_geos_factory->createPolygon(m_rings[0].release(), inner_rings));
                         m_rings.clear();
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -203,7 +185,7 @@ namespace osmium {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -211,7 +193,7 @@ namespace osmium {
                     try {
                         m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -219,7 +201,7 @@ namespace osmium {
                     try {
                         m_coordinate_sequence.reset(m_geos_factory->getCoordinateSequenceFactory()->create(static_cast<std::size_t>(0), 2));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -227,7 +209,7 @@ namespace osmium {
                     try {
                         m_rings.emplace_back(m_geos_factory->createLinearRing(m_coordinate_sequence.release()));
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -235,7 +217,7 @@ namespace osmium {
                     try {
                         m_coordinate_sequence->add(geos::geom::Coordinate{xy.x, xy.y});
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -248,7 +230,7 @@ namespace osmium {
                         m_polygons.clear();
                         return multipolygon_type{m_geos_factory->createMultiPolygon(polygons)};
                     } catch (const geos::util::GEOSException& e) {
-                        THROW(osmium::geos_geometry_error(e.what()));
+                        std::throw_with_nested(osmium::geos_geometry_error(e.what()));
                     }
                 }
 
@@ -264,8 +246,6 @@ namespace osmium {
 
 } // namespace osmium
 
-#undef THROW
-
 #endif
 
 #endif // OSMIUM_GEOM_GEOS_HPP
diff --git a/third_party/libosmium/include/osmium/geom/haversine.hpp b/third_party/libosmium/include/osmium/geom/haversine.hpp
index 46cc30850..d0e95e2a4 100644
--- a/third_party/libosmium/include/osmium/geom/haversine.hpp
+++ b/third_party/libosmium/include/osmium/geom/haversine.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,7 +35,7 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/util.hpp>
-#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/node_ref_list.hpp>
 #include <osmium/osm/way.hpp>
 
 #include <cmath>
@@ -63,13 +63,13 @@ namespace osmium {
              *
              * @pre @code c1.valid() && c2.valid() @endcode
              */
-            inline double distance(const osmium::geom::Coordinates& c1, const osmium::geom::Coordinates& c2) {
-                double lonh = sin(deg_to_rad(c1.x - c2.x) * 0.5);
+            inline double distance(const osmium::geom::Coordinates& c1, const osmium::geom::Coordinates& c2) noexcept {
+                double lonh = std::sin(deg_to_rad(c1.x - c2.x) * 0.5);
                 lonh *= lonh;
-                double lath = sin(deg_to_rad(c1.y - c2.y) * 0.5);
+                double lath = std::sin(deg_to_rad(c1.y - c2.y) * 0.5);
                 lath *= lath;
-                const double tmp = cos(deg_to_rad(c1.y)) * cos(deg_to_rad(c2.y));
-                return 2.0 * EARTH_RADIUS_IN_METERS * asin(sqrt(lath + tmp * lonh));
+                const double tmp = std::cos(deg_to_rad(c1.y)) * std::cos(deg_to_rad(c2.y));
+                return 2.0 * EARTH_RADIUS_IN_METERS * std::asin(std::sqrt(lath + tmp * lonh));
             }
 
             /**
@@ -78,7 +78,7 @@ namespace osmium {
             inline double distance(const osmium::WayNodeList& wnl) {
                 double sum_length = 0;
 
-                for (auto it = wnl.begin(); it != wnl.end(); ++it) {
+                for (const auto* it = wnl.begin(); it != wnl.end(); ++it) {
                     if (std::next(it) != wnl.end()) {
                         sum_length += distance(it->location(), std::next(it)->location());
                     }
@@ -87,6 +87,21 @@ namespace osmium {
                 return sum_length;
             }
 
+            /**
+             * Calculate length of node list.
+             */
+            inline double distance(const osmium::NodeRefList& nrl) {
+                double sum_length = 0;
+
+                for (const auto* it = nrl.begin(); it != nrl.end(); ++it) {
+                    if (std::next(it) != nrl.end()) {
+                        sum_length += distance(it->location(), std::next(it)->location());
+                    }
+                }
+
+                return sum_length;
+            }
+
         } // namespace haversine
 
     } // namespace geom
diff --git a/third_party/libosmium/include/osmium/geom/mercator_projection.hpp b/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
index febb372ac..b0e67d993 100644
--- a/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
+++ b/third_party/libosmium/include/osmium/geom/mercator_projection.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -49,7 +49,7 @@ namespace osmium {
             constexpr double earth_radius_for_epsg3857 = 6378137.0;
             constexpr double max_coordinate_epsg3857 = 20037508.34;
 
-            constexpr inline double lon_to_x(double lon) {
+            constexpr inline double lon_to_x(double lon) noexcept {
                 return earth_radius_for_epsg3857 * deg_to_rad(lon);
             }
 
@@ -116,6 +116,9 @@ namespace osmium {
          * Convert the coordinates from WGS84 lon/lat to web mercator.
          *
          * @pre @code c.valid() @endcode
+         * @pre Coordinates must be in valid range, longitude between
+         *      -180 and +180 degree, latitude between -MERCATOR_MAX_LAT
+         *      and MERCATOR_MAX_LAT.
          */
         inline Coordinates lonlat_to_mercator(const Coordinates& c) {
             return Coordinates{detail::lon_to_x(c.x), detail::lat_to_y(c.y)};
@@ -125,6 +128,8 @@ namespace osmium {
          * Convert the coordinates from web mercator to WGS84 lon/lat.
          *
          * @pre @code c.valid() @endcode
+         * @pre Coordinates must be in valid range (longitude and
+         *      latidude between -/+20037508.34).
          */
         inline Coordinates mercator_to_lonlat(const Coordinates& c) {
             return Coordinates{detail::x_to_lon(c.x), detail::y_to_lat(c.y)};
@@ -145,15 +150,22 @@ namespace osmium {
             MercatorProjection() { // NOLINT(hicpp-use-equals-default, modernize-use-equals-default)
             }
 
+            /**
+             * Do coordinate transformation.
+             *
+             * @pre Coordinates must be in valid range, longitude between
+             *      -180 and +180 degree, latitude between -MERCATOR_MAX_LAT
+             *      and MERCATOR_MAX_LAT.
+             */
             Coordinates operator()(osmium::Location location) const {
                 return Coordinates{detail::lon_to_x(location.lon()), detail::lat_to_y(location.lat())};
             }
 
-            int epsg() const noexcept {
+            static int epsg() noexcept {
                 return 3857;
             }
 
-            std::string proj_string() const {
+            static std::string proj_string() noexcept {
                 return "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +wktext +no_defs";
             }
 
diff --git a/third_party/libosmium/include/osmium/geom/ogr.hpp b/third_party/libosmium/include/osmium/geom/ogr.hpp
index 73276c1f0..1179ae064 100644
--- a/third_party/libosmium/include/osmium/geom/ogr.hpp
+++ b/third_party/libosmium/include/osmium/geom/ogr.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -82,7 +82,7 @@ namespace osmium {
 
                 /* Point */
 
-                point_type make_point(const osmium::geom::Coordinates& xy) const {
+                static point_type make_point(const osmium::geom::Coordinates& xy) {
                     return point_type{new OGRPoint{xy.x, xy.y}};
                 }
 
diff --git a/third_party/libosmium/include/osmium/geom/projection.hpp b/third_party/libosmium/include/osmium/geom/projection.hpp
index 4b6629709..8a4c670ca 100644
--- a/third_party/libosmium/include/osmium/geom/projection.hpp
+++ b/third_party/libosmium/include/osmium/geom/projection.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -46,8 +46,15 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/util.hpp>
 #include <osmium/osm/location.hpp>
+#include <osmium/util/compatibility.hpp>
 
-#include <proj_api.h>
+#ifdef ACCEPT_USE_OF_DEPRECATED_PROJ_API_H
+# include <proj_api.h>
+#else
+# define ACCEPT_USE_OF_DEPRECATED_PROJ_API_H
+# include <proj_api.h>
+# undef ACCEPT_USE_OF_DEPRECATED_PROJ_API_H
+#endif
 
 #include <memory>
 #include <string>
@@ -58,8 +65,10 @@ namespace osmium {
 
         /**
          * C++ wrapper for a Coordinate Reference System of the proj library.
+         *
+         * @deprecated Only supports the old PROJ API.
          */
-        class CRS {
+        class OSMIUM_DEPRECATED CRS {
 
             struct ProjCRSDeleter {
                 void operator()(void* crs) {
@@ -110,9 +119,10 @@ namespace osmium {
          * Coordinates have to be in radians and are produced in radians.
          *
          * @throws osmium::projection_error if the projection fails
+         *
+         * @deprecated Only supports the old PROJ API.
          */
-        // cppcheck-suppress passedByValue (because c is small and we want to change it)
-        inline Coordinates transform(const CRS& src, const CRS& dest, Coordinates c) {
+        inline OSMIUM_DEPRECATED Coordinates transform(const CRS& src, const CRS& dest, Coordinates c) {
             const int result = pj_transform(src.get(), dest.get(), 1, 1, &c.x, &c.y, nullptr);
             if (result != 0) {
                 throw osmium::projection_error{std::string{"projection failed: "} + pj_strerrno(result)};
@@ -130,8 +140,10 @@ namespace osmium {
          * implementation of the Mercator projection is used, otherwise this
          * falls back to using the proj.4 library. Note that this "magic" does
          * not work if you use any of the constructors taking a string.
+         *
+         * @deprecated Only supports the old PROJ API.
          */
-        class Projection {
+        class OSMIUM_DEPRECATED Projection {
 
             int m_epsg;
             std::string m_proj_string;
@@ -140,9 +152,9 @@ namespace osmium {
 
         public:
 
-            explicit Projection(const std::string& proj_string) :
+            explicit Projection(std::string proj_string) :
                 m_epsg(-1),
-                m_proj_string(proj_string),
+                m_proj_string(std::move(proj_string)),
                 m_crs_user(proj_string) {
             }
 
@@ -158,6 +170,12 @@ namespace osmium {
                 m_crs_user(epsg) {
             }
 
+            /**
+             * Do coordinate transformation.
+             *
+             * @pre Location must be in valid range (depends on projection
+             *      used).
+             */
             Coordinates operator()(osmium::Location location) const {
                 if (m_epsg == 4326) {
                     return Coordinates{location.lon(), location.lat()};
diff --git a/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp b/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
index 53fc79847..c9d104a8c 100644
--- a/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
+++ b/third_party/libosmium/include/osmium/geom/rapid_geojson.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/relations.hpp b/third_party/libosmium/include/osmium/geom/relations.hpp
index c3b28c4dd..fb33f8912 100644
--- a/third_party/libosmium/include/osmium/geom/relations.hpp
+++ b/third_party/libosmium/include/osmium/geom/relations.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/geom/tile.hpp b/third_party/libosmium/include/osmium/geom/tile.hpp
index 133916e64..4c3e02ed6 100644
--- a/third_party/libosmium/include/osmium/geom/tile.hpp
+++ b/third_party/libosmium/include/osmium/geom/tile.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -58,7 +58,7 @@ namespace osmium {
          * level.
          */
         inline constexpr uint32_t num_tiles_in_zoom(uint32_t zoom) noexcept {
-            return 1u << zoom;
+            return 1U << zoom;
         }
 
         /**
@@ -77,8 +77,7 @@ namespace osmium {
         inline constexpr uint32_t mercx_to_tilex(uint32_t zoom, double x) noexcept {
             return static_cast<uint32_t>(detail::clamp<int32_t>(
                 static_cast<int32_t>((x + detail::max_coordinate_epsg3857) / tile_extent_in_zoom(zoom)),
-                0, num_tiles_in_zoom(zoom) -1
-            ));
+                0, num_tiles_in_zoom(zoom) - 1));
         }
 
         /**
@@ -89,8 +88,7 @@ namespace osmium {
         inline constexpr uint32_t mercy_to_tiley(uint32_t zoom, double y) noexcept {
             return static_cast<uint32_t>(detail::clamp<int32_t>(
                 static_cast<int32_t>((detail::max_coordinate_epsg3857 - y) / tile_extent_in_zoom(zoom)),
-                0, num_tiles_in_zoom(zoom) -1
-            ));
+                0, num_tiles_in_zoom(zoom) - 1));
         }
 
         /**
@@ -98,6 +96,10 @@ namespace osmium {
          */
         struct Tile {
 
+            enum {
+                max_zoom = 30U
+            };
+
             /// x coordinate
             uint32_t x;
 
@@ -119,7 +121,7 @@ namespace osmium {
                 x(tx),
                 y(ty),
                 z(zoom) {
-                assert(zoom <= 30u);
+                assert(zoom <= max_zoom);
                 assert(x < num_tiles_in_zoom(zoom));
                 assert(y < num_tiles_in_zoom(zoom));
             }
@@ -134,7 +136,7 @@ namespace osmium {
              */
             explicit Tile(uint32_t zoom, const osmium::Location& location) :
                 z(zoom) {
-                assert(zoom <= 30u);
+                assert(zoom <= max_zoom);
                 assert(location.valid());
                 const auto coordinates = lonlat_to_mercator(location);
                 x = mercx_to_tilex(zoom, coordinates.x);
@@ -151,7 +153,7 @@ namespace osmium {
              */
             explicit Tile(uint32_t zoom, const osmium::geom::Coordinates& coordinates) :
                 z(zoom) {
-                assert(zoom <= 30u);
+                assert(zoom <= max_zoom);
                 x = mercx_to_tilex(zoom, coordinates.x);
                 y = mercy_to_tiley(zoom, coordinates.y);
             }
@@ -162,7 +164,7 @@ namespace osmium {
              * each be between 0 and 2^zoom-1.
              */
             bool valid() const noexcept {
-                if (z > 30) {
+                if (z > max_zoom) {
                     return false;
                 }
                 const auto max = num_tiles_in_zoom(z);
diff --git a/third_party/libosmium/include/osmium/geom/util.hpp b/third_party/libosmium/include/osmium/geom/util.hpp
index 6984edf49..a51e72ddb 100644
--- a/third_party/libosmium/include/osmium/geom/util.hpp
+++ b/third_party/libosmium/include/osmium/geom/util.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+
 #include <stdexcept>
 #include <string>
 
@@ -42,7 +44,7 @@ namespace osmium {
      * Exception thrown when a projection object can not be initialized or the
      * projection of some coordinates can not be calculated.
      */
-    struct projection_error : public std::runtime_error {
+    struct OSMIUM_EXPORT projection_error : public std::runtime_error {
 
         explicit projection_error(const std::string& what) :
             std::runtime_error(what) {
diff --git a/third_party/libosmium/include/osmium/geom/wkb.hpp b/third_party/libosmium/include/osmium/geom/wkb.hpp
index 405d92def..a07844c78 100644
--- a/third_party/libosmium/include/osmium/geom/wkb.hpp
+++ b/third_party/libosmium/include/osmium/geom/wkb.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,7 +35,6 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/geom/coordinates.hpp>
 #include <osmium/geom/factory.hpp>
-#include <osmium/util/cast.hpp>
 #include <osmium/util/endian.hpp>
 
 #include <algorithm>
@@ -70,8 +69,8 @@ namespace osmium {
                 out.reserve(str.size() * 2);
 
                 for (char c : str) {
-                    out += lookup_hex[(static_cast<unsigned int>(c) >> 4u) & 0xfu];
-                    out += lookup_hex[ static_cast<unsigned int>(c)        & 0xfu];
+                    out += lookup_hex[(static_cast<unsigned int>(c) >> 4U) & 0xfU];
+                    out += lookup_hex[ static_cast<unsigned int>(c)        & 0xfU];
                 }
 
                 return out;
@@ -202,6 +201,34 @@ namespace osmium {
                     return data;
                 }
 
+                /* Polygon */
+
+                void polygon_start() {
+                    m_data.clear();
+                    set_size(header(m_data, wkbPolygon, true), 1);
+                    m_ring_size_offset = m_data.size();
+                    str_push(m_data, static_cast<uint32_t>(0));
+                }
+
+                void polygon_add_location(const osmium::geom::Coordinates& xy) {
+                    str_push(m_data, xy.x);
+                    str_push(m_data, xy.y);
+                }
+
+                polygon_type polygon_finish(std::size_t num_points) {
+                    set_size(m_ring_size_offset, num_points);
+                    std::string data;
+
+                    using std::swap;
+                    swap(data, m_data);
+
+                    if (m_out_type == out_type::hex) {
+                        return convert_to_hex(data);
+                    }
+
+                    return data;
+                }
+
                 /* MultiPolygon */
 
                 void multipolygon_start() {
diff --git a/third_party/libosmium/include/osmium/geom/wkt.hpp b/third_party/libosmium/include/osmium/geom/wkt.hpp
index 5801c652b..235b9daae 100644
--- a/third_party/libosmium/include/osmium/geom/wkt.hpp
+++ b/third_party/libosmium/include/osmium/geom/wkt.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/handler.hpp b/third_party/libosmium/include/osmium/handler.hpp
index fe9dca3f4..9d6fc8911 100644
--- a/third_party/libosmium/include/osmium/handler.hpp
+++ b/third_party/libosmium/include/osmium/handler.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/handler/chain.hpp b/third_party/libosmium/include/osmium/handler/chain.hpp
index 5f4bb78e7..432ee2afc 100644
--- a/third_party/libosmium/include/osmium/handler/chain.hpp
+++ b/third_party/libosmium/include/osmium/handler/chain.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -80,7 +80,7 @@ namespace osmium {
 
             template <int SIZE, typename THandlers>
             struct call_flush<SIZE, SIZE, THandlers> {
-                void operator()(THandlers&) {}
+                void operator()(THandlers& /*handlers*/) {}
             }; // struct call_flush
 
             OSMIUM_CHAIN_HANDLER_CALL(node, Node)
diff --git a/third_party/libosmium/include/osmium/handler/check_order.hpp b/third_party/libosmium/include/osmium/handler/check_order.hpp
index c6d77bbaf..31de2b97c 100644
--- a/third_party/libosmium/include/osmium/handler/check_order.hpp
+++ b/third_party/libosmium/include/osmium/handler/check_order.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -39,8 +39,8 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/relation.hpp>
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
+#include <osmium/util/compatibility.hpp>
 
-#include <limits>
 #include <stdexcept>
 #include <string>
 
@@ -50,7 +50,7 @@ namespace osmium {
      * Exception thrown when a method in the CheckOrder class detects
      * that the input is out of order.
      */
-    struct out_of_order_error : public std::runtime_error {
+    struct OSMIUM_EXPORT out_of_order_error : public std::runtime_error {
 
         osmium::object_id_type object_id;
 
@@ -86,51 +86,69 @@ namespace osmium {
          */
         class CheckOrder : public osmium::handler::Handler {
 
-            osmium::object_id_type m_max_node_id     = std::numeric_limits<osmium::object_id_type>::min();
-            osmium::object_id_type m_max_way_id      = std::numeric_limits<osmium::object_id_type>::min();
-            osmium::object_id_type m_max_relation_id = std::numeric_limits<osmium::object_id_type>::min();
+            osmium::object_id_type m_max_node_id = 0;
+            osmium::object_id_type m_max_way_id = 0;
+            osmium::object_id_type m_max_relation_id = 0;
+            bool m_has_node = false;
+            bool m_has_way = false;
+            bool m_has_relation = false;
 
         public:
 
             void node(const osmium::Node& node) {
-                if (m_max_way_id > std::numeric_limits<osmium::object_id_type>::min()) {
+                if (m_has_way) {
                     throw out_of_order_error{"Found a node after a way.", node.id()};
                 }
-                if (m_max_relation_id > std::numeric_limits<osmium::object_id_type>::min()) {
+                if (m_has_relation) {
                     throw out_of_order_error{"Found a node after a relation.", node.id()};
                 }
 
-                if (m_max_node_id == node.id()) {
-                    throw out_of_order_error{"Node ID twice in input. Maybe you are using a history or change file?", node.id()};
+                if (m_has_node) {
+                    if (m_max_node_id == node.id()) {
+                        throw out_of_order_error{"Node ID twice in input. Maybe you are using a history or change file?", node.id()};
+                    }
+                    if (id_order{}(node.id(), m_max_node_id)) {
+                        throw out_of_order_error{"Node IDs out of order: " + std::to_string(node.id()), node.id()};
+                    }
+                    m_max_node_id = node.id();
+                } else {
+                    m_max_node_id = node.id();
+                    m_has_node = true;
                 }
-                if (id_order{}(node.id(), m_max_node_id)) {
-                    throw out_of_order_error{"Node IDs out of order.", node.id()};
-                }
-                m_max_node_id = node.id();
             }
 
             void way(const osmium::Way& way) {
-                if (m_max_relation_id > std::numeric_limits<osmium::object_id_type>::min()) {
+                if (m_has_relation) {
                     throw out_of_order_error{"Found a way after a relation.", way.id()};
                 }
 
-                if (m_max_way_id == way.id()) {
-                    throw out_of_order_error{"Way ID twice in input. Maybe you are using a history or change file?", way.id()};
+                if (m_has_way) {
+                    if (m_max_way_id == way.id()) {
+                        throw out_of_order_error{"Way ID twice in input. Maybe you are using a history or change file?", way.id()};
+                    }
+                    if (id_order{}(way.id(), m_max_way_id)) {
+                        throw out_of_order_error{"Way IDs out of order: " + std::to_string(way.id()), way.id()};
+                    }
+                    m_max_way_id = way.id();
+                } else {
+                    m_max_way_id = way.id();
+                    m_has_way = true;
                 }
-                if (id_order{}(way.id(), m_max_way_id)) {
-                    throw out_of_order_error{"Way IDs out of order.", way.id()};
-                }
-                m_max_way_id = way.id();
             }
 
             void relation(const osmium::Relation& relation) {
-                if (m_max_relation_id == relation.id()) {
-                    throw out_of_order_error{"Relation ID twice in input. Maybe you are using a history or change file?", relation.id()};
+                if (m_has_relation) {
+                    if (m_max_relation_id == relation.id()) {
+                        throw out_of_order_error{"Relation ID twice in input. Maybe you are using a history or change file?", relation.id()};
+                    }
+                    if (id_order{}(relation.id(), m_max_relation_id)) {
+                        throw out_of_order_error{"Relation IDs out of order: " + std::to_string(relation.id()), relation.id()};
+                    }
+                    m_max_relation_id = relation.id();
+                } else {
+                    m_max_relation_id = relation.id();
+                    m_has_relation = true;
                 }
-                if (id_order{}(relation.id(), m_max_relation_id)) {
-                    throw out_of_order_error{"Relation IDs out of order.", relation.id()};
-                }
-                m_max_relation_id = relation.id();
             }
 
             osmium::object_id_type max_node_id() const noexcept {
diff --git a/third_party/libosmium/include/osmium/handler/disk_store.hpp b/third_party/libosmium/include/osmium/handler/disk_store.hpp
index 8ec4c3ecc..b6a9b43b5 100644
--- a/third_party/libosmium/include/osmium/handler/disk_store.hpp
+++ b/third_party/libosmium/include/osmium/handler/disk_store.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/handler/dump.hpp b/third_party/libosmium/include/osmium/handler/dump.hpp
index 8827387b6..fcfa7f81a 100644
--- a/third_party/libosmium/include/osmium/handler/dump.hpp
+++ b/third_party/libosmium/include/osmium/handler/dump.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp b/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
index 640b7016f..4fd38753e 100644
--- a/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
+++ b/third_party/libosmium/include/osmium/handler/node_locations_for_ways.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -115,6 +115,14 @@ namespace osmium {
                 m_ignore_errors = true;
             }
 
+            TStoragePosIDs& storage_pos() noexcept {
+                return m_storage_pos;
+            }
+
+            TStorageNegIDs& storage_neg() noexcept {
+                return m_storage_neg;
+            }
+
             /**
              * Store the location of the node in the storage.
              */
diff --git a/third_party/libosmium/include/osmium/handler/object_relations.hpp b/third_party/libosmium/include/osmium/handler/object_relations.hpp
index fd903ea22..1cfec9255 100644
--- a/third_party/libosmium/include/osmium/handler/object_relations.hpp
+++ b/third_party/libosmium/include/osmium/handler/object_relations.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/bool_vector.hpp b/third_party/libosmium/include/osmium/index/bool_vector.hpp
index 11290d656..529063565 100644
--- a/third_party/libosmium/include/osmium/index/bool_vector.hpp
+++ b/third_party/libosmium/include/osmium/index/bool_vector.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp b/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
index 32a9b6317..004b76833 100644
--- a/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/create_map_with_fd.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,10 +35,10 @@ DEALINGS IN THE SOFTWARE.
 
 #include <cassert>
 #include <cerrno>
-#include <cstring>
 #include <fcntl.h>
 #include <stdexcept>
 #include <string>
+#include <system_error>
 #include <vector>
 
 namespace osmium {
@@ -56,7 +56,7 @@ namespace osmium {
                 const std::string& filename = config[1];
                 const int fd = ::open(filename.c_str(), O_CREAT | O_RDWR, 0644); // NOLINT(hicpp-signed-bitwise)
                 if (fd == -1) {
-                    throw std::runtime_error{std::string{"can't open file '"} + filename + "': " + std::strerror(errno)};
+                    throw std::system_error{errno, std::system_category(), "can't open file '" + filename + "'"};
                 }
                 return new T{fd};
             }
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
index 555246dc5..0f97e9999 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_anon.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
index 6e0bbf42d..b5b193e5c 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_base.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -46,7 +46,9 @@ namespace osmium {
 
     namespace detail {
 
-        constexpr size_t mmap_vector_size_increment = 1024 * 1024;
+        enum {
+            mmap_vector_size_increment = 1024UL * 1024UL
+        };
 
         /**
          * This is a base class for implementing classes that look like
@@ -58,12 +60,12 @@ namespace osmium {
 
         protected:
 
-            size_t m_size = 0;
+            std::size_t m_size = 0;
             osmium::TypedMemoryMapping<T> m_mapping;
 
         public:
 
-            mmap_vector_base(int fd, size_t capacity, size_t size = 0) :
+            mmap_vector_base(const int fd, const std::size_t capacity, const std::size_t size = 0) :
                 m_size(size),
                 m_mapping(capacity, osmium::MemoryMapping::mapping_mode::write_shared, fd) {
                 assert(size <= capacity);
@@ -71,7 +73,7 @@ namespace osmium {
                 shrink_to_fit();
             }
 
-            explicit mmap_vector_base(size_t capacity = mmap_vector_size_increment) :
+            explicit mmap_vector_base(const std::size_t capacity = mmap_vector_size_increment) :
                 m_mapping(capacity) {
                 std::fill_n(data(), capacity, osmium::index::empty_value<T>());
             }
@@ -88,11 +90,11 @@ namespace osmium {
                 m_mapping.unmap();
             }
 
-            size_t capacity() const noexcept {
+            std::size_t capacity() const noexcept {
                 return m_mapping.size();
             }
 
-            size_t size() const noexcept {
+            std::size_t size() const noexcept {
                 return m_size;
             }
 
@@ -108,17 +110,17 @@ namespace osmium {
                 return m_mapping.begin();
             }
 
-            const_reference operator[](size_t n) const {
+            const_reference operator[](const std::size_t n) const {
                 assert(n < m_size);
                 return data()[n];
             }
 
-            reference operator[](size_t n) {
+            reference operator[](const std::size_t n) {
                 assert(n < m_size);
                 return data()[n];
             }
 
-            value_type at(size_t n) const {
+            value_type at(const std::size_t n) const {
                 if (n >= m_size) {
                     throw std::out_of_range{"out of range"};
                 }
@@ -140,17 +142,17 @@ namespace osmium {
                 data()[m_size - 1] = value;
             }
 
-            void reserve(size_t new_capacity) {
+            void reserve(const std::size_t new_capacity) {
                 if (new_capacity > capacity()) {
-                    const size_t old_capacity = capacity();
+                    const std::size_t old_capacity = capacity();
                     m_mapping.resize(new_capacity);
                     std::fill(data() + old_capacity, data() + new_capacity, osmium::index::empty_value<value_type>());
                 }
             }
 
-            void resize(size_t new_size) {
+            void resize(const std::size_t new_size) {
                 if (new_size > capacity()) {
-                    reserve(new_size + osmium::detail::mmap_vector_size_increment);
+                    reserve(new_size + mmap_vector_size_increment);
                 }
                 m_size = new_size;
             }
diff --git a/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp b/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
index 8258bb374..80e20adec 100644
--- a/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/mmap_vector_file.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -53,7 +53,7 @@ namespace osmium {
         template <typename T>
         class mmap_vector_file : public mmap_vector_base<T> {
 
-            static std::size_t filesize(int fd) {
+            static std::size_t filesize(const int fd) {
                 const auto size = osmium::file_size(fd);
 
                 if (size % sizeof(T) != 0) {
@@ -71,10 +71,10 @@ namespace osmium {
                     osmium::detail::mmap_vector_size_increment) {
             }
 
-            explicit mmap_vector_file(int fd) :
+            explicit mmap_vector_file(const int fd) :
                 mmap_vector_base<T>(
                     fd,
-                    std::max(osmium::detail::mmap_vector_size_increment, filesize(fd)),
+                    std::max(static_cast<std::size_t>(mmap_vector_size_increment), filesize(fd)),
                     filesize(fd)) {
             }
 
diff --git a/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp b/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
index 26a39de15..4734e671a 100644
--- a/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/tmpfile.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/detail/vector_map.hpp b/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
index c560ed91e..fd643144f 100644
--- a/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/vector_map.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -39,8 +39,10 @@ DEALINGS IN THE SOFTWARE.
 
 #include <algorithm>
 #include <cstddef>
+#include <memory>
 #include <utility>
 
+
 namespace osmium {
 
     namespace index {
@@ -63,6 +65,14 @@ namespace osmium {
                     m_vector() {
                 }
 
+                VectorBasedDenseMap(const VectorBasedDenseMap&) = default;
+                VectorBasedDenseMap& operator=(const VectorBasedDenseMap&) = default;
+
+                VectorBasedDenseMap(VectorBasedDenseMap&&) noexcept = default;
+                VectorBasedDenseMap& operator=(VectorBasedDenseMap&&) noexcept = default;
+
+                ~VectorBasedDenseMap() noexcept override = default;
+
                 explicit VectorBasedDenseMap(int fd) :
                     m_vector(fd) {
                 }
@@ -159,10 +169,9 @@ namespace osmium {
                 vector_type m_vector;
 
                 typename vector_type::const_iterator find_id(const TId id) const noexcept {
-                    const element_type element {
+                    const element_type element{
                         id,
-                        osmium::index::empty_value<TValue>()
-                    };
+                        osmium::index::empty_value<TValue>()};
                     return std::lower_bound(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) {
                         return a.first < b.first;
                     });
@@ -178,6 +187,14 @@ namespace osmium {
                     m_vector(fd) {
                 }
 
+                VectorBasedSparseMap(const VectorBasedSparseMap&) = default;
+                VectorBasedSparseMap& operator=(const VectorBasedSparseMap&) = default;
+
+                VectorBasedSparseMap(VectorBasedSparseMap&&) noexcept = default;
+                VectorBasedSparseMap& operator=(VectorBasedSparseMap&&) noexcept = default;
+
+                ~VectorBasedSparseMap() noexcept override = default;
+
                 void set(const TId id, const TValue value) final {
                     m_vector.push_back(element_type(id, value));
                 }
@@ -221,6 +238,26 @@ namespace osmium {
                     std::sort(m_vector.begin(), m_vector.end());
                 }
 
+                void dump_as_array(const int fd) final {
+                    constexpr const size_t value_size = sizeof(TValue);
+                    constexpr const size_t buffer_size = (10L * 1024L * 1024L) / value_size;
+                    std::unique_ptr<TValue[]> output_buffer{new TValue[buffer_size]};
+
+                    size_t buffer_start_id = 0;
+                    for (auto it = cbegin(); it != cend();) {
+                        std::fill_n(output_buffer.get(), buffer_size, osmium::index::empty_value<TValue>());
+                        size_t offset = 0;
+                        for (; offset < buffer_size && it != end(); ++offset) {
+                            if (buffer_start_id + offset == it->first) {
+                                output_buffer[offset] = it->second;
+                                ++it;
+                            }
+                        }
+                        osmium::io::detail::reliable_write(fd, reinterpret_cast<const unsigned char*>(output_buffer.get()), offset * value_size);
+                        buffer_start_id += buffer_size;
+                    }
+                }
+
                 void dump_as_list(const int fd) final {
                     osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(m_vector.data()), byte_size());
                 }
diff --git a/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp b/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
index b7fdf84db..3b4796209 100644
--- a/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/detail/vector_multimap.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -61,7 +61,7 @@ namespace osmium {
 
                 vector_type m_vector;
 
-                static bool is_removed(element_type& element) {
+                static bool is_removed(const element_type& element) {
                     return element.second == osmium::index::empty_value<TValue>();
                 }
 
@@ -75,6 +75,14 @@ namespace osmium {
                     m_vector(fd) {
                 }
 
+                VectorBasedSparseMultimap(const VectorBasedSparseMultimap&) = default;
+                VectorBasedSparseMultimap& operator=(const VectorBasedSparseMultimap&) = default;
+
+                VectorBasedSparseMultimap(VectorBasedSparseMultimap&&) noexcept = default;
+                VectorBasedSparseMultimap& operator=(VectorBasedSparseMultimap&&) noexcept = default;
+
+                ~VectorBasedSparseMultimap() noexcept override = default;
+
                 void set(const TId id, const TValue value) final {
                     m_vector.push_back(element_type(id, value));
                 }
@@ -84,20 +92,18 @@ namespace osmium {
                 }
 
                 std::pair<iterator, iterator> get_all(const TId id) {
-                    const element_type element {
+                    const element_type element{
                         id,
-                        osmium::index::empty_value<TValue>()
-                    };
+                        osmium::index::empty_value<TValue>()};
                     return std::equal_range(m_vector.begin(), m_vector.end(), element, [](const element_type& a, const element_type& b) {
                         return a.first < b.first;
                     });
                 }
 
                 std::pair<const_iterator, const_iterator> get_all(const TId id) const {
-                    const element_type element {
+                    const element_type element{
                         id,
-                        osmium::index::empty_value<TValue>()
-                    };
+                        osmium::index::empty_value<TValue>()};
                     return std::equal_range(m_vector.cbegin(), m_vector.cend(), element, [](const element_type& a, const element_type& b) {
                         return a.first < b.first;
                     });
@@ -141,8 +147,7 @@ namespace osmium {
                 void erase_removed() {
                     m_vector.erase(
                         std::remove_if(m_vector.begin(), m_vector.end(), is_removed),
-                        m_vector.end()
-                    );
+                        m_vector.end());
                 }
 
                 void dump_as_list(const int fd) final {
diff --git a/third_party/libosmium/include/osmium/index/id_set.hpp b/third_party/libosmium/include/osmium/index/id_set.hpp
index eefdf821c..1c64aa55b 100644
--- a/third_party/libosmium/include/osmium/index/id_set.hpp
+++ b/third_party/libosmium/include/osmium/index/id_set.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -37,6 +37,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstddef>
 #include <cstring>
@@ -66,7 +67,7 @@ namespace osmium {
             IdSet(IdSet&&) noexcept = default;
             IdSet& operator=(IdSet&&) noexcept = default;
 
-            virtual ~IdSet() = default;
+            virtual ~IdSet() noexcept = default;
 
             /**
              * Add the given Id to the set.
@@ -95,33 +96,47 @@ namespace osmium {
 
         }; // class IdSet
 
-        template <typename T>
+        namespace detail {
+
+            // This value is a compromise. For node Ids it could be bigger
+            // which would mean less (but larger) memory allocations. For
+            // relations Ids it could be smaller, because they would all fit
+            // into a smaller allocation.
+            enum : std::size_t {
+                default_chunk_bits = 22U
+            };
+
+        } // namespace detail
+
+        template <typename T, std::size_t chunk_bits = detail::default_chunk_bits>
         class IdSetDense;
 
         /**
          * Const_iterator for iterating over a IdSetDense.
          */
-        template <typename T>
+        template <typename T, std::size_t chunk_bits>
         class IdSetDenseIterator {
 
             static_assert(std::is_unsigned<T>::value, "Needs unsigned type");
             static_assert(sizeof(T) >= 4, "Needs at least 32bit type");
 
-            const IdSetDense<T>* m_set;
+            using id_set = IdSetDense<T, chunk_bits>;
+
+            const id_set* m_set;
             T m_value;
             T m_last;
 
             void next() noexcept {
                 while (m_value != m_last && !m_set->get(m_value)) {
-                    const T cid = IdSetDense<T>::chunk_id(m_value);
+                    const T cid = id_set::chunk_id(m_value);
                     assert(cid < m_set->m_data.size());
                     if (!m_set->m_data[cid]) {
-                        m_value = (cid + 1) << (IdSetDense<T>::chunk_bits + 3);
+                        m_value = (cid + 1) << (chunk_bits + 3);
                     } else {
-                        const auto slot = m_set->m_data[cid][IdSetDense<T>::offset(m_value)];
+                        const auto slot = m_set->m_data[cid][id_set::offset(m_value)];
                         if (slot == 0) {
                             m_value += 8;
-                            m_value &= ~0x7ull;
+                            m_value &= ~0x7ULL;
                         } else {
                             ++m_value;
                         }
@@ -136,14 +151,14 @@ namespace osmium {
             using pointer           = value_type*;
             using reference         = value_type&;
 
-            IdSetDenseIterator(const IdSetDense<T>* set, T value, T last) noexcept :
+            IdSetDenseIterator(const id_set* set, T value, T last) noexcept :
                 m_set(set),
                 m_value(value),
                 m_last(last) {
                 next();
             }
 
-            IdSetDenseIterator<T>& operator++() noexcept {
+            IdSetDenseIterator& operator++() noexcept {
                 if (m_value != m_last) {
                     ++m_value;
                     next();
@@ -151,17 +166,17 @@ namespace osmium {
                 return *this;
             }
 
-            IdSetDenseIterator<T> operator++(int) noexcept {
-                IdSetDenseIterator<T> tmp{*this};
+            IdSetDenseIterator operator++(int) noexcept {
+                IdSetDenseIterator tmp{*this};
                 operator++();
                 return tmp;
             }
 
-            bool operator==(const IdSetDenseIterator<T>& rhs) const noexcept {
+            bool operator==(const IdSetDenseIterator& rhs) const noexcept {
                 return m_set == rhs.m_set && m_value == rhs.m_value;
             }
 
-            bool operator!=(const IdSetDenseIterator<T>& rhs) const noexcept {
+            bool operator!=(const IdSetDenseIterator& rhs) const noexcept {
                 return !(*this == rhs);
             }
 
@@ -179,34 +194,31 @@ namespace osmium {
          * and larger Id sets. If it is not used, no memory is allocated at
          * all.
          */
-        template <typename T>
+        template <typename T, std::size_t chunk_bits>
         class IdSetDense : public IdSet<T> {
 
             static_assert(std::is_unsigned<T>::value, "Needs unsigned type");
             static_assert(sizeof(T) >= 4, "Needs at least 32bit type");
 
-            friend class IdSetDenseIterator<T>;
+            friend class IdSetDenseIterator<T, chunk_bits>;
 
-            // This value is a compromise. For node Ids it could be bigger
-            // which would mean less (but larger) memory allocations. For
-            // relations Ids it could be smaller, because they would all fit
-            // into a smaller allocation.
-            constexpr static const std::size_t chunk_bits = 22u;
-            constexpr static const std::size_t chunk_size = 1u << chunk_bits;
+            enum : std::size_t {
+                chunk_size = 1U << chunk_bits
+            };
 
             std::vector<std::unique_ptr<unsigned char[]>> m_data;
             T m_size = 0;
 
             static std::size_t chunk_id(T id) noexcept {
-                return id >> (chunk_bits + 3u);
+                return id >> (chunk_bits + 3U);
             }
 
             static std::size_t offset(T id) noexcept {
-                return (id >> 3u) & ((1u << chunk_bits) - 1u);
+                return (id >> 3U) & ((1U << chunk_bits) - 1U);
             }
 
-            static unsigned char bitmask(T id) noexcept {
-                return 1u << (id & 0x7u);
+            static unsigned int bitmask(T id) noexcept {
+                return 1U << (id & 0x7U);
             }
 
             T last() const noexcept {
@@ -230,10 +242,43 @@ namespace osmium {
 
         public:
 
-            using const_iterator = IdSetDenseIterator<T>;
+            using const_iterator = IdSetDenseIterator<T, chunk_bits>;
+
+            friend void swap(IdSetDense& first, IdSetDense& second) noexcept {
+                using std::swap;
+                swap(first.m_data, second.m_data);
+                swap(first.m_size, second.m_size);
+            }
 
             IdSetDense() = default;
 
+            IdSetDense(const IdSetDense& other) :
+                IdSet<T>(other),
+                m_size(other.m_size) {
+                m_data.reserve(other.m_data.size());
+                for (const auto& ptr : other.m_data) {
+                    if (ptr) {
+                        m_data.emplace_back(new unsigned char[chunk_size]);
+                        ::memcpy(m_data.back().get(), ptr.get(), chunk_size);
+                    } else {
+                        m_data.emplace_back();
+                    }
+                }
+            }
+
+            IdSetDense& operator=(IdSetDense other) {
+                swap(*this, other);
+                return *this;
+            }
+
+            IdSetDense(IdSetDense&&) noexcept = default;
+
+            // This should really be noexcept, but GCC 4.8 doesn't like it.
+            // NOLINTNEXTLINE(hicpp-noexcept-move, performance-noexcept-move-constructor)
+            IdSetDense& operator=(IdSetDense&&) = default;
+
+            ~IdSetDense() noexcept override = default;
+
             /**
              * Add the Id to the set if it is not already in there.
              *
@@ -284,7 +329,7 @@ namespace osmium {
                 if (chunk_id(id) >= m_data.size()) {
                     return false;
                 }
-                auto* r = m_data[chunk_id(id)].get();
+                const auto* r = m_data[chunk_id(id)].get();
                 if (!r) {
                     return false;
                 }
@@ -317,11 +362,11 @@ namespace osmium {
                 return m_data.size() * chunk_size;
             }
 
-            IdSetDenseIterator<T> begin() const {
+            const_iterator begin() const {
                 return {this, 0, last()};
             }
 
-            IdSetDenseIterator<T> end() const {
+            const_iterator end() const {
                 return {this, last(), last()};
             }
 
@@ -338,11 +383,23 @@ namespace osmium {
 
         public:
 
+            IdSetSmall() = default;
+
+            IdSetSmall(const IdSetSmall&) = default;
+            IdSetSmall& operator=(const IdSetSmall&) = default;
+
+            IdSetSmall(IdSetSmall&&) noexcept = default;
+            IdSetSmall& operator=(IdSetSmall&&) noexcept = default;
+
+            ~IdSetSmall() noexcept override = default;
+
             /**
              * Add the given Id to the set.
              */
             void set(T id) final {
-                m_data.push_back(id);
+                if (m_data.empty() || m_data.back() != id) {
+                    m_data.push_back(id);
+                }
             }
 
             /**
@@ -385,7 +442,8 @@ namespace osmium {
 
             /**
              * Sort the internal vector and remove any duplicates. Call this
-             * before using size(), get_binary_search() or using an iterator.
+             * before using size(), get_binary_search(), merge_sorted() or
+             * using an iterator.
              */
             void sort_unique() {
                 std::sort(m_data.begin(), m_data.end());
@@ -408,6 +466,22 @@ namespace osmium {
                 return m_data.capacity() * sizeof(T);
             }
 
+            /**
+             * Merge the other set into this one. The result is sorted.
+             *
+             * @pre Both sets must be sorted and must not contain any
+             *      duplicates. Call sort_unique() if you are not sure.
+             */
+            void merge_sorted(const IdSetSmall<T>& other) {
+                std::vector<T> new_data;
+                new_data.reserve(m_data.size() + other.m_data.size());
+                std::set_union(m_data.cbegin(), m_data.cend(),
+                               other.m_data.cbegin(), other.m_data.cend(),
+                               std::back_inserter(new_data));
+                using std::swap;
+                swap(new_data, m_data);
+            }
+
             /// Iterator type. There is no non-const iterator.
             using const_iterator = typename std::vector<T>::const_iterator;
 
@@ -435,7 +509,7 @@ namespace osmium {
 
             using id_set_type = IdSetType<osmium::unsigned_object_id_type>;
 
-            id_set_type m_sets[3];
+            std::array<id_set_type, 3> m_sets;
 
         public:
 
diff --git a/third_party/libosmium/include/osmium/index/index.hpp b/third_party/libosmium/include/osmium/index/index.hpp
index ca9e660d0..b858a0f2a 100644
--- a/third_party/libosmium/include/osmium/index/index.hpp
+++ b/third_party/libosmium/include/osmium/index/index.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+
 #include <cstddef>
 #include <cstdint>
 #include <limits>
@@ -45,7 +47,7 @@ namespace osmium {
      * Exception signaling that an element could not be
      * found in an index.
      */
-    struct not_found : public std::runtime_error {
+    struct OSMIUM_EXPORT not_found : public std::runtime_error {
 
         explicit not_found(const std::string& what) :
             std::runtime_error(what) {
diff --git a/third_party/libosmium/include/osmium/index/map.hpp b/third_party/libosmium/include/osmium/index/map.hpp
index a9fe9a390..508e322a8 100644
--- a/third_party/libosmium/include/osmium/index/map.hpp
+++ b/third_party/libosmium/include/osmium/index/map.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
 #include <osmium/util/string.hpp>
 
 #include <algorithm>
@@ -47,7 +48,7 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
-    struct map_factory_error : public std::runtime_error {
+    struct OSMIUM_EXPORT map_factory_error : public std::runtime_error {
 
         explicit map_factory_error(const char* message) :
             std::runtime_error(message) {
@@ -118,7 +119,7 @@ namespace osmium {
 
                 virtual ~Map() noexcept = default;
 
-                virtual void reserve(const size_t /*size*/) {
+                virtual void reserve(const std::size_t /*size*/) {
                     // default implementation is empty
                 }
 
@@ -151,7 +152,7 @@ namespace osmium {
                  * accurate. You can not use this to find out how much memory the
                  * storage uses. Use used_memory() for that.
                  */
-                virtual size_t size() const = 0;
+                virtual std::size_t size() const = 0;
 
                 /**
                  * Get the memory used for this storage in bytes. Note that this
@@ -160,7 +161,7 @@ namespace osmium {
                  * the main memory used, for storage classes storing data on disk
                  * this is the memory used on disk.
                  */
-                virtual size_t used_memory() const = 0;
+                virtual std::size_t used_memory() const = 0;
 
                 /**
                  * Clear memory used for this storage. After this you can not
@@ -210,8 +211,6 @@ namespace osmium {
 
             MapFactory() = default;
 
-            ~MapFactory() = default;
-
         public:
 
             MapFactory(const MapFactory&) = delete;
@@ -220,6 +219,8 @@ namespace osmium {
             MapFactory(MapFactory&&) = delete;
             MapFactory& operator=(MapFactory&&) = delete;
 
+            ~MapFactory() noexcept = default;
+
             static MapFactory<id_type, value_type>& instance() {
                 static MapFactory<id_type, value_type> factory;
                 return factory;
diff --git a/third_party/libosmium/include/osmium/index/map/all.hpp b/third_party/libosmium/include/osmium/index/map/all.hpp
index 948bc5ec8..8a08dabaa 100644
--- a/third_party/libosmium/include/osmium/index/map/all.hpp
+++ b/third_party/libosmium/include/osmium/index/map/all.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -41,7 +41,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/index/map/sparse_file_array.hpp> // IWYU pragma: keep
 #include <osmium/index/map/sparse_mem_array.hpp>  // IWYU pragma: keep
 #include <osmium/index/map/sparse_mem_map.hpp>    // IWYU pragma: keep
-#include <osmium/index/map/sparse_mem_table.hpp>  // IWYU pragma: keep
 #include <osmium/index/map/sparse_mmap_array.hpp> // IWYU pragma: keep
 
 #endif // OSMIUM_INDEX_MAP_ALL_HPP
diff --git a/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
index da49c0642..7529067c0 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_file_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
index 84ca04969..5263db560 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_mem_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp b/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
index 02e1883fb..c23edf0f4 100644
--- a/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dense_mmap_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/dummy.hpp b/third_party/libosmium/include/osmium/index/map/dummy.hpp
index d6e396df4..6708bd2c3 100644
--- a/third_party/libosmium/include/osmium/index/map/dummy.hpp
+++ b/third_party/libosmium/include/osmium/index/map/dummy.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -56,6 +56,14 @@ namespace osmium {
 
                 Dummy() = default;
 
+                Dummy(const Dummy&) = default;
+                Dummy& operator=(const Dummy&) = default;
+
+                Dummy(Dummy&&) noexcept = default;
+                Dummy& operator=(Dummy&&) noexcept = default;
+
+                ~Dummy() noexcept override = default;
+
                 void set(const TId /*id*/, const TValue /*value*/) final {
                     // intentionally left blank
                 }
diff --git a/third_party/libosmium/include/osmium/index/map/flex_mem.hpp b/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
index 43bf9ce3b..fe3201ae0 100644
--- a/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
+++ b/third_party/libosmium/include/osmium/index/map/flex_mem.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,17 +62,17 @@ namespace osmium {
 
                 // This value is based on benchmarks with a planet file and
                 // some smaller files.
-                enum constant_bits {
+                enum {
                     bits = 16
                 };
 
-                enum constant_block_size : uint64_t {
-                    block_size = 1ull << bits
+                enum : uint64_t {
+                    block_size = 1ULL << bits
                 };
 
                 // Minimum number of entries in the sparse index before we
                 // are considering switching to a dense index.
-                enum constant_min_dense_entries : int64_t {
+                enum : int64_t {
                     min_dense_entries = 0xffffff
                 };
 
@@ -81,7 +81,7 @@ namespace osmium {
                 // the best memory efficiency (which we would get at a factor
                 // of 2) and the performance (dense index is much faster then
                 // the sparse index).
-                enum constant_density_factor {
+                enum {
                     density_factor = 3
                 };
 
@@ -244,7 +244,7 @@ namespace osmium {
                     if (m_dense) {
                         return;
                     }
-                    for (const auto entry : m_sparse_entries) {
+                    for (const auto& entry : m_sparse_entries) {
                         set_dense(entry.id, entry.value);
                     }
                     m_sparse_entries.clear();
@@ -257,8 +257,8 @@ namespace osmium {
                     std::size_t used_blocks = 0;
                     std::size_t empty_blocks = 0;
 
-                    for (const auto& block : m_dense_blocks) {
-                        if (block.empty()) {
+                    for (const auto& dense_block : m_dense_blocks) {
+                        if (dense_block.empty()) {
                             ++empty_blocks;
                         } else {
                             ++used_blocks;
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
index 80bb37103..21d03db1f 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_file_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
index 6035a6643..dfeb1f5e6 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mem_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
index 25b01b1bb..9078671f0 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mem_map.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,7 +62,9 @@ namespace osmium {
                 // element in the map (id + value + pointers to left, right,
                 // and parent plus some overhead for color of red-black-tree
                 // or similar).
-                static constexpr size_t element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4;
+                enum {
+                    element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4U
+                };
 
                 std::map<TId, TValue> m_elements;
 
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp
deleted file mode 100644
index 8d1a0422b..000000000
--- a/third_party/libosmium/include/osmium/index/map/sparse_mem_table.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-#ifndef OSMIUM_INDEX_MAP_SPARSE_MEM_TABLE_HPP
-#define OSMIUM_INDEX_MAP_SPARSE_MEM_TABLE_HPP
-
-/*
-
-This file is part of Osmium (http://osmcode.org/libosmium).
-
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-*/
-
-#ifdef OSMIUM_WITH_SPARSEHASH
-
-#include <osmium/index/index.hpp>
-#include <osmium/index/map.hpp>
-#include <osmium/io/detail/read_write.hpp>
-
-#include <google/sparsetable>
-
-#include <cstddef>
-#include <utility>
-#include <vector>
-
-#define OSMIUM_HAS_INDEX_MAP_SPARSE_MEM_TABLE
-
-namespace osmium {
-
-    namespace index {
-
-        namespace map {
-
-            /**
-             * The SparseMemTable index stores elements in a Google sparsetable,
-             * a data structure that can hold sparsly filled tables in a
-             * space efficient way. It will resize automatically.
-             *
-             * Use this index if the ID space is only sparsly
-             * populated, such as when working with smaller OSM files (like
-             * country extracts).
-             *
-             * This will only work on 64 bit machines.
-             */
-            template <typename TId, typename TValue>
-            class SparseMemTable : public osmium::index::map::Map<TId, TValue> {
-
-                TId m_grow_size;
-
-                google::sparsetable<TValue> m_elements;
-
-                static_assert(sizeof(typename google::sparsetable<TValue>::size_type) >= 8, "google::sparsetable needs 64bit machine");
-
-            public:
-
-                /**
-                * Constructor.
-                *
-                * @param grow_size The initial size of the index (ie number of
-                *                  elements that fit into the index).
-                *                  The storage will grow by at least this size
-                *                  every time it runs out of space.
-                */
-                explicit SparseMemTable(const TId grow_size = 10000) :
-                    m_grow_size(grow_size),
-                    m_elements(grow_size) {
-                }
-
-                void set(const TId id, const TValue value) final {
-                    if (id >= m_elements.size()) {
-                        m_elements.resize(id + m_grow_size);
-                    }
-                    m_elements[id] = value;
-                }
-
-                TValue get(const TId id) const final {
-                    if (id >= m_elements.size()) {
-                        throw osmium::not_found{id};
-                    }
-                    const TValue value = m_elements[id];
-                    if (value == osmium::index::empty_value<TValue>()) {
-                        throw osmium::not_found{id};
-                    }
-                    return value;
-                }
-
-                TValue get_noexcept(const TId id) const noexcept final {
-                    if (id >= m_elements.size()) {
-                        return osmium::index::empty_value<TValue>();
-                    }
-                    return m_elements[id];
-                }
-
-                size_t size() const final {
-                    return m_elements.size();
-                }
-
-                size_t used_memory() const final {
-                    // unused elements use 1 bit, used elements sizeof(TValue) bytes
-                    // https://github.com/sparsehash/sparsehash/blob/master/doc/sparsetable.html
-                    return (m_elements.size() / 8) + (m_elements.num_nonempty() * sizeof(TValue));
-                }
-
-                void clear() final {
-                    m_elements.clear();
-                }
-
-                void dump_as_list(const int fd) final {
-                    std::vector<std::pair<TId, TValue>> v;
-                    v.reserve(m_elements.size());
-                    int n = 0;
-                    for (const TValue value : m_elements) {
-                        if (value != osmium::index::empty_value<TValue>()) {
-                            v.emplace_back(n, value);
-                        }
-                        ++n;
-                    }
-                    osmium::io::detail::reliable_write(fd, reinterpret_cast<const char*>(v.data()), sizeof(std::pair<TId, TValue>) * v.size());
-                }
-
-            }; // class SparseMemTable
-
-        } // namespace map
-
-    } // namespace index
-
-} // namespace osmium
-
-#ifdef OSMIUM_WANT_NODE_LOCATION_MAPS
-    REGISTER_MAP(osmium::unsigned_object_id_type, osmium::Location, osmium::index::map::SparseMemTable, sparse_mem_table)
-#endif
-
-#endif // OSMIUM_WITH_SPARSEHASH
-
-#endif // OSMIUM_INDEX_MAP_SPARSE_MEM_TABLE_HPP
diff --git a/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp b/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
index 47310e83c..5cc2641a8 100644
--- a/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/map/sparse_mmap_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap.hpp b/third_party/libosmium/include/osmium/index/multimap.hpp
index 5d9b610fa..a91e834f9 100644
--- a/third_party/libosmium/include/osmium/index/multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -113,7 +113,7 @@ namespace osmium {
                 }
 
                 virtual void dump_as_list(const int /*fd*/) {
-                    std::runtime_error("can't dump as list");
+                    throw std::runtime_error{"can't dump as list"};
                 }
 
             }; // class Multimap
diff --git a/third_party/libosmium/include/osmium/index/multimap/all.hpp b/third_party/libosmium/include/osmium/index/multimap/all.hpp
index 989f0ad90..3fa1b87d8 100644
--- a/third_party/libosmium/include/osmium/index/multimap/all.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/all.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp b/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
index 3c1d049b6..cd69d4a36 100644
--- a/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/hybrid.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,10 +62,10 @@ namespace osmium {
 
             public:
 
-                 HybridIterator(typename main_map_type::iterator begin_main,
-                                typename main_map_type::iterator end_main,
-                                typename extra_map_type::iterator begin_extra,
-                                typename extra_map_type::iterator end_extra) :
+                HybridIterator(typename main_map_type::iterator begin_main,
+                               typename main_map_type::iterator end_main,
+                               typename extra_map_type::iterator begin_extra,
+                               typename extra_map_type::iterator end_extra) :
                     m_begin_main(begin_main),
                     m_end_main(end_main),
                     m_begin_extra(begin_extra),
@@ -87,7 +87,7 @@ namespace osmium {
                 }
 
                 HybridIterator<TId, TValue> operator++(int) {
-                    auto tmp(*this);
+                    const auto tmp{*this};
                     operator++();
                     return tmp;
                 }
@@ -100,15 +100,14 @@ namespace osmium {
                 }
 
                 bool operator!=(const HybridIterator& rhs) const {
-                    return ! operator==(rhs);
+                    return !operator==(rhs);
                 }
 
                 const element_type& operator*() {
                     if (m_begin_main == m_end_main) {
                         return *m_begin_extra;
-                    } else {
-                        return *m_begin_main;
                     }
+                    return *m_begin_main;
                 }
 
                 const element_type* operator->() {
@@ -159,10 +158,10 @@ namespace osmium {
                 }
 
                 std::pair<iterator, iterator> get_all(const TId id) {
-                    auto result_main = m_main.get_all(id);
-                    auto result_extra = m_extra.get_all(id);
-                    return std::make_pair(iterator(result_main.first, result_main.second, result_extra.first, result_extra.second),
-                                          iterator(result_main.second, result_main.second, result_extra.second, result_extra.second));
+                    const auto result_main = m_main.get_all(id);
+                    const auto result_extra = m_extra.get_all(id);
+                    return std::make_pair(iterator{result_main.first, result_main.second, result_extra.first, result_extra.second},
+                                          iterator{result_main.second, result_main.second, result_extra.second, result_extra.second});
                 }
 
                 void remove(const TId id, const TValue value) {
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
index e5f5b9226..0a30df1f4 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_file_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
index a6d7a5ac9..713aa0bbe 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
index 917a5a04d..0a1b0ffa2 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mem_multimap.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -53,13 +53,15 @@ namespace osmium {
              * lot of memory, but might make sense for small maps.
              */
             template <typename TId, typename TValue>
-            class SparseMemMultimap : public osmium::index::multimap::Multimap<TId, TValue> {
+            class SparseMemMultimap final : public osmium::index::multimap::Multimap<TId, TValue> {
 
                 // This is a rough estimate for the memory needed for each
                 // element in the map (id + value + pointers to left, right,
                 // and parent plus some overhead for color of red-black-tree
                 // or similar).
-                static constexpr size_t element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4;
+                enum {
+                    element_size = sizeof(TId) + sizeof(TValue) + sizeof(void*) * 4U
+                };
 
             public:
 
@@ -77,13 +79,13 @@ namespace osmium {
 
                 SparseMemMultimap() = default;
 
-                ~SparseMemMultimap() noexcept final = default;
+                ~SparseMemMultimap() noexcept = default;
 
                 void unsorted_set(const TId id, const TValue value) {
                     m_elements.emplace(id, value);
                 }
 
-                void set(const TId id, const TValue value) final {
+                void set(const TId id, const TValue value) override {
                     m_elements.emplace(id, value);
                 }
 
@@ -113,15 +115,15 @@ namespace osmium {
                     return m_elements.end();
                 }
 
-                size_t size() const final {
+                size_t size() const override {
                     return m_elements.size();
                 }
 
-                size_t used_memory() const final {
+                size_t used_memory() const override {
                     return element_size * m_elements.size();
                 }
 
-                void clear() final {
+                void clear() override {
                     m_elements.clear();
                 }
 
@@ -129,7 +131,7 @@ namespace osmium {
                     // intentionally left blank
                 }
 
-                void dump_as_list(const int fd) final {
+                void dump_as_list(const int fd) override {
                     std::vector<element_type> v;
                     v.reserve(m_elements.size());
                     for (const auto& element : m_elements) {
diff --git a/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp b/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
index 87629f786..d2e0f12b4 100644
--- a/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
+++ b/third_party/libosmium/include/osmium/index/multimap/sparse_mmap_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/node_locations_map.hpp b/third_party/libosmium/include/osmium/index/node_locations_map.hpp
index 70eb264d0..599e31cbc 100644
--- a/third_party/libosmium/include/osmium/index/node_locations_map.hpp
+++ b/third_party/libosmium/include/osmium/index/node_locations_map.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/index/nwr_array.hpp b/third_party/libosmium/include/osmium/index/nwr_array.hpp
index 69132bd49..bf29f8ec9 100644
--- a/third_party/libosmium/include/osmium/index/nwr_array.hpp
+++ b/third_party/libosmium/include/osmium/index/nwr_array.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -35,21 +35,84 @@ DEALINGS IN THE SOFTWARE.
 
 #include <osmium/osm/item_type.hpp>
 
+#include <array>
+
 namespace osmium {
 
+    /**
+     * Often some information must be kept separately for nodes, ways, and
+     * relations. Then this helper class becomes useful. It can keep three
+     * somethings (of type T) which can be accessed conveniently through
+     * the call operator.
+     */
     template <typename T>
     class nwr_array {
 
-        T m_sets[3];
+        std::array<T, 3> m_data;
 
     public:
 
-        T& operator()(osmium::item_type type) noexcept {
-            return m_sets[osmium::item_type_to_nwr_index(type)];
+        using iterator = typename std::array<T, 3>::iterator;
+        using const_iterator = typename std::array<T, 3>::const_iterator;
+
+        nwr_array() :
+            m_data() {
         }
 
-        const T& operator()(osmium::item_type type) const noexcept {
-            return m_sets[osmium::item_type_to_nwr_index(type)];
+        T& operator()(const osmium::item_type type) noexcept {
+            return m_data[osmium::item_type_to_nwr_index(type)];
+        }
+
+        const T& operator()(const osmium::item_type type) const noexcept {
+            return m_data[osmium::item_type_to_nwr_index(type)];
+        }
+
+        T& nodes() noexcept {
+            return m_data[0];
+        }
+
+        const T& nodes() const noexcept {
+            return m_data[0];
+        }
+
+        T& ways() noexcept {
+            return m_data[1];
+        }
+
+        const T& ways() const noexcept {
+            return m_data[1];
+        }
+
+        T& relations() noexcept {
+            return m_data[2];
+        }
+
+        const T& relations() const noexcept {
+            return m_data[2];
+        }
+
+        iterator begin() noexcept {
+            return m_data.begin();
+        }
+
+        iterator end() noexcept {
+            return m_data.end();
+        }
+
+        const_iterator begin() const noexcept {
+            return m_data.cbegin();
+        }
+
+        const_iterator end() const noexcept {
+            return m_data.cend();
+        }
+
+        const_iterator cbegin() const noexcept {
+            return m_data.cbegin();
+        }
+
+        const_iterator cend() const noexcept {
+            return m_data.cend();
         }
 
     }; // class nwr_array
diff --git a/third_party/libosmium/include/osmium/index/relations_map.hpp b/third_party/libosmium/include/osmium/index/relations_map.hpp
index f514940d1..6cdb371a3 100644
--- a/third_party/libosmium/include/osmium/index/relations_map.hpp
+++ b/third_party/libosmium/include/osmium/index/relations_map.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -66,12 +66,12 @@ namespace osmium {
                     TKeyInternal key;
                     TValueInternal value;
 
-                    explicit kv_pair(key_type key_id) :
+                    explicit kv_pair(const key_type key_id) :
                         key(static_cast<TKeyInternal>(key_id)),
                         value() {
                     }
 
-                    kv_pair(key_type key_id, value_type value_id) :
+                    kv_pair(const key_type key_id, const value_type value_id) :
                         key(static_cast<TKeyInternal>(key_id)),
                         value(static_cast<TValueInternal>(value_id)) {
                     }
@@ -91,7 +91,7 @@ namespace osmium {
 
                 using const_iterator = typename std::vector<kv_pair>::const_iterator;
 
-                void set(key_type key, value_type value) {
+                void set(const key_type key, const value_type value) {
                     m_map.emplace_back(key, value);
                 }
 
@@ -119,7 +119,7 @@ namespace osmium {
                     m_map.erase(last, m_map.end());
                 }
 
-                std::pair<const_iterator, const_iterator> get(key_type key) const noexcept {
+                std::pair<const_iterator, const_iterator> get(const key_type key) const noexcept {
                     return std::equal_range(m_map.begin(), m_map.end(), kv_pair{key}, [](const kv_pair& lhs, const kv_pair& rhs) {
                         return lhs.key < rhs.key;
                     });
@@ -133,7 +133,7 @@ namespace osmium {
                     return m_map.size();
                 }
 
-                void reserve(std::size_t size) {
+                void reserve(const std::size_t size) {
                     m_map.reserve(size);
                 }
 
@@ -209,10 +209,10 @@ namespace osmium {
              *             (Lookup uses binary search.)
              */
             template <typename TFunc>
-            void for_each_parent(osmium::unsigned_object_id_type member_id, TFunc&& func) const {
+            void for_each_parent(const osmium::unsigned_object_id_type member_id, TFunc&& func) const {
                 const auto parents = m_map.get(member_id);
                 for (auto it = parents.first; it != parents.second; ++it) {
-                    std::forward<TFunc>(func)(it->value);
+                    func(it->value);
                 }
             }
 
@@ -231,10 +231,10 @@ namespace osmium {
              *             (Lookup uses binary search.)
              */
             template <typename TFunc>
-            void for_each(osmium::unsigned_object_id_type id, TFunc&& func) const {
+            void for_each(const osmium::unsigned_object_id_type id, TFunc&& func) const {
                 const auto parents = m_map.get(id);
                 for (auto it = parents.first; it != parents.second; ++it) {
-                    std::forward<TFunc>(func)(it->value);
+                    func(it->value);
                 }
             }
 
@@ -336,7 +336,7 @@ namespace osmium {
             /**
              * Add mapping from member to parent relation in the stash.
              */
-            void add(osmium::unsigned_object_id_type member_id, osmium::unsigned_object_id_type relation_id) {
+            void add(const osmium::unsigned_object_id_type member_id, const osmium::unsigned_object_id_type relation_id) {
                 assert(m_valid && "You can't use the RelationsMap any more after calling build_index()");
                 m_map.set(member_id, relation_id);
             }
diff --git a/third_party/libosmium/include/osmium/io/any_compression.hpp b/third_party/libosmium/include/osmium/io/any_compression.hpp
index ab3384226..268351446 100644
--- a/third_party/libosmium/include/osmium/io/any_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/any_compression.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/any_input.hpp b/third_party/libosmium/include/osmium/io/any_input.hpp
index d2708592f..ae00f876f 100644
--- a/third_party/libosmium/include/osmium/io/any_input.hpp
+++ b/third_party/libosmium/include/osmium/io/any_input.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/any_output.hpp b/third_party/libosmium/include/osmium/io/any_output.hpp
index 52f989e62..029c5cabb 100644
--- a/third_party/libosmium/include/osmium/io/any_output.hpp
+++ b/third_party/libosmium/include/osmium/io/any_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -46,6 +46,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/any_compression.hpp> // IWYU pragma: export
 
 #include <osmium/io/debug_output.hpp> // IWYU pragma: export
+#include <osmium/io/ids_output.hpp> // IWYU pragma: export
 #include <osmium/io/opl_output.hpp> // IWYU pragma: export
 #include <osmium/io/pbf_output.hpp> // IWYU pragma: export
 #include <osmium/io/xml_output.hpp> // IWYU pragma: export
diff --git a/third_party/libosmium/include/osmium/io/bzip2_compression.hpp b/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
index b3d216114..bed643753 100644
--- a/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/bzip2_compression.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,7 +36,7 @@ DEALINGS IN THE SOFTWARE.
 /**
  * @file
  *
- * Include this file if you want to read or write bzip2-compressed OSM XML
+ * Include this file if you want to read or write bzip2-compressed OSM
  * files.
  *
  * @attention If you include this file, you'll need to link with `libbz2`.
@@ -47,7 +47,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/error.hpp>
 #include <osmium/io/file_compression.hpp>
 #include <osmium/io/writer_options.hpp>
-#include <osmium/util/compatibility.hpp>
+#include <osmium/util/file.hpp>
 
 #include <bzlib.h>
 
@@ -70,13 +70,15 @@ namespace osmium {
      */
     struct bzip2_error : public io_error {
 
-        int bzip2_error_code;
-        int system_errno;
+        int bzip2_error_code = 0;
+        int system_errno = 0;
 
-        bzip2_error(const std::string& what, int error_code) :
+        bzip2_error(const std::string& what, const int error_code) :
             io_error(what),
-            bzip2_error_code(error_code),
-            system_errno(error_code == BZ_IO_ERROR ? errno : 0) {
+            bzip2_error_code(error_code) {
+            if (error_code == BZ_IO_ERROR) {
+                system_errno = errno;
+            }
         }
 
     }; // struct bzip2_error
@@ -85,36 +87,102 @@ namespace osmium {
 
         namespace detail {
 
-            OSMIUM_NORETURN inline void throw_bzip2_error(BZFILE* bzfile, const char* msg, int bzlib_error = 0) {
+            [[noreturn]] inline void throw_bzip2_error(BZFILE* bzfile, const char* msg, const int bzlib_error) {
                 std::string error{"bzip2 error: "};
                 error += msg;
                 error += ": ";
                 int errnum = bzlib_error;
                 if (bzlib_error) {
                     error += std::to_string(bzlib_error);
-                } else {
+                } else if (bzfile) {
                     error += ::BZ2_bzerror(bzfile, &errnum);
                 }
                 throw osmium::bzip2_error{error, errnum};
             }
 
+            class file_wrapper {
+
+                FILE* m_file = nullptr;
+
+            public:
+
+                file_wrapper() noexcept = default;
+
+                file_wrapper(const int fd, const char* mode) {
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    m_file = fdopen(fd, mode);
+                    if (!m_file) {
+
+                        // Do not close stdout
+                        if (fd != 1) {
+                            ::close(fd);
+                        }
+                        throw std::system_error{errno, std::system_category(), "fdopen failed"};
+                    }
+                }
+
+                file_wrapper(const file_wrapper&) = delete;
+                file_wrapper& operator=(const file_wrapper&) = delete;
+
+                file_wrapper(file_wrapper&&) = delete;
+                file_wrapper& operator=(file_wrapper&&) = delete;
+
+                ~file_wrapper() noexcept {
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    if (m_file) {
+                        fclose(m_file);
+                    }
+                }
+
+                FILE* file() const noexcept {
+                    return m_file;
+                }
+
+                void close() {
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    if (m_file) {
+                        FILE* wrapped_file = m_file;
+                        m_file = nullptr;
+
+                        // Do not close stdout
+                        if (fileno(wrapped_file) == 1) {
+                            return;
+                        }
+
+                        if (fclose(wrapped_file) != 0) {
+                            throw std::system_error{errno, std::system_category(), "fclose failed"};
+                        }
+                    }
+                }
+
+            }; // class file_wrapper
+
         } // namespace detail
 
-        class Bzip2Compressor : public Compressor {
+        class Bzip2Compressor final : public Compressor {
 
-            FILE* m_file;
-            int m_bzerror;
-            BZFILE* m_bzfile;
+            std::size_t m_file_size = 0;
+            detail::file_wrapper m_file;
+            BZFILE* m_bzfile = nullptr;
 
         public:
 
-            explicit Bzip2Compressor(int fd, fsync sync) :
+            explicit Bzip2Compressor(const int fd, const fsync sync) :
                 Compressor(sync),
-                m_file(fdopen(::dup(fd), "wb")),
-                m_bzerror(BZ_OK),
-                m_bzfile(::BZ2_bzWriteOpen(&m_bzerror, m_file, 6, 0, 0)) {
+                m_file(fd, "wb") {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                int bzerror = BZ_OK;
+                m_bzfile = ::BZ2_bzWriteOpen(&bzerror, m_file.file(), 6, 0, 0);
                 if (!m_bzfile) {
-                    detail::throw_bzip2_error(m_bzfile, "write open failed", m_bzerror);
+                    throw bzip2_error{"bzip2 error: write open failed", bzerror};
                 }
             }
 
@@ -124,7 +192,7 @@ namespace osmium {
             Bzip2Compressor(Bzip2Compressor&&) = delete;
             Bzip2Compressor& operator=(Bzip2Compressor&&) = delete;
 
-            ~Bzip2Compressor() noexcept final {
+            ~Bzip2Compressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -132,50 +200,63 @@ namespace osmium {
                 }
             }
 
-            void write(const std::string& data) final {
-                int error;
+            void write(const std::string& data) override {
                 assert(data.size() < std::numeric_limits<int>::max());
-                ::BZ2_bzWrite(&error, m_bzfile, const_cast<char*>(data.data()), static_cast<int>(data.size()));
-                if (error != BZ_OK && error != BZ_STREAM_END) {
-                    detail::throw_bzip2_error(m_bzfile, "write failed", error);
+                assert(m_bzfile);
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                int bzerror = BZ_OK;
+                ::BZ2_bzWrite(&bzerror, m_bzfile, const_cast<char*>(data.data()), static_cast<int>(data.size()));
+                if (bzerror != BZ_OK && bzerror != BZ_STREAM_END) {
+                    detail::throw_bzip2_error(m_bzfile, "write failed", bzerror);
                 }
             }
 
-            void close() final {
+            void close() override {
                 if (m_bzfile) {
-                    int error;
-                    ::BZ2_bzWriteClose(&error, m_bzfile, 0, nullptr, nullptr);
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    int bzerror = BZ_OK;
+                    unsigned int nbytes_out_lo32 = 0;
+                    unsigned int nbytes_out_hi32 = 0;
+                    ::BZ2_bzWriteClose64(&bzerror, m_bzfile, 0, nullptr, nullptr, &nbytes_out_lo32, &nbytes_out_hi32);
                     m_bzfile = nullptr;
-                    if (m_file) {
-                        if (do_fsync()) {
-                            osmium::io::detail::reliable_fsync(::fileno(m_file));
-                        }
-                        if (fclose(m_file) != 0) {
-                            throw std::system_error{errno, std::system_category(), "Close failed"};
-                        }
+                    if (do_fsync() && m_file.file()) {
+                        osmium::io::detail::reliable_fsync(fileno(m_file.file()));
                     }
-                    if (error != BZ_OK) {
-                        detail::throw_bzip2_error(m_bzfile, "write close failed", error);
+                    m_file.close();
+                    if (bzerror != BZ_OK) {
+                        throw bzip2_error{"bzip2 error: write close failed", bzerror};
                     }
+                    m_file_size = static_cast<std::size_t>(static_cast<uint64_t>(nbytes_out_hi32) << 32U | nbytes_out_lo32);
                 }
             }
 
+            std::size_t file_size() const override {
+                return m_file_size;
+            }
+
         }; // class Bzip2Compressor
 
-        class Bzip2Decompressor : public Decompressor {
+        class Bzip2Decompressor final : public Decompressor {
 
-            FILE* m_file;
-            int m_bzerror = BZ_OK;
-            BZFILE* m_bzfile;
+            detail::file_wrapper m_file;
+            BZFILE* m_bzfile = nullptr;
             bool m_stream_end = false;
 
         public:
 
-            explicit Bzip2Decompressor(int fd) :
-                m_file(fdopen(::dup(fd), "rb")),
-                m_bzfile(::BZ2_bzReadOpen(&m_bzerror, m_file, 0, 0, nullptr, 0)) {
+            explicit Bzip2Decompressor(const int fd) :
+                m_file(fd, "rb") {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                int bzerror = BZ_OK;
+                m_bzfile = ::BZ2_bzReadOpen(&bzerror, m_file.file(), 0, 0, nullptr, 0);
                 if (!m_bzfile) {
-                    detail::throw_bzip2_error(m_bzfile, "read open failed", m_bzerror);
+                    throw bzip2_error{"bzip2 error: read open failed", bzerror};
                 }
             }
 
@@ -185,7 +266,7 @@ namespace osmium {
             Bzip2Decompressor(Bzip2Decompressor&&) = delete;
             Bzip2Decompressor& operator=(Bzip2Decompressor&&) = delete;
 
-            ~Bzip2Decompressor() noexcept final {
+            ~Bzip2Decompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -193,34 +274,42 @@ namespace osmium {
                 }
             }
 
-            std::string read() final {
+            std::string read() override {
+                const auto offset = ftell(m_file.file());
+                if (offset > 0 && want_buffered_pages_removed()) {
+                    osmium::io::detail::remove_buffered_pages(fileno(m_file.file()), static_cast<std::size_t>(offset));
+                }
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                assert(m_bzfile);
                 std::string buffer;
 
                 if (!m_stream_end) {
                     buffer.resize(osmium::io::Decompressor::input_buffer_size);
-                    int error;
+                    int bzerror = BZ_OK;
                     assert(buffer.size() < std::numeric_limits<int>::max());
-                    const int nread = ::BZ2_bzRead(&error, m_bzfile, const_cast<char*>(buffer.data()), static_cast<int>(buffer.size()));
-                    if (error != BZ_OK && error != BZ_STREAM_END) {
-                        detail::throw_bzip2_error(m_bzfile, "read failed", error);
+                    const int nread = ::BZ2_bzRead(&bzerror, m_bzfile, &*buffer.begin(), static_cast<int>(buffer.size()));
+                    if (bzerror != BZ_OK && bzerror != BZ_STREAM_END) {
+                        detail::throw_bzip2_error(m_bzfile, "read failed", bzerror);
                     }
-                    if (error == BZ_STREAM_END) {
-                        void* unused;
-                        int nunused;
-                        if (! feof(m_file)) {
-                            ::BZ2_bzReadGetUnused(&error, m_bzfile, &unused, &nunused);
-                            if (error != BZ_OK) {
-                                detail::throw_bzip2_error(m_bzfile, "get unused failed", error);
+                    if (bzerror == BZ_STREAM_END) {
+                        void* unused = nullptr;
+                        int nunused = 0;
+                        if (!feof(m_file.file())) {
+                            ::BZ2_bzReadGetUnused(&bzerror, m_bzfile, &unused, &nunused);
+                            if (bzerror != BZ_OK) {
+                                detail::throw_bzip2_error(m_bzfile, "get unused failed", bzerror);
                             }
-                            std::string unused_data(static_cast<const char*>(unused), static_cast<std::string::size_type>(nunused));
-                            ::BZ2_bzReadClose(&error, m_bzfile);
-                            if (error != BZ_OK) {
-                                detail::throw_bzip2_error(m_bzfile, "read close failed", error);
+                            std::string unused_data{static_cast<const char*>(unused), static_cast<std::string::size_type>(nunused)};
+                            ::BZ2_bzReadClose(&bzerror, m_bzfile);
+                            if (bzerror != BZ_OK) {
+                                throw bzip2_error{"bzip2 error: read close failed", bzerror};
                             }
                             assert(unused_data.size() < std::numeric_limits<int>::max());
-                            m_bzfile = ::BZ2_bzReadOpen(&error, m_file, 0, 0, const_cast<void*>(static_cast<const void*>(unused_data.data())), static_cast<int>(unused_data.size()));
-                            if (error != BZ_OK) {
-                                detail::throw_bzip2_error(m_bzfile, "read open failed", error);
+                            m_bzfile = ::BZ2_bzReadOpen(&bzerror, m_file.file(), 0, 0, &*unused_data.begin(), static_cast<int>(unused_data.size()));
+                            if (!m_bzfile) {
+                                throw bzip2_error{"bzip2 error: read open failed", bzerror};
                             }
                         } else {
                             m_stream_end = true;
@@ -229,38 +318,40 @@ namespace osmium {
                     buffer.resize(static_cast<std::string::size_type>(nread));
                 }
 
-                set_offset(size_t(ftell(m_file)));
+                set_offset(static_cast<std::size_t>(ftell(m_file.file())));
 
                 return buffer;
             }
 
-            void close() final {
+            void close() override {
                 if (m_bzfile) {
-                    int error;
-                    ::BZ2_bzReadClose(&error, m_bzfile);
-                    m_bzfile = nullptr;
-                    if (m_file) {
-                        if (fclose(m_file) != 0) {
-                            throw std::system_error{errno, std::system_category(), "Close failed"};
-                        }
+                    if (want_buffered_pages_removed()) {
+                        osmium::io::detail::remove_buffered_pages(fileno(m_file.file()));
                     }
-                    if (error != BZ_OK) {
-                        detail::throw_bzip2_error(m_bzfile, "read close failed", error);
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    int bzerror = BZ_OK;
+                    ::BZ2_bzReadClose(&bzerror, m_bzfile);
+                    m_bzfile = nullptr;
+                    m_file.close();
+                    if (bzerror != BZ_OK) {
+                        throw bzip2_error{"bzip2 error: read close failed", bzerror};
                     }
                 }
             }
 
         }; // class Bzip2Decompressor
 
-        class Bzip2BufferDecompressor : public Decompressor {
+        class Bzip2BufferDecompressor final : public Decompressor {
 
             const char* m_buffer;
-            size_t m_buffer_size;
+            std::size_t m_buffer_size;
             bz_stream m_bzstream;
 
         public:
 
-            Bzip2BufferDecompressor(const char* buffer, size_t size) :
+            Bzip2BufferDecompressor(const char* buffer, const std::size_t size) :
                 m_buffer(buffer),
                 m_buffer_size(size),
                 m_bzstream() {
@@ -269,8 +360,7 @@ namespace osmium {
                 m_bzstream.avail_in = static_cast<unsigned int>(size);
                 const int result = BZ2_bzDecompressInit(&m_bzstream, 0, 0);
                 if (result != BZ_OK) {
-                    std::string message{"bzip2 error: decompression init failed: "};
-                    throw bzip2_error{message, result};
+                    throw bzip2_error{"bzip2 error: decompression init failed: ", result};
                 }
             }
 
@@ -280,7 +370,7 @@ namespace osmium {
             Bzip2BufferDecompressor(Bzip2BufferDecompressor&&) = delete;
             Bzip2BufferDecompressor& operator=(Bzip2BufferDecompressor&&) = delete;
 
-            ~Bzip2BufferDecompressor() noexcept final {
+            ~Bzip2BufferDecompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -288,13 +378,13 @@ namespace osmium {
                 }
             }
 
-            std::string read() final {
+            std::string read() override {
                 std::string output;
 
                 if (m_buffer) {
-                    const size_t buffer_size = 10240;
+                    const std::size_t buffer_size = 10240;
                     output.resize(buffer_size);
-                    m_bzstream.next_out = const_cast<char*>(output.data());
+                    m_bzstream.next_out = &*output.begin();
                     m_bzstream.avail_out = buffer_size;
                     const int result = BZ2_bzDecompress(&m_bzstream);
 
@@ -304,8 +394,7 @@ namespace osmium {
                     }
 
                     if (result != BZ_OK && result != BZ_STREAM_END) {
-                        std::string message{"bzip2 error: decompress failed: "};
-                        throw bzip2_error{message, result};
+                        throw bzip2_error{"bzip2 error: decompress failed: ", result};
                     }
 
                     output.resize(static_cast<std::size_t>(m_bzstream.next_out - output.data()));
@@ -314,7 +403,7 @@ namespace osmium {
                 return output;
             }
 
-            void close() final {
+            void close() override {
                 BZ2_bzDecompressEnd(&m_bzstream);
             }
 
@@ -325,9 +414,9 @@ namespace osmium {
             // we want the register_compression() function to run, setting
             // the variable is only a side-effect, it will never be used
             const bool registered_bzip2_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::bzip2,
-                [](int fd, fsync sync) { return new osmium::io::Bzip2Compressor{fd, sync}; },
-                [](int fd) { return new osmium::io::Bzip2Decompressor{fd}; },
-                [](const char* buffer, size_t size) { return new osmium::io::Bzip2BufferDecompressor{buffer, size}; }
+                [](const int fd, const fsync sync) { return new osmium::io::Bzip2Compressor{fd, sync}; },
+                [](const int fd) { return new osmium::io::Bzip2Decompressor{fd}; },
+                [](const char* buffer, const std::size_t size) { return new osmium::io::Bzip2BufferDecompressor{buffer, size}; }
             );
 
             // dummy function to silence the unused variable warning from above
diff --git a/third_party/libosmium/include/osmium/io/compression.hpp b/third_party/libosmium/include/osmium/io/compression.hpp
index b26d279f3..309150ddc 100644
--- a/third_party/libosmium/include/osmium/io/compression.hpp
+++ b/third_party/libosmium/include/osmium/io/compression.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -50,12 +50,6 @@ DEALINGS IN THE SOFTWARE.
 #include <tuple>
 #include <utility>
 
-#ifndef _MSC_VER
-# include <unistd.h>
-#else
-# include <io.h>
-#endif
-
 namespace osmium {
 
     namespace io {
@@ -66,13 +60,13 @@ namespace osmium {
 
         protected:
 
-            bool do_fsync() const {
+            bool do_fsync() const noexcept {
                 return m_fsync == fsync::yes;
             }
 
         public:
 
-            explicit Compressor(fsync sync) :
+            explicit Compressor(const fsync sync) noexcept :
                 m_fsync(sync) {
             }
 
@@ -88,16 +82,23 @@ namespace osmium {
 
             virtual void close() = 0;
 
+            virtual std::size_t file_size() const {
+                return 0;
+            }
+
         }; // class Compressor
 
         class Decompressor {
 
-            std::atomic<std::size_t> m_file_size{0};
-            std::atomic<std::size_t> m_offset{0};
+            std::atomic<std::size_t>* m_offset_ptr{nullptr};
+
+            std::atomic_bool m_want_buffered_pages_removed{false};
 
         public:
 
-            static constexpr unsigned int input_buffer_size = 1024 * 1024;
+            enum {
+                input_buffer_size = 1024U * 1024U
+            };
 
             Decompressor() = default;
 
@@ -113,20 +114,26 @@ namespace osmium {
 
             virtual void close() = 0;
 
-            std::size_t file_size() const noexcept {
-                return m_file_size;
+            virtual bool is_real() const noexcept {
+                return true;
             }
 
-            void set_file_size(std::size_t size) noexcept {
-                m_file_size = size;
+            void set_offset_ptr(std::atomic<std::size_t>* offset_ptr) noexcept {
+                m_offset_ptr = offset_ptr;
             }
 
-            std::size_t offset() const noexcept {
-                return m_offset;
+            void set_offset(const std::size_t offset) noexcept {
+                if (m_offset_ptr) {
+                    *m_offset_ptr = offset;
+                }
             }
 
-            void set_offset(std::size_t offset) noexcept {
-                m_offset = offset;
+            bool want_buffered_pages_removed() const noexcept {
+                return m_want_buffered_pages_removed;
+            }
+
+            void set_want_buffered_pages_removed(bool value) noexcept {
+                m_want_buffered_pages_removed = value;
             }
 
         }; // class Decompressor
@@ -158,7 +165,7 @@ namespace osmium {
 
             CompressionFactory() = default;
 
-            const callbacks_type& find_callbacks(osmium::io::file_compression compression) const {
+            const callbacks_type& find_callbacks(const osmium::io::file_compression compression) const {
                 const auto it = m_callbacks.find(compression);
 
                 if (it != m_callbacks.end()) {
@@ -188,9 +195,9 @@ namespace osmium {
 
             bool register_compression(
                 osmium::io::file_compression compression,
-                create_compressor_type create_compressor,
-                create_decompressor_type_fd create_decompressor_fd,
-                create_decompressor_type_buffer create_decompressor_buffer) {
+                const create_compressor_type& create_compressor,
+                const create_decompressor_type_fd& create_decompressor_fd,
+                const create_decompressor_type_buffer& create_decompressor_buffer) {
 
                 compression_map_type::value_type cc{compression,
                                                     std::make_tuple(create_compressor,
@@ -201,32 +208,31 @@ namespace osmium {
             }
 
             template <typename... TArgs>
-            std::unique_ptr<osmium::io::Compressor> create_compressor(osmium::io::file_compression compression, TArgs&&... args) const {
+            std::unique_ptr<osmium::io::Compressor> create_compressor(const osmium::io::file_compression compression, TArgs&&... args) const {
                 const auto callbacks = find_callbacks(compression);
                 return std::unique_ptr<osmium::io::Compressor>(std::get<0>(callbacks)(std::forward<TArgs>(args)...));
             }
 
-            std::unique_ptr<osmium::io::Decompressor> create_decompressor(osmium::io::file_compression compression, int fd) const {
+            std::unique_ptr<osmium::io::Decompressor> create_decompressor(const osmium::io::file_compression compression, const int fd) const {
                 const auto callbacks = find_callbacks(compression);
-                auto p = std::unique_ptr<osmium::io::Decompressor>(std::get<1>(callbacks)(fd));
-                p->set_file_size(osmium::file_size(fd));
-                return p;
+                return std::unique_ptr<osmium::io::Decompressor>(std::get<1>(callbacks)(fd));
             }
 
-            std::unique_ptr<osmium::io::Decompressor> create_decompressor(osmium::io::file_compression compression, const char* buffer, std::size_t size) const {
+            std::unique_ptr<osmium::io::Decompressor> create_decompressor(const osmium::io::file_compression compression, const char* buffer, const std::size_t size) const {
                 const auto callbacks = find_callbacks(compression);
                 return std::unique_ptr<osmium::io::Decompressor>(std::get<2>(callbacks)(buffer, size));
             }
 
         }; // class CompressionFactory
 
-        class NoCompressor : public Compressor {
+        class NoCompressor final : public Compressor {
 
+            std::size_t m_file_size = 0;
             int m_fd;
 
         public:
 
-            NoCompressor(int fd, fsync sync) :
+            NoCompressor(const int fd, const fsync sync) :
                 Compressor(sync),
                 m_fd(fd) {
             }
@@ -237,7 +243,7 @@ namespace osmium {
             NoCompressor(NoCompressor&&) = delete;
             NoCompressor& operator=(NoCompressor&&) = delete;
 
-            ~NoCompressor() noexcept final {
+            ~NoCompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -245,14 +251,21 @@ namespace osmium {
                 }
             }
 
-            void write(const std::string& data) final {
+            void write(const std::string& data) override {
                 osmium::io::detail::reliable_write(m_fd, data.data(), data.size());
+                m_file_size += data.size();
             }
 
-            void close() final {
+            void close() override {
                 if (m_fd >= 0) {
                     const int fd = m_fd;
                     m_fd = -1;
+
+                    // Do not sync or close stdout
+                    if (fd == 1) {
+                        return;
+                    }
+
                     if (do_fsync()) {
                         osmium::io::detail::reliable_fsync(fd);
                     }
@@ -260,9 +273,44 @@ namespace osmium {
                 }
             }
 
+            std::size_t file_size() const override {
+                return m_file_size;
+            }
+
         }; // class NoCompressor
 
-        class NoDecompressor : public Decompressor {
+        /**
+         * The DummyDecompressor is used when reading PBF files. In that
+         * case the PBFParser class is responsible for reading from the
+         * file itself, and the DummyDecompressor does nothing.
+         */
+        class DummyDecompressor final : public Decompressor {
+        public:
+
+            DummyDecompressor() = default;
+
+            DummyDecompressor(const DummyDecompressor&) = delete;
+            DummyDecompressor& operator=(const DummyDecompressor&) = delete;
+
+            DummyDecompressor(DummyDecompressor&&) = delete;
+            DummyDecompressor& operator=(DummyDecompressor&&) = delete;
+
+            ~DummyDecompressor() noexcept override = default;
+
+            std::string read() override {
+                return {};
+            }
+
+            void close() override {
+            }
+
+            bool is_real() const noexcept override {
+                return false;
+            }
+
+        }; // class DummyDecompressor
+
+        class NoDecompressor final : public Decompressor {
 
             int m_fd = -1;
             const char* m_buffer = nullptr;
@@ -271,11 +319,11 @@ namespace osmium {
 
         public:
 
-            explicit NoDecompressor(int fd) :
+            explicit NoDecompressor(const int fd) :
                 m_fd(fd) {
             }
 
-            NoDecompressor(const char* buffer, std::size_t size) :
+            NoDecompressor(const char* buffer, const std::size_t size) :
                 m_buffer(buffer),
                 m_buffer_size(size) {
             }
@@ -286,7 +334,7 @@ namespace osmium {
             NoDecompressor(NoDecompressor&&) = delete;
             NoDecompressor& operator=(NoDecompressor&&) = delete;
 
-            ~NoDecompressor() noexcept final {
+            ~NoDecompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -294,7 +342,7 @@ namespace osmium {
                 }
             }
 
-            std::string read() final {
+            std::string read() override {
                 std::string buffer;
 
                 if (m_buffer) {
@@ -305,7 +353,10 @@ namespace osmium {
                     }
                 } else {
                     buffer.resize(osmium::io::Decompressor::input_buffer_size);
-                    const auto nread = detail::reliable_read(m_fd, const_cast<char*>(buffer.data()), osmium::io::Decompressor::input_buffer_size);
+                    if (want_buffered_pages_removed()) {
+                        osmium::io::detail::remove_buffered_pages(m_fd, m_offset);
+                    }
+                    const auto nread = detail::reliable_read(m_fd, &*buffer.begin(), osmium::io::Decompressor::input_buffer_size);
                     buffer.resize(std::string::size_type(nread));
                 }
 
@@ -315,8 +366,11 @@ namespace osmium {
                 return buffer;
             }
 
-            void close() final {
+            void close() override {
                 if (m_fd >= 0) {
+                    if (want_buffered_pages_removed()) {
+                        osmium::io::detail::remove_buffered_pages(m_fd);
+                    }
                     const int fd = m_fd;
                     m_fd = -1;
                     osmium::io::detail::reliable_close(fd);
@@ -330,8 +384,8 @@ namespace osmium {
             // we want the register_compression() function to run, setting
             // the variable is only a side-effect, it will never be used
             const bool registered_no_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::none,
-                [](int fd, fsync sync) { return new osmium::io::NoCompressor{fd, sync}; },
-                [](int fd) { return new osmium::io::NoDecompressor{fd}; },
+                [](const int fd, const fsync sync) { return new osmium::io::NoCompressor{fd, sync}; },
+                [](const int fd) { return new osmium::io::NoDecompressor{fd}; },
                 [](const char* buffer, std::size_t size) { return new osmium::io::NoDecompressor{buffer, size}; }
             );
 
diff --git a/third_party/libosmium/include/osmium/io/debug_output.hpp b/third_party/libosmium/include/osmium/io/debug_output.hpp
index eac514f10..3f59d7aad 100644
--- a/third_party/libosmium/include/osmium/io/debug_output.hpp
+++ b/third_party/libosmium/include/osmium/io/debug_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
index 30909418a..dc6d87fa5 100644
--- a/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/debug_output_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -44,6 +44,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/box.hpp>
 #include <osmium/osm/changeset.hpp>
 #include <osmium/osm/crc.hpp>
+#include <osmium/osm/crc_zlib.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/metadata_options.hpp>
@@ -59,9 +60,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/util/minmax.hpp>
 #include <osmium/visitor.hpp>
 
-#include <boost/crc.hpp>
-
-#include <cinttypes>
+#include <array>
 #include <cmath>
 #include <cstring>
 #include <iterator>
@@ -112,6 +111,8 @@ namespace osmium {
              */
             class DebugOutputBlock : public OutputBlock {
 
+                using crc_type = osmium::CRC_zlib;
+
                 debug_output_options m_options;
 
                 const char* m_utf8_prefix = "";
@@ -124,8 +125,8 @@ namespace osmium {
                 }
 
                 template <typename... TArgs>
-                void output_formatted(const char* format, TArgs&&... args) {
-                    append_printf_formatted_string(*m_out, format, std::forward<TArgs>(args)...);
+                void output_formatted(const char* format, TArgs... args) {
+                    append_printf_formatted_string(*m_out, format, args...);
                 }
 
                 void write_color(const char* color) {
@@ -197,7 +198,12 @@ namespace osmium {
 
                 void write_counter(int width, int n) {
                     write_color(color_white);
+#pragma GCC diagnostic push
+#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ > 7)
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
                     output_formatted("    %0*d: ", width, n++);
+#pragma GCC diagnostic pop
                     write_color(color_reset);
                 }
 
@@ -255,7 +261,7 @@ namespace osmium {
                     }
                 }
 
-                void write_tags(const osmium::TagList& tags, const char* padding="") {
+                void write_tags(const osmium::TagList& tags, const char* padding = "") {
                     if (tags.empty()) {
                         return;
                     }
@@ -315,14 +321,14 @@ namespace osmium {
                 template <typename T>
                 void write_crc32(const T& object) {
                     write_fieldname("crc32");
-                    osmium::CRC<boost::crc_32_type> crc32;
+                    osmium::CRC<crc_type> crc32;
                     crc32.update(object);
                     output_formatted("    %x\n", crc32().checksum());
                 }
 
                 void write_crc32(const osmium::Changeset& object) {
                     write_fieldname("crc32");
-                    osmium::CRC<boost::crc_32_type> crc32;
+                    osmium::CRC<crc_type> crc32;
                     crc32.update(object);
                     output_formatted("      %x\n", crc32().checksum());
                 }
@@ -391,7 +397,7 @@ namespace osmium {
                     for (const auto& node_ref : way.nodes()) {
                         write_diff();
                         write_counter(width, n++);
-                        output_formatted("%10" PRId64, node_ref.ref());
+                        output_formatted("%10lld", static_cast<long long>(node_ref.ref())); // NOLINT(google-runtime-int)
                         if (node_ref.location().valid()) {
                             *m_out += " (";
                             node_ref.location().as_string(std::back_inserter(*m_out));
@@ -408,7 +414,7 @@ namespace osmium {
                 }
 
                 void relation(const osmium::Relation& relation) {
-                    static const char* short_typename[] = { "node", "way ", "rel " };
+                    static const std::array<const char*, 3> short_typename = {{ "node", "way ", "rel " }};
 
                     m_diff_char = m_options.format_as_diff ? relation.diff_as_char() : '\0';
 
@@ -427,7 +433,7 @@ namespace osmium {
                         write_diff();
                         write_counter(width, n++);
                         *m_out += short_typename[item_type_to_nwr_index(member.type())];
-                        output_formatted(" %10" PRId64 " ", member.ref());
+                        output_formatted(" %10lld ", static_cast<long long>(member.ref())); // NOLINT(google-runtime-int)
                         write_string(member.role());
                         *m_out += '\n';
                     }
@@ -513,7 +519,7 @@ namespace osmium {
 
                 debug_output_options m_options;
 
-                void write_fieldname(std::string& out, const char* name) {
+                void write_fieldname(std::string& out, const char* name) const {
                     out += "  ";
                     if (m_options.use_color) {
                         out += color_cyan;
diff --git a/third_party/libosmium/include/osmium/io/detail/ids_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/ids_output_format.hpp
new file mode 100644
index 000000000..d3ce472d2
--- /dev/null
+++ b/third_party/libosmium/include/osmium/io/detail/ids_output_format.hpp
@@ -0,0 +1,164 @@
+#ifndef OSMIUM_IO_DETAIL_IDS_OUTPUT_FORMAT_HPP
+#define OSMIUM_IO_DETAIL_IDS_OUTPUT_FORMAT_HPP
+
+/*
+
+This file is part of Osmium (https://osmcode.org/libosmium).
+
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+*/
+
+#include <osmium/io/detail/output_format.hpp>
+#include <osmium/io/detail/queue_util.hpp>
+#include <osmium/io/detail/string_util.hpp>
+#include <osmium/io/file.hpp>
+#include <osmium/io/file_format.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/memory/collection.hpp>
+#include <osmium/memory/item_iterator.hpp>
+#include <osmium/osm/box.hpp>
+#include <osmium/osm/changeset.hpp>
+#include <osmium/osm/item_type.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/metadata_options.hpp>
+#include <osmium/osm/node.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/object.hpp>
+#include <osmium/osm/relation.hpp>
+#include <osmium/osm/tag.hpp>
+#include <osmium/osm/timestamp.hpp>
+#include <osmium/osm/way.hpp>
+#include <osmium/thread/pool.hpp>
+#include <osmium/visitor.hpp>
+
+#include <cstdint>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <utility>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            struct ids_output_options {
+
+                bool with_type = true;
+
+            }; // struct ids_output_options
+
+            /**
+             * Writes out one buffer with OSM data in IDS format.
+             */
+            class IDSOutputBlock : public OutputBlock {
+
+                ids_output_options m_options;
+
+                void write_id(char c, int64_t value) {
+                    if (m_options.with_type) {
+                        *m_out += c;
+                    }
+                    output_int(value);
+                    *m_out += '\n';
+                }
+
+            public:
+
+                IDSOutputBlock(osmium::memory::Buffer&& buffer, const ids_output_options& options) :
+                    OutputBlock(std::move(buffer)),
+                    m_options(options) {
+                }
+
+                std::string operator()() {
+                    osmium::apply(m_input_buffer->cbegin(), m_input_buffer->cend(), *this);
+
+                    std::string out;
+                    using std::swap;
+                    swap(out, *m_out);
+
+                    return out;
+                }
+
+                void node(const osmium::Node& node) {
+                    write_id('n', node.id());
+                }
+
+                void way(const osmium::Way& way) {
+                    write_id('w', way.id());
+                }
+
+                void relation(const osmium::Relation& relation) {
+                    write_id('r', relation.id());
+                }
+
+                void changeset(const osmium::Changeset& changeset) {
+                    write_id('c', changeset.id());
+                }
+
+            }; // class IDSOutputBlock
+
+            class IDSOutputFormat : public osmium::io::detail::OutputFormat {
+
+                ids_output_options m_options;
+
+            public:
+
+                IDSOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
+                    OutputFormat(pool, output_queue) {
+                    if (file.is_false("ids_with_type")) {
+                        m_options.with_type = false;
+                    }
+                }
+
+                void write_buffer(osmium::memory::Buffer&& buffer) final {
+                    m_output_queue.push(m_pool.submit(IDSOutputBlock{std::move(buffer), m_options}));
+                }
+
+            }; // class IDSOutputFormat
+
+            // we want the register_output_format() function to run, setting
+            // the variable is only a side-effect, it will never be used
+            const bool registered_ids_output = osmium::io::detail::OutputFormatFactory::instance().register_output_format(osmium::io::file_format::ids,
+                [](osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) {
+                    return new osmium::io::detail::IDSOutputFormat(pool, file, output_queue);
+            });
+
+            // dummy function to silence the unused variable warning from above
+            inline bool get_registered_ids_output() noexcept {
+                return registered_ids_output;
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_DETAIL_IDS_OUTPUT_FORMAT_HPP
diff --git a/third_party/libosmium/include/osmium/io/detail/input_format.hpp b/third_party/libosmium/include/osmium/io/detail/input_format.hpp
index d8f0fef2e..230c464bc 100644
--- a/third_party/libosmium/include/osmium/io/detail/input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/input_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -58,11 +58,15 @@ namespace osmium {
 
             struct parser_arguments {
                 osmium::thread::Pool& pool;
+                int fd;
                 future_string_queue_type& input_queue;
                 future_buffer_queue_type& output_queue;
                 std::promise<osmium::io::Header>& header_promise;
+                std::atomic<std::size_t>* offset_ptr;
                 osmium::osm_entity_bits::type read_which_entities;
                 osmium::io::read_meta read_metadata;
+                osmium::io::buffers_type buffers_kind;
+                bool want_buffered_pages_removed;
             };
 
             class Parser {
@@ -162,6 +166,72 @@ namespace osmium {
 
             }; // class Parser
 
+            class ParserWithBuffer : public Parser {
+
+                enum {
+                    initial_buffer_size = 1024UL * 1024UL
+                };
+
+                osmium::memory::Buffer m_buffer{initial_buffer_size,
+                                                osmium::memory::Buffer::auto_grow::internal};
+
+                osmium::io::buffers_type m_buffers_kind;
+                osmium::item_type m_last_type = osmium::item_type::undefined;
+
+                bool is_different_type(osmium::item_type current_type) noexcept {
+                    if (m_last_type == current_type) {
+                        return false;
+                    }
+
+                    if (m_last_type == osmium::item_type::undefined) {
+                        m_last_type = current_type;
+                        return false;
+                    }
+
+                    m_last_type = current_type;
+                    return true;
+                }
+
+            protected:
+
+                explicit ParserWithBuffer(parser_arguments& args) :
+                    Parser(args),
+                    m_buffers_kind(args.buffers_kind) {
+                }
+
+                osmium::memory::Buffer& buffer() noexcept {
+                    return m_buffer;
+                }
+
+                void flush_nested_buffer() {
+                    if (m_buffer.has_nested_buffers()) {
+                        std::unique_ptr<osmium::memory::Buffer> buffer_ptr{m_buffer.get_last_nested()};
+                        send_to_output_queue(std::move(*buffer_ptr));
+                    }
+                }
+
+                void flush_final_buffer() {
+                    if (m_buffer.committed() > 0) {
+                        send_to_output_queue(std::move(m_buffer));
+                    }
+                }
+
+                void maybe_new_buffer(osmium::item_type current_type) {
+                    if (m_buffers_kind == buffers_type::any) {
+                        return;
+                    }
+
+                    if (is_different_type(current_type) && m_buffer.committed() > 0) {
+                        osmium::memory::Buffer new_buffer{initial_buffer_size,
+                                                          osmium::memory::Buffer::auto_grow::internal};
+                        using std::swap;
+                        swap(new_buffer, m_buffer);
+                        send_to_output_queue(std::move(new_buffer));
+                    }
+                }
+
+            }; // class ParserWithBuffer
+
             /**
              * This factory class is used to create objects that decode OSM
              * data written in a specified format.
@@ -197,21 +267,21 @@ namespace osmium {
                 }
 
                 bool register_parser(const osmium::io::file_format format, create_parser_type&& create_function) {
-                    callbacks(format) = std::forward<create_parser_type>(create_function);
+                    callbacks(format) = std::move(create_function);
                     return true;
                 }
 
                 create_parser_type get_creator_function(const osmium::io::File& file) const {
-                    const auto func = callbacks(file.format());
+                    auto func = callbacks(file.format());
                     if (func) {
                         return func;
                     }
                     throw unsupported_file_format_error{
-                            std::string{"Can not open file '"} +
-                            file.filename() +
-                            "' with type '" +
-                            as_string(file.format()) +
-                            "'. No support for reading this format in this program."};
+                        std::string{"Can not open file '"} +
+                        file.filename() +
+                        "' with type '" +
+                        as_string(file.format()) +
+                        "'. No support for reading this format in this program."};
                 }
 
             }; // class ParserFactory
diff --git a/third_party/libosmium/include/osmium/io/detail/lz4.hpp b/third_party/libosmium/include/osmium/io/detail/lz4.hpp
new file mode 100644
index 000000000..583d439bb
--- /dev/null
+++ b/third_party/libosmium/include/osmium/io/detail/lz4.hpp
@@ -0,0 +1,142 @@
+#ifndef OSMIUM_IO_DETAIL_LZ4_HPP
+#define OSMIUM_IO_DETAIL_LZ4_HPP
+
+/*
+
+This file is part of Osmium (https://osmcode.org/libosmium).
+
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+*/
+
+#ifdef OSMIUM_WITH_LZ4
+
+#include <cassert>
+#include <limits>
+#include <stdexcept>
+#include <string>
+
+#include <osmium/io/error.hpp>
+
+#include <protozero/version.hpp>
+
+#if PROTOZERO_VERSION_CODE >= 10600
+# include <protozero/data_view.hpp>
+#else
+# include <protozero/types.hpp>
+#endif
+
+#include <lz4.h>
+
+namespace osmium {
+
+    namespace io {
+
+        namespace detail {
+
+            constexpr inline int lz4_default_compression_level() noexcept {
+                return 1; // LZ4_ACCELERATION_DEFAULT
+            }
+
+            inline void lz4_check_compression_level(int value) {
+                if (value <= 0 || value > 65537 /* LZ4_ACCELERATION_MAX */) {
+                    throw std::invalid_argument{"The 'pbf_compression_level' for lz4 compression must be between 1 and 65537."};
+                }
+            }
+
+            /**
+             * Compress data using lz4.
+             *
+             * Note that this function can not compress data larger than
+             * LZ4_MAX_INPUT_SIZE.
+             *
+             * @param input Data to compress.
+             * @param compression_level Compression level.
+             * @returns Compressed data.
+             */
+            inline std::string lz4_compress(const std::string& input, int compression_level = lz4_default_compression_level()) { // NOLINT(google-runtime-int)
+                assert(input.size() < LZ4_MAX_INPUT_SIZE);
+                const int output_size = ::LZ4_compressBound(static_cast<int>(input.size())); // NOLINT(google-runtime-int)
+
+                std::string output(static_cast<std::size_t>(output_size), '\0');
+
+                const int result = ::LZ4_compress_fast( // NOLINT(google-runtime-int)
+                    input.data(),
+                    &*output.begin(),
+                    static_cast<int>(input.size()),
+                    output_size,
+                    compression_level);
+
+                if (result == 0) {
+                    throw io_error{"LZ4 compression failed"};
+                }
+
+                output.resize(result);
+
+                return output;
+            }
+
+            /**
+             * Uncompress data using lz4.
+             *
+             * Note that this function can not uncompress data larger than
+             * LZ4_MAX_INPUT_SIZE.
+             *
+             * @param input Compressed input data.
+             * @param raw_size Size of uncompressed data.
+             * @param output Uncompressed result data.
+             * @returns Pointer and size to incompressed data.
+             */
+            inline protozero::data_view lz4_uncompress_string(const char* input, unsigned long input_size, unsigned long raw_size, std::string& output) { // NOLINT(google-runtime-int)
+                output.resize(raw_size);
+
+                const int result = ::LZ4_decompress_safe( // NOLINT(google-runtime-int)
+                    input,
+                    &*output.begin(),
+                    static_cast<int>(input_size),
+                    static_cast<int>(raw_size));
+
+                if (result < 0) {
+                    throw io_error{"LZ4 decompression failed: invalid block"};
+                }
+
+                if (result != static_cast<int>(raw_size)) {
+                    throw io_error{"LZ4 decompression failed: data size does not match"};
+                }
+
+                return protozero::data_view{output.data(), output.size()};
+            }
+
+        } // namespace detail
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif
+
+#endif // OSMIUM_IO_DETAIL_LZ4_HPP
diff --git a/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
index 41976dbec..3bbd1615b 100644
--- a/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/o5m_input_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -57,6 +57,8 @@ DEALINGS IN THE SOFTWARE.
 #include <protozero/varint.hpp>
 
 #include <algorithm>
+#include <array>
+#include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
@@ -96,15 +98,19 @@ namespace osmium {
 
                 // The following settings are from the o5m description:
 
-                // The maximum number of entries in this table.
-                const uint64_t number_of_entries = 15000;
+                enum : uint64_t {
+                    // The maximum number of entries in this table.
+                    number_of_entries = 15000UL,
 
-                // The size of one entry in the table.
-                const unsigned int entry_size = 256;
+                    // The size of one entry in the table.
+                    entry_size = 256UL
+                };
 
                 // The maximum length of a string in the table including
                 // two \0 bytes.
-                const unsigned int max_length = 250 + 2;
+                enum {
+                    max_length = 250U + 2U
+                };
 
                 // The data is stored in this string. It is default constructed
                 // and then resized on demand the first time something is added.
@@ -122,6 +128,8 @@ namespace osmium {
                 }
 
                 void add(const char* string, std::size_t size) {
+                    assert(string);
+
                     if (m_table.empty()) {
                         m_table.resize(entry_size * number_of_entries);
                     }
@@ -143,14 +151,10 @@ namespace osmium {
 
             }; // class ReferenceTable
 
-            class O5mParser : public Parser {
-
-                static constexpr std::size_t buffer_size = 2 * 1000 * 1000;
+            class O5mParser final : public ParserWithBuffer {
 
                 osmium::io::Header m_header{};
 
-                osmium::memory::Buffer m_buffer;
-
                 std::string m_input{};
 
                 const char* m_data;
@@ -163,7 +167,7 @@ namespace osmium {
                 }
 
                 bool ensure_bytes_available(std::size_t need_bytes) {
-                    if ((m_end - m_data) >= static_cast<int64_t>(need_bytes)) {
+                    if (static_cast<std::size_t>(m_end - m_data) >= need_bytes) {
                         return true;
                     }
 
@@ -188,7 +192,7 @@ namespace osmium {
                 }
 
                 void check_header_magic() {
-                    static const unsigned char header_magic[] = { 0xff, 0xe0, 0x04, 'o', '5' };
+                    static const unsigned char header_magic[] = {0xff, 0xe0, 0x04, 'o', '5'};
 
                     if (std::strncmp(reinterpret_cast<const char*>(header_magic), m_data, sizeof(header_magic)) != 0) {
                         throw o5m_error{"wrong header magic"};
@@ -218,7 +222,7 @@ namespace osmium {
                 }
 
                 void decode_header() {
-                    if (! ensure_bytes_available(7)) { // overall length of header
+                    if (!ensure_bytes_available(7)) { // overall length of header
                         throw o5m_error{"file too short (incomplete header info)"};
                     }
 
@@ -239,7 +243,7 @@ namespace osmium {
                 osmium::DeltaDecode<int64_t> m_delta_lat;
 
                 osmium::DeltaDecode<osmium::object_id_type> m_delta_way_node_id;
-                osmium::DeltaDecode<osmium::object_id_type> m_delta_member_ids[3];
+                std::array<osmium::DeltaDecode<osmium::object_id_type>, 3> m_delta_member_ids;
 
                 void reset() {
                     m_reference_table.clear();
@@ -257,8 +261,10 @@ namespace osmium {
                 }
 
                 const char* decode_string(const char** dataptr, const char* const end) {
+                    assert(*dataptr != end);
+
                     if (**dataptr == 0x00) { // get inline string
-                        (*dataptr)++;
+                        ++(*dataptr);
                         if (*dataptr == end) {
                             throw o5m_error{"string format error"};
                         }
@@ -270,6 +276,8 @@ namespace osmium {
                 }
 
                 std::pair<osmium::user_id_type, const char*> decode_user(const char** dataptr, const char* const end) {
+                    assert(*dataptr != end);
+
                     const bool update_pointer = (**dataptr == 0x00);
                     const char* data = decode_string(dataptr, end);
                     const char* start = data;
@@ -291,11 +299,11 @@ namespace osmium {
                         return {0, ""};
                     }
 
-                    while (*data++) {
+                    do {
                         if (data == end) {
                             throw o5m_error{"no null byte in user name"};
                         }
-                    }
+                    } while (*data++);
 
                     if (update_pointer) {
                         m_reference_table.add(start, data - start);
@@ -342,6 +350,10 @@ namespace osmium {
                 const char* decode_info(osmium::OSMObject& object, const char** dataptr, const char* const end) {
                     const char* user = "";
 
+                    if (*dataptr == end) {
+                        throw o5m_error{"premature end of file while parsing object metadata"};
+                    }
+
                     if (**dataptr == 0x00) { // no info section
                         ++*dataptr;
                     } else { // has info section
@@ -356,11 +368,11 @@ namespace osmium {
                             object.set_timestamp(timestamp);
                             object.set_changeset(m_delta_changeset.update(zvarint(dataptr, end)));
                             if (*dataptr != end) {
-                                auto uid_user = decode_user(dataptr, end);
+                                const auto uid_user = decode_user(dataptr, end);
                                 object.set_uid(uid_user.first);
                                 user = uid_user.second;
                             } else {
-                                object.set_uid(user_id_type(0));
+                                object.set_uid(user_id_type{0});
                             }
                         }
                     }
@@ -369,7 +381,7 @@ namespace osmium {
                 }
 
                 void decode_node(const char* data, const char* const end) {
-                    osmium::builder::NodeBuilder builder{m_buffer};
+                    osmium::builder::NodeBuilder builder{buffer()};
 
                     builder.set_id(m_delta_id.update(zvarint(&data, end)));
 
@@ -391,7 +403,7 @@ namespace osmium {
                 }
 
                 void decode_way(const char* data, const char* const end) {
-                    osmium::builder::WayBuilder builder{m_buffer};
+                    osmium::builder::WayBuilder builder{buffer()};
 
                     builder.set_id(m_delta_id.update(zvarint(&data, end)));
 
@@ -421,7 +433,7 @@ namespace osmium {
                     }
                 }
 
-                osmium::item_type decode_member_type(char c) {
+                static osmium::item_type decode_member_type(char c) {
                     if (c < '0' || c > '2') {
                         throw o5m_error{"unknown member type"};
                     }
@@ -429,11 +441,13 @@ namespace osmium {
                 }
 
                 std::pair<osmium::item_type, const char*> decode_role(const char** dataptr, const char* const end) {
+                    assert(*dataptr != end);
+
                     const bool update_pointer = (**dataptr == 0x00);
                     const char* data = decode_string(dataptr, end);
                     const char* start = data;
 
-                    auto member_type = decode_member_type(*data++);
+                    const auto member_type = decode_member_type(*data++);
                     if (data == end) {
                         throw o5m_error{"missing role"};
                     }
@@ -454,7 +468,7 @@ namespace osmium {
                 }
 
                 void decode_relation(const char* data, const char* const end) {
-                    osmium::builder::RelationBuilder builder{m_buffer};
+                    osmium::builder::RelationBuilder builder{buffer()};
 
                     builder.set_id(m_delta_id.update(zvarint(&data, end)));
 
@@ -474,13 +488,13 @@ namespace osmium {
                             osmium::builder::RelationMemberListBuilder rml_builder{builder};
 
                             while (data < end_refs) {
-                                auto delta_id = zvarint(&data, end);
+                                const auto delta_id = zvarint(&data, end);
                                 if (data == end) {
                                     throw o5m_error{"relation member format error"};
                                 }
-                                auto type_role = decode_role(&data, end);
-                                auto i = osmium::item_type_to_nwr_index(type_role.first);
-                                auto ref = m_delta_member_ids[i].update(delta_id);
+                                const auto type_role = decode_role(&data, end);
+                                const auto i = osmium::item_type_to_nwr_index(type_role.first);
+                                const auto ref = m_delta_member_ids[i].update(delta_id);
                                 rml_builder.add_member(type_role.first, ref, type_role.second);
                             }
                         }
@@ -502,18 +516,11 @@ namespace osmium {
                 }
 
                 void decode_timestamp(const char* data, const char* const end) {
-                    const auto timestamp = osmium::Timestamp(zvarint(&data, end)).to_iso();
+                    const auto timestamp = osmium::Timestamp{zvarint(&data, end)}.to_iso();
                     m_header.set("o5m_timestamp", timestamp);
                     m_header.set("timestamp", timestamp);
                 }
 
-                void flush() {
-                    osmium::memory::Buffer buffer{buffer_size};
-                    using std::swap;
-                    swap(m_buffer, buffer);
-                    send_to_output_queue(std::move(buffer));
-                }
-
                 enum class dataset_type : unsigned char {
                     node         = 0x10,
                     way          = 0x11,
@@ -543,7 +550,7 @@ namespace osmium {
                                 throw o5m_error{"premature end of file"};
                             }
 
-                            if (! ensure_bytes_available(length)) {
+                            if (!ensure_bytes_available(length)) {
                                 throw o5m_error{"premature end of file"};
                             }
 
@@ -551,22 +558,25 @@ namespace osmium {
                                 case dataset_type::node:
                                     mark_header_as_done();
                                     if (read_types() & osmium::osm_entity_bits::node) {
+                                        maybe_new_buffer(osmium::item_type::node);
                                         decode_node(m_data, m_data + length);
-                                        m_buffer.commit();
+                                        buffer().commit();
                                     }
                                     break;
                                 case dataset_type::way:
                                     mark_header_as_done();
                                     if (read_types() & osmium::osm_entity_bits::way) {
+                                        maybe_new_buffer(osmium::item_type::way);
                                         decode_way(m_data, m_data + length);
-                                        m_buffer.commit();
+                                        buffer().commit();
                                     }
                                     break;
                                 case dataset_type::relation:
                                     mark_header_as_done();
                                     if (read_types() & osmium::osm_entity_bits::relation) {
+                                        maybe_new_buffer(osmium::item_type::relation);
                                         decode_relation(m_data, m_data + length);
-                                        m_buffer.commit();
+                                        buffer().commit();
                                     }
                                     break;
                                 case dataset_type::bounding_box:
@@ -586,24 +596,18 @@ namespace osmium {
 
                             m_data += length;
 
-                            if (m_buffer.committed() > buffer_size / 10 * 9) {
-                                flush();
-                            }
+                            flush_nested_buffer();
                         }
                     }
 
-                    if (m_buffer.committed()) {
-                        flush();
-                    }
-
                     mark_header_as_done();
+                    flush_final_buffer();
                 }
 
             public:
 
                 explicit O5mParser(parser_arguments& args) :
-                    Parser(args),
-                    m_buffer(buffer_size),
+                    ParserWithBuffer(args),
                     m_data(m_input.data()),
                     m_end(m_data) {
                 }
@@ -614,9 +618,9 @@ namespace osmium {
                 O5mParser(O5mParser&&) = delete;
                 O5mParser& operator=(O5mParser&&) = delete;
 
-                ~O5mParser() noexcept final = default;
+                ~O5mParser() noexcept override = default;
 
-                void run() final {
+                void run() override {
                     osmium::thread::set_thread_name("_osmium_o5m_in");
 
                     decode_header();
@@ -631,7 +635,7 @@ namespace osmium {
                 file_format::o5m,
                 [](parser_arguments& args) {
                     return std::unique_ptr<Parser>(new O5mParser{args});
-            });
+                });
 
             // dummy function to silence the unused variable warning from above
             inline bool get_registered_o5m_parser() noexcept {
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
index ba5fb8b57..649c62776 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_input_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -98,25 +98,14 @@ namespace osmium {
                 }
             }
 
-            class OPLParser : public Parser {
+            class OPLParser final : public ParserWithBuffer {
 
-                osmium::memory::Buffer m_buffer{1024*1024};
                 uint64_t m_line_count = 0;
 
-                void maybe_flush() {
-                    if (m_buffer.committed() > 800*1024) {
-                        osmium::memory::Buffer buffer{1024*1024};
-                        using std::swap;
-                        swap(m_buffer, buffer);
-                        send_to_output_queue(std::move(buffer));
-
-                    }
-                }
-
             public:
 
                 explicit OPLParser(parser_arguments& args) :
-                    Parser(args) {
+                    ParserWithBuffer(args) {
                     set_header_value(osmium::io::Header{});
                 }
 
@@ -126,23 +115,36 @@ namespace osmium {
                 OPLParser(OPLParser&&) = delete;
                 OPLParser& operator=(OPLParser&&) = delete;
 
-                ~OPLParser() noexcept final = default;
+                ~OPLParser() noexcept override = default;
 
                 void parse_line(const char* data) {
-                    if (opl_parse_line(m_line_count, data, m_buffer, read_types())) {
-                        maybe_flush();
+                    switch (*data) {
+                        case 'n':
+                            maybe_new_buffer(osmium::item_type::node);
+                            break;
+                        case 'w':
+                            maybe_new_buffer(osmium::item_type::way);
+                            break;
+                        case 'r':
+                            maybe_new_buffer(osmium::item_type::relation);
+                            break;
+                        case 'c':
+                            maybe_new_buffer(osmium::item_type::way);
+                            break;
+                    }
+
+                    if (opl_parse_line(m_line_count, data, buffer(), read_types())) {
+                        flush_nested_buffer();
                     }
                     ++m_line_count;
                 }
 
-                void run() final {
+                void run() override {
                     osmium::thread::set_thread_name("_osmium_opl_in");
 
                     line_by_line(*this);
 
-                    if (m_buffer.committed() > 0) {
-                        send_to_output_queue(std::move(m_buffer));
-                    }
+                    flush_final_buffer();
                 }
 
             }; // class OPLParser
@@ -153,7 +155,7 @@ namespace osmium {
                 file_format::opl,
                 [](parser_arguments& args) {
                     return std::unique_ptr<Parser>(new OPLParser{args});
-            });
+                });
 
             // dummy function to silence the unused variable warning from above
             inline bool get_registered_opl_parser() noexcept {
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
index f61fba714..4a1d64247 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_output_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -214,7 +214,7 @@ namespace osmium {
                     *m_out += " N";
 
                     if (!way.nodes().empty()) {
-                        auto it = way.nodes().begin();
+                        const auto* it = way.nodes().cbegin();
                         if (m_options.locations_on_ways) {
                             write_field_ref(*it);
                             for (++it; it != way.nodes().end(); ++it) {
diff --git a/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp b/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
index 935455e66..eedec3169 100644
--- a/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/opl_parser_functions.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,6 +34,7 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #include <osmium/builder/osm_object_builder.hpp>
+#include <osmium/io/detail/string_util.hpp>
 #include <osmium/io/error.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/box.hpp>
@@ -47,8 +48,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 
-#include <utf8.h>
-
 #include <cstdint>
 #include <cstdlib>
 #include <iterator>
@@ -123,7 +122,7 @@ namespace osmium {
              * Check whether s points to something else than the end of the
              * string or a space or tab.
              */
-            inline bool opl_non_empty(const char *s) {
+            inline bool opl_non_empty(const char* s) {
                 return *s != '\0' && *s != ' ' && *s != '\t';
             }
 
@@ -145,6 +144,8 @@ namespace osmium {
              * Returns a pointer to next character that needs to be consumed.
              */
             inline void opl_parse_escaped(const char** data, std::string& result) {
+                assert(data);
+                assert(*data);
                 const char* s = *data;
                 uint32_t value = 0;
                 const int max_length = sizeof(value) * 2 /* hex chars per byte */;
@@ -155,11 +156,15 @@ namespace osmium {
                     }
                     if (*s == '%') {
                         ++s;
-                        utf8::utf32to8(&value, &value + 1, std::back_inserter(result));
+                        if (value == 0) {
+                            result += '%';
+                        } else {
+                            append_codepoint_as_utf8(value, std::back_inserter(result));
+                        }
                         *data = s;
                         return;
                     }
-                    value <<= 4;
+                    value <<= 4U;
                     if (*s >= '0' && *s <= '9') {
                         value += *s - '0';
                     } else if (*s >= 'a' && *s <= 'f') {
@@ -183,6 +188,8 @@ namespace osmium {
              * Returns a pointer to next character that needs to be consumed.
              */
             inline void opl_parse_string(const char** data, std::string& result) {
+                assert(data);
+                assert(*data);
                 const char* s = *data;
                 while (true) {
                     if (*s == '\0' || *s == ' ' || *s == '\t' || *s == ',' || *s == '=') {
@@ -199,41 +206,38 @@ namespace osmium {
                 *data = s;
             }
 
-            // Arbitrary limit how long integers can get
-            constexpr const int max_int_len = 16;
-
             template <typename T>
             inline T opl_parse_int(const char** s) {
-                if (**s == '\0') {
-                    throw opl_error{"expected integer", *s};
-                }
                 const bool negative = (**s == '-');
                 if (negative) {
                     ++*s;
                 }
 
-                int64_t value = 0;
-
-                int n = max_int_len;
-                while (**s >= '0' && **s <= '9') {
-                    if (--n == 0) {
-                        throw opl_error{"integer too long", *s};
-                    }
-                    value *= 10;
-                    value += **s - '0';
-                    ++*s;
-                }
-
-                if (n == max_int_len) {
+                if (**s < '0' || **s > '9') {
                     throw opl_error{"expected integer", *s};
                 }
 
+                int64_t value = 0;
+                while (**s >= '0' && **s <= '9') {
+                    if (value <= -922337203685477580) {
+                        if ((value < -922337203685477580) || (**s > '8')) {
+                            throw opl_error("integer too long", *s);
+                        }
+                    }
+                    value *= 10;
+                    value -= **s - '0';
+                    ++*s;
+                }
+
                 if (negative) {
-                    value = -value;
                     if (value < std::numeric_limits<T>::min()) {
                         throw opl_error{"integer too long", *s};
                     }
                 } else {
+                    if (value == std::numeric_limits<int64_t>::min()) {
+                        throw opl_error{"integer too long", *s};
+                    }
+                    value = -value;
                     if (value > std::numeric_limits<T>::max()) {
                         throw opl_error{"integer too long", *s};
                     }
@@ -371,6 +375,16 @@ namespace osmium {
 
                 const char* tags_begin = nullptr;
 
+                bool has_version = false;
+                bool has_visible = false;
+                bool has_changeset_id = false;
+                bool has_timestamp = false;
+                bool has_uid = false;
+                bool has_user = false;
+                bool has_tags = false;
+                bool has_lon = false;
+                bool has_lat = false;
+
                 std::string user;
                 osmium::Location location;
                 while (**data) {
@@ -382,35 +396,71 @@ namespace osmium {
                     ++(*data);
                     switch (c) {
                         case 'v':
+                            if (has_version) {
+                                throw opl_error{"Duplicate attribute: version (v)"};
+                            }
+                            has_version = true;
                             builder.set_version(opl_parse_version(data));
                             break;
                         case 'd':
+                            if (has_visible) {
+                                throw opl_error{"Duplicate attribute: visible (d)"};
+                            }
+                            has_visible = true;
                             builder.set_visible(opl_parse_visible(data));
                             break;
                         case 'c':
+                            if (has_changeset_id) {
+                                throw opl_error{"Duplicate attribute: changeset_id (c)"};
+                            }
+                            has_changeset_id = true;
                             builder.set_changeset(opl_parse_changeset_id(data));
                             break;
                         case 't':
+                            if (has_timestamp) {
+                                throw opl_error{"Duplicate attribute: timestamp (t)"};
+                            }
+                            has_timestamp = true;
                             builder.set_timestamp(opl_parse_timestamp(data));
                             break;
                         case 'i':
+                            if (has_uid) {
+                                throw opl_error{"Duplicate attribute: uid (i)"};
+                            }
+                            has_uid = true;
                             builder.set_uid(opl_parse_uid(data));
                             break;
                         case 'u':
+                            if (has_user) {
+                                throw opl_error{"Duplicate attribute: user (u)"};
+                            }
+                            has_user = true;
                             opl_parse_string(data, user);
                             break;
                         case 'T':
+                            if (has_tags) {
+                                throw opl_error{"Duplicate attribute: tags (T)"};
+                            }
+                            has_tags = true;
                             if (opl_non_empty(*data)) {
                                 tags_begin = *data;
                                 opl_skip_section(data);
                             }
                             break;
                         case 'x':
+                            if (has_lon) {
+                                throw opl_error{"Duplicate attribute: lon (x)"};
+                            }
+                            has_lon = true;
                             if (opl_non_empty(*data)) {
                                 location.set_lon_partial(data);
                             }
                             break;
                         case 'y':
+                            if (has_lat) {
+                                throw opl_error{"Duplicate attribute: lat (y)"};
+                            }
+                            has_lat = true;
                             if (opl_non_empty(*data)) {
                                 location.set_lat_partial(data);
                             }
@@ -442,6 +492,15 @@ namespace osmium {
                 const char* nodes_begin = nullptr;
                 const char* nodes_end = nullptr;
 
+                bool has_version = false;
+                bool has_visible = false;
+                bool has_changeset_id = false;
+                bool has_timestamp = false;
+                bool has_uid = false;
+                bool has_user = false;
+                bool has_tags = false;
+                bool has_nodes = false;
+
                 std::string user;
                 while (**data) {
                     opl_parse_space(data);
@@ -452,30 +511,62 @@ namespace osmium {
                     ++(*data);
                     switch (c) {
                         case 'v':
+                            if (has_version) {
+                                throw opl_error{"Duplicate attribute: version (v)"};
+                            }
+                            has_version = true;
                             builder.set_version(opl_parse_version(data));
                             break;
                         case 'd':
+                            if (has_visible) {
+                                throw opl_error{"Duplicate attribute: visible (d)"};
+                            }
+                            has_visible = true;
                             builder.set_visible(opl_parse_visible(data));
                             break;
                         case 'c':
+                            if (has_changeset_id) {
+                                throw opl_error{"Duplicate attribute: changeset_id (c)"};
+                            }
+                            has_changeset_id = true;
                             builder.set_changeset(opl_parse_changeset_id(data));
                             break;
                         case 't':
+                            if (has_timestamp) {
+                                throw opl_error{"Duplicate attribute: timestamp (t)"};
+                            }
+                            has_timestamp = true;
                             builder.set_timestamp(opl_parse_timestamp(data));
                             break;
                         case 'i':
+                            if (has_uid) {
+                                throw opl_error{"Duplicate attribute: uid (i)"};
+                            }
+                            has_uid = true;
                             builder.set_uid(opl_parse_uid(data));
                             break;
                         case 'u':
+                            if (has_user) {
+                                throw opl_error{"Duplicate attribute: user (u)"};
+                            }
+                            has_user = true;
                             opl_parse_string(data, user);
                             break;
                         case 'T':
+                            if (has_tags) {
+                                throw opl_error{"Duplicate attribute: tags (T)"};
+                            }
+                            has_tags = true;
                             if (opl_non_empty(*data)) {
                                 tags_begin = *data;
                                 opl_skip_section(data);
                             }
                             break;
                         case 'N':
+                            if (has_nodes) {
+                                throw opl_error{"Duplicate attribute: nodes (N)"};
+                            }
+                            has_nodes = true;
                             nodes_begin = *data;
                             nodes_end = opl_skip_section(data);
                             break;
@@ -539,6 +630,15 @@ namespace osmium {
                 const char* members_begin = nullptr;
                 const char* members_end = nullptr;
 
+                bool has_version = false;
+                bool has_visible = false;
+                bool has_changeset_id = false;
+                bool has_timestamp = false;
+                bool has_uid = false;
+                bool has_user = false;
+                bool has_tags = false;
+                bool has_members = false;
+
                 std::string user;
                 while (**data) {
                     opl_parse_space(data);
@@ -549,30 +649,62 @@ namespace osmium {
                     ++(*data);
                     switch (c) {
                         case 'v':
+                            if (has_version) {
+                                throw opl_error{"Duplicate attribute: version (v)"};
+                            }
+                            has_version = true;
                             builder.set_version(opl_parse_version(data));
                             break;
                         case 'd':
+                            if (has_visible) {
+                                throw opl_error{"Duplicate attribute: visible (d)"};
+                            }
+                            has_visible = true;
                             builder.set_visible(opl_parse_visible(data));
                             break;
                         case 'c':
+                            if (has_changeset_id) {
+                                throw opl_error{"Duplicate attribute: changeset_id (c)"};
+                            }
+                            has_changeset_id = true;
                             builder.set_changeset(opl_parse_changeset_id(data));
                             break;
                         case 't':
+                            if (has_timestamp) {
+                                throw opl_error{"Duplicate attribute: timestamp (t)"};
+                            }
+                            has_timestamp = true;
                             builder.set_timestamp(opl_parse_timestamp(data));
                             break;
                         case 'i':
+                            if (has_uid) {
+                                throw opl_error{"Duplicate attribute: uid (i)"};
+                            }
+                            has_uid = true;
                             builder.set_uid(opl_parse_uid(data));
                             break;
                         case 'u':
+                            if (has_user) {
+                                throw opl_error{"Duplicate attribute: user (u)"};
+                            }
+                            has_user = true;
                             opl_parse_string(data, user);
                             break;
                         case 'T':
+                            if (has_tags) {
+                                throw opl_error{"Duplicate attribute: tags (T)"};
+                            }
+                            has_tags = true;
                             if (opl_non_empty(*data)) {
                                 tags_begin = *data;
                                 opl_skip_section(data);
                             }
                             break;
                         case 'M':
+                            if (has_members) {
+                                throw opl_error{"Duplicate attribute: members (M)"};
+                            }
+                            has_members = true;
                             members_begin = *data;
                             members_end = opl_skip_section(data);
                             break;
@@ -600,6 +732,18 @@ namespace osmium {
 
                 const char* tags_begin = nullptr;
 
+                bool has_num_changes = false;
+                bool has_created_at = false;
+                bool has_closed_at = false;
+                bool has_num_comments = false;
+                bool has_uid = false;
+                bool has_user = false;
+                bool has_tags = false;
+                bool has_min_x = false;
+                bool has_min_y = false;
+                bool has_max_x = false;
+                bool has_max_y = false;
+
                 osmium::Box box;
                 std::string user;
                 while (**data) {
@@ -611,44 +755,88 @@ namespace osmium {
                     ++(*data);
                     switch (c) {
                         case 'k':
+                            if (has_num_changes) {
+                                throw opl_error{"Duplicate attribute: num_changes (k)"};
+                            }
+                            has_num_changes = true;
                             builder.set_num_changes(opl_parse_int<osmium::num_changes_type>(data));
                             break;
                         case 's':
+                            if (has_created_at) {
+                                throw opl_error{"Duplicate attribute: created_at (s)"};
+                            }
+                            has_created_at = true;
                             builder.set_created_at(opl_parse_timestamp(data));
                             break;
                         case 'e':
+                            if (has_closed_at) {
+                                throw opl_error{"Duplicate attribute: closed_at (e)"};
+                            }
+                            has_closed_at = true;
                             builder.set_closed_at(opl_parse_timestamp(data));
                             break;
                         case 'd':
+                            if (has_num_comments) {
+                                throw opl_error{"Duplicate attribute: num_comments (d)"};
+                            }
+                            has_num_comments = true;
                             builder.set_num_comments(opl_parse_int<osmium::num_comments_type>(data));
                             break;
                         case 'i':
+                            if (has_uid) {
+                                throw opl_error{"Duplicate attribute: uid (i)"};
+                            }
+                            has_uid = true;
                             builder.set_uid(opl_parse_uid(data));
                             break;
                         case 'u':
+                            if (has_user) {
+                                throw opl_error{"Duplicate attribute: user (u)"};
+                            }
+                            has_user = true;
                             opl_parse_string(data, user);
                             break;
                         case 'x':
+                            if (has_min_x) {
+                                throw opl_error{"Duplicate attribute: min_x (x)"};
+                            }
+                            has_min_x = true;
                             if (opl_non_empty(*data)) {
                                 box.bottom_left().set_lon_partial(data);
                             }
                             break;
                         case 'y':
+                            if (has_min_y) {
+                                throw opl_error{"Duplicate attribute: min_y (y)"};
+                            }
+                            has_min_y = true;
                             if (opl_non_empty(*data)) {
                                 box.bottom_left().set_lat_partial(data);
                             }
                             break;
                         case 'X':
+                            if (has_max_x) {
+                                throw opl_error{"Duplicate attribute: max_x (X)"};
+                            }
+                            has_max_x = true;
                             if (opl_non_empty(*data)) {
                                 box.top_right().set_lon_partial(data);
                             }
                             break;
                         case 'Y':
+                            if (has_max_y) {
+                                throw opl_error{"Duplicate attribute: max_y (Y)"};
+                            }
+                            has_max_y = true;
                             if (opl_non_empty(*data)) {
                                 box.top_right().set_lat_partial(data);
                             }
                             break;
                         case 'T':
+                            if (has_tags) {
+                                throw opl_error{"Duplicate attribute: tags (T)"};
+                            }
+                            has_tags = true;
                             if (opl_non_empty(*data)) {
                                 tags_begin = *data;
                                 opl_skip_section(data);
diff --git a/third_party/libosmium/include/osmium/io/detail/output_format.hpp b/third_party/libosmium/include/osmium/io/detail/output_format.hpp
index 43c28755f..8cd5c75c9 100644
--- a/third_party/libosmium/include/osmium/io/detail/output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/output_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -81,9 +81,9 @@ namespace osmium {
                     }
 
                     char temp[20];
-                    char *t = temp;
+                    char* t = temp;
                     do {
-                        *t++ = char(value % 10) + '0';
+                        *t++ = static_cast<char>(value % 10) + '0'; // NOLINT(bugprone-narrowing-conversions, cppcoreguidelines-narrowing-conversions)
                         value /= 10;
                     } while (value > 0);
 
@@ -91,7 +91,7 @@ namespace osmium {
                     m_out->resize(old_size + (t - temp));
                     char* data = &(*m_out)[old_size];
                     do {
-                        *data++ += *--t;
+                        *data++ = *--t;
                     } while (t != temp);
                 }
 
@@ -179,7 +179,7 @@ namespace osmium {
                 }
 
                 bool register_output_format(const osmium::io::file_format format, create_output_type&& create_function) {
-                    callbacks(format) = std::forward<create_output_type>(create_function);
+                    callbacks(format) = std::move(create_function);
                     return true;
                 }
 
@@ -190,16 +190,16 @@ namespace osmium {
                     }
 
                     throw unsupported_file_format_error{
-                                std::string{"Can not open file '"} +
-                                file.filename() +
-                                "' with type '" +
-                                as_string(file.format()) +
-                                "'. No support for writing this format in this program."};
+                        std::string{"Can not open file '"} +
+                        file.filename() +
+                        "' with type '" +
+                        as_string(file.format()) +
+                        "'. No support for writing this format in this program."};
                 }
 
             }; // class OutputFormatFactory
 
-            class BlackholeOutputFormat : public osmium::io::detail::OutputFormat {
+            class BlackholeOutputFormat final : public osmium::io::detail::OutputFormat {
 
             public:
 
@@ -213,9 +213,9 @@ namespace osmium {
                 BlackholeOutputFormat(BlackholeOutputFormat&&) = delete;
                 BlackholeOutputFormat& operator=(BlackholeOutputFormat&&) = delete;
 
-                ~BlackholeOutputFormat() noexcept final = default;
+                ~BlackholeOutputFormat() noexcept override = default;
 
-                void write_buffer(osmium::memory::Buffer&& /*buffer*/) final {
+                void write_buffer(osmium::memory::Buffer&& /*buffer*/) override {
                 }
 
             }; // class BlackholeOutputFormat
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf.hpp b/third_party/libosmium/include/osmium/io/detail/pbf.hpp
index c2b2681da..b70888d4b 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,13 +36,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/error.hpp>
 #include <osmium/osm/location.hpp>
 
-// needed for htonl and ntohl or their equivalent in protozero
-#ifndef _WIN32
-# include <netinet/in.h>
-#else
-# include <protozero/byteswap.hpp>
-#endif
-
 #include <cstdint>
 #include <string>
 
@@ -72,14 +65,33 @@ namespace osmium {
             const int max_blob_header_size = 64 * 1024; // 64 kB
 
             // the maximum size of an uncompressed blob in bytes
-            const uint64_t max_uncompressed_blob_size = 32 * 1024 * 1024; // 32 MB
+            const uint64_t max_uncompressed_blob_size = 32UL * 1024UL * 1024UL; // 32 MB
 
             // resolution for longitude/latitude used for conversion
             // between representation as double and as int
-            const int64_t lonlat_resolution = 1000 * 1000 * 1000;
+            const int64_t lonlat_resolution = 1000L * 1000L * 1000L;
 
             const int64_t resolution_convert = lonlat_resolution / osmium::detail::coordinate_precision;
 
+            enum class pbf_compression : uint8_t {
+                none = 0,
+                zlib = 1,
+                lz4 = 2
+            };
+
+            inline pbf_compression get_compression_type(const std::string& val) {
+                if (val.empty() || val == "zlib" || val == "true") {
+                    return pbf_compression::zlib;
+                }
+                if (val == "none" || val == "false") {
+                    return pbf_compression::none;
+                }
+                if (val == "lz4") {
+                    return pbf_compression::lz4;
+                }
+                throw std::invalid_argument{"Unknown value for 'pbf_compression' option."};
+            }
+
         } // namespace detail
 
     } // namespace io
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
index b63893b63..41416c82d 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_decoder.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <cstdint>
+#include <cstring>
+#include <limits>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/detail/protobuf_tags.hpp>
@@ -52,19 +61,14 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/way.hpp>
 #include <osmium/util/delta.hpp>
 
+#ifdef OSMIUM_WITH_LZ4
+# include <osmium/io/detail/lz4.hpp>
+#endif
+
 #include <protozero/iterators.hpp>
 #include <protozero/pbf_message.hpp>
 #include <protozero/types.hpp>
 
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <utility>
-#include <vector>
-
 namespace osmium {
 
     namespace builder {
@@ -76,11 +80,67 @@ namespace osmium {
         namespace detail {
 
             using protozero::data_view;
+
+            class varint_range {
+
+                const char* m_data = nullptr;
+                const char* m_end = nullptr;
+
+                std::uint64_t next() {
+                    return protozero::decode_varint(&m_data, m_end);
+                }
+
+            public:
+
+                varint_range() = default;
+
+                explicit varint_range(const data_view& data) :
+                    m_data(data.data()),
+                    m_end(data.data() + data.size()) {
+                }
+
+                bool empty() const noexcept {
+                    return m_data == m_end;
+                }
+
+                std::size_t size() const noexcept {
+                    if (!m_data) {
+                        return 0;
+                    }
+
+                    // We know that each varint contains exactly one byte with the most
+                    // significant bit not set. We can use this to quickly figure out
+                    // how many varints there are without actually decoding the varints.
+                    return std::count_if(m_data, m_end, [](char c) noexcept {
+                        return (static_cast<unsigned char>(c) & 0x80U) == 0;
+                    });
+                }
+
+                std::int32_t next_int32() {
+                    return static_cast<int32_t>(next());
+                }
+
+                std::uint32_t next_uint32() {
+                    return static_cast<uint32_t>(next());
+                }
+
+                std::int32_t next_sint32() {
+                    return protozero::decode_zigzag32(static_cast<uint32_t>(next()));
+                }
+
+                std::int64_t next_sint64() {
+                    return protozero::decode_zigzag64(next());
+                }
+
+            }; // class varint_range
+
             using osm_string_len_type = std::pair<const char*, osmium::string_size_type>;
 
             class PBFPrimitiveBlockDecoder {
 
-                static constexpr const size_t initial_buffer_size = 2 * 1024 * 1024;
+                enum {
+                    initial_buffer_size = 64UL * 1024UL
+                };
 
                 data_view m_data;
                 std::vector<osm_string_len_type> m_stringtable;
@@ -92,7 +152,7 @@ namespace osmium {
 
                 osmium::osm_entity_bits::type m_read_types;
 
-                osmium::memory::Buffer m_buffer { initial_buffer_size };
+                osmium::memory::Buffer m_buffer{initial_buffer_size, osmium::memory::Buffer::auto_grow::internal};
 
                 osmium::io::read_meta m_read_metadata;
 
@@ -239,35 +299,33 @@ namespace osmium {
                     return user;
                 }
 
-                using kv_type = protozero::iterator_range<protozero::pbf_reader::const_uint32_iterator>;
-
-                void build_tag_list(osmium::builder::Builder& parent, const kv_type& keys, const kv_type& vals) {
-                    if (!keys.empty()) {
-                        osmium::builder::TagListBuilder builder{parent};
-                        auto kit = keys.begin();
-                        auto vit = vals.begin();
-                        while (kit != keys.end()) {
-                            if (vit == vals.end()) {
-                                // this is against the spec, must have same number of elements
-                                throw osmium::pbf_error{"PBF format error"};
-                            }
-                            const auto& k = m_stringtable.at(*kit++);
-                            const auto& v = m_stringtable.at(*vit++);
-                            builder.add_tag(k.first, k.second, v.first, v.second);
-                        }
+                void build_tag_list(osmium::builder::Builder& parent, varint_range& keys, varint_range& vals) {
+                    if (keys.empty() || vals.empty()) {
+                        return;
                     }
+
+                    osmium::builder::TagListBuilder builder{parent};
+                    do {
+                        const auto& k = m_stringtable.at(keys.next_uint32());
+                        const auto& v = m_stringtable.at(vals.next_uint32());
+                        builder.add_tag(k.first, k.second, v.first, v.second);
+                    } while (!keys.empty() && !vals.empty());
                 }
 
-                int32_t convert_pbf_coordinate(int64_t c) const noexcept {
+                int32_t convert_pbf_lon(const int64_t c) const noexcept {
                     return int32_t((c * m_granularity + m_lon_offset) / resolution_convert);
                 }
 
+                int32_t convert_pbf_lat(const int64_t c) const noexcept {
+                    return int32_t((c * m_granularity + m_lat_offset) / resolution_convert);
+                }
+
                 void decode_node(const data_view& data) {
                     osmium::builder::NodeBuilder builder{m_buffer};
                     osmium::Node& node = builder.object();
 
-                    kv_type keys;
-                    kv_type vals;
+                    varint_range keys;
+                    varint_range vals;
                     int64_t lon = std::numeric_limits<int64_t>::max();
                     int64_t lat = std::numeric_limits<int64_t>::max();
 
@@ -280,10 +338,10 @@ namespace osmium {
                                 node.set_id(pbf_node.get_sint64());
                                 break;
                             case protozero::tag_and_type(OSMFormat::Node::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
-                                keys = pbf_node.get_packed_uint32();
+                                keys = varint_range{pbf_node.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Node::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
-                                vals = pbf_node.get_packed_uint32();
+                                vals = varint_range{pbf_node.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Node::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
@@ -309,8 +367,8 @@ namespace osmium {
                             throw osmium::pbf_error{"illegal coordinate format"};
                         }
                         node.set_location(osmium::Location{
-                                convert_pbf_coordinate(lon),
-                                convert_pbf_coordinate(lat)
+                                convert_pbf_lon(lon),
+                                convert_pbf_lat(lat)
                         });
                     }
 
@@ -322,11 +380,11 @@ namespace osmium {
                 void decode_way(const data_view& data) {
                     osmium::builder::WayBuilder builder{m_buffer};
 
-                    kv_type keys;
-                    kv_type vals;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> refs;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lats;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lons;
+                    varint_range keys;
+                    varint_range vals;
+                    varint_range refs;
+                    varint_range lats;
+                    varint_range lons;
 
                     osm_string_len_type user{"", 0};
 
@@ -337,10 +395,10 @@ namespace osmium {
                                 builder.object().set_id(pbf_way.get_int64());
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
-                                keys = pbf_way.get_packed_uint32();
+                                keys = varint_range{pbf_way.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
-                                vals = pbf_way.get_packed_uint32();
+                                vals = varint_range{pbf_way.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
@@ -350,13 +408,13 @@ namespace osmium {
                                 }
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::packed_sint64_refs, protozero::pbf_wire_type::length_delimited):
-                                refs = pbf_way.get_packed_sint64();
+                                refs = varint_range{pbf_way.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
-                                lats = pbf_way.get_packed_sint64();
+                                lats = varint_range{pbf_way.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Way::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
-                                lons = pbf_way.get_packed_sint64();
+                                lons = varint_range{pbf_way.get_view()};
                                 break;
                             default:
                                 pbf_way.skip();
@@ -369,21 +427,18 @@ namespace osmium {
                         osmium::builder::WayNodeListBuilder wnl_builder{builder};
                         osmium::DeltaDecode<int64_t> ref;
                         if (lats.empty()) {
-                            for (const auto& ref_value : refs) {
-                                wnl_builder.add_node_ref(ref.update(ref_value));
+                            while (!refs.empty()) {
+                                wnl_builder.add_node_ref(ref.update(refs.next_sint64()));
                             }
                         } else {
                             osmium::DeltaDecode<int64_t> lon;
                             osmium::DeltaDecode<int64_t> lat;
                             while (!refs.empty() && !lons.empty() && !lats.empty()) {
                                 wnl_builder.add_node_ref(
-                                    ref.update(refs.front()),
-                                    osmium::Location{convert_pbf_coordinate(lon.update(lons.front())),
-                                                     convert_pbf_coordinate(lat.update(lats.front()))}
+                                    ref.update(refs.next_sint64()),
+                                    osmium::Location{convert_pbf_lon(lon.update(lons.next_sint64())),
+                                                     convert_pbf_lat(lat.update(lats.next_sint64()))}
                                 );
-                                refs.drop_front();
-                                lons.drop_front();
-                                lats.drop_front();
                             }
                         }
                     }
@@ -394,11 +449,11 @@ namespace osmium {
                 void decode_relation(const data_view& data) {
                     osmium::builder::RelationBuilder builder{m_buffer};
 
-                    kv_type keys;
-                    kv_type vals;
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator> roles;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> refs;
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator> types;
+                    varint_range keys;
+                    varint_range vals;
+                    varint_range roles;
+                    varint_range refs;
+                    varint_range types;
 
                     osm_string_len_type user{"", 0};
 
@@ -409,10 +464,10 @@ namespace osmium {
                                 builder.object().set_id(pbf_relation.get_int64());
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::packed_uint32_keys, protozero::pbf_wire_type::length_delimited):
-                                keys = pbf_relation.get_packed_uint32();
+                                keys = varint_range{pbf_relation.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::packed_uint32_vals, protozero::pbf_wire_type::length_delimited):
-                                vals = pbf_relation.get_packed_uint32();
+                                vals = varint_range{pbf_relation.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::optional_Info_info, protozero::pbf_wire_type::length_delimited):
                                 if (m_read_metadata == osmium::io::read_meta::yes) {
@@ -422,13 +477,13 @@ namespace osmium {
                                 }
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::packed_int32_roles_sid, protozero::pbf_wire_type::length_delimited):
-                                roles = pbf_relation.get_packed_int32();
+                                roles = varint_range{pbf_relation.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::packed_sint64_memids, protozero::pbf_wire_type::length_delimited):
-                                refs = pbf_relation.get_packed_sint64();
+                                refs = varint_range{pbf_relation.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::Relation::packed_MemberType_types, protozero::pbf_wire_type::length_delimited):
-                                types = pbf_relation.get_packed_enum();
+                                types = varint_range{pbf_relation.get_view()};
                                 break;
                             default:
                                 pbf_relation.skip();
@@ -441,63 +496,59 @@ namespace osmium {
                         osmium::builder::RelationMemberListBuilder rml_builder{builder};
                         osmium::DeltaDecode<int64_t> ref;
                         while (!roles.empty() && !refs.empty() && !types.empty()) {
-                            const auto& r = m_stringtable.at(roles.front());
-                            const int type = types.front();
+                            const auto& r = m_stringtable.at(roles.next_int32());
+                            const int type = types.next_int32();
                             if (type < 0 || type > 2) {
                                 throw osmium::pbf_error{"unknown relation member type"};
                             }
                             rml_builder.add_member(
                                 osmium::item_type(type + 1),
-                                ref.update(refs.front()),
+                                ref.update(refs.next_sint64()),
                                 r.first,
                                 r.second
                             );
-                            roles.drop_front();
-                            refs.drop_front();
-                            types.drop_front();
                         }
                     }
 
                     build_tag_list(builder, keys, vals);
                 }
 
-                void build_tag_list_from_dense_nodes(osmium::builder::NodeBuilder& builder, protozero::pbf_reader::const_int32_iterator& it, protozero::pbf_reader::const_int32_iterator last) {
+                void build_tag_list_from_dense_nodes(osmium::builder::NodeBuilder& builder, varint_range& tags) {
                     osmium::builder::TagListBuilder tl_builder{builder};
-                    while (it != last && *it != 0) {
-                        const auto& k = m_stringtable.at(*it++);
-                        if (it == last) {
+                    while (!tags.empty()) {
+                        const auto idx = tags.next_int32();
+                        if (idx == 0) {
+                            return;
+                        }
+                        const auto& k = m_stringtable.at(idx);
+                        if (tags.empty()) {
                             throw osmium::pbf_error{"PBF format error"}; // this is against the spec, keys/vals must come in pairs
                         }
-                        const auto& v = m_stringtable.at(*it++);
+                        const auto& v = m_stringtable.at(tags.next_int32());
                         tl_builder.add_tag(k.first, k.second, v.first, v.second);
                     }
-
-                    if (it != last) {
-                        ++it;
-                    }
                 }
 
                 void decode_dense_nodes_without_metadata(const data_view& data) {
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> ids;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lats;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lons;
-
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator>  tags;
+                    varint_range ids;
+                    varint_range lats;
+                    varint_range lons;
+                    varint_range tags;
 
                     protozero::pbf_message<OSMFormat::DenseNodes> pbf_dense_nodes{data};
                     while (pbf_dense_nodes.next()) {
                         switch (pbf_dense_nodes.tag_and_type()) {
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_id, protozero::pbf_wire_type::length_delimited):
-                                ids = pbf_dense_nodes.get_packed_sint64();
+                                ids = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
-                                lats = pbf_dense_nodes.get_packed_sint64();
+                                lats = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
-                                lons = pbf_dense_nodes.get_packed_sint64();
+                                lons = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_int32_keys_vals, protozero::pbf_wire_type::length_delimited):
-                                tags = pbf_dense_nodes.get_packed_int32();
+                                tags = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             default:
                                 pbf_dense_nodes.skip();
@@ -508,8 +559,6 @@ namespace osmium {
                     osmium::DeltaDecode<int64_t> dense_latitude;
                     osmium::DeltaDecode<int64_t> dense_longitude;
 
-                    auto tag_it = tags.begin();
-
                     while (!ids.empty()) {
                         if (lons.empty() ||
                             lats.empty()) {
@@ -517,24 +566,24 @@ namespace osmium {
                             throw osmium::pbf_error{"PBF format error"};
                         }
 
-                        osmium::builder::NodeBuilder builder{m_buffer};
-                        osmium::Node& node = builder.object();
+                        {
+                            osmium::builder::NodeBuilder builder{m_buffer};
+                            osmium::Node& node = builder.object();
 
-                        node.set_id(dense_id.update(ids.front()));
-                        ids.drop_front();
+                            node.set_id(dense_id.update(ids.next_sint64()));
 
-                        const auto lon = dense_longitude.update(lons.front());
-                        lons.drop_front();
-                        const auto lat = dense_latitude.update(lats.front());
-                        lats.drop_front();
-                        builder.object().set_location(osmium::Location(
-                                convert_pbf_coordinate(lon),
-                                convert_pbf_coordinate(lat)
-                        ));
+                            const auto lon = dense_longitude.update(lons.next_sint64());
+                            const auto lat = dense_latitude.update(lats.next_sint64());
+                            builder.object().set_location(osmium::Location{
+                                    convert_pbf_lon(lon),
+                                    convert_pbf_lat(lat)
+                            });
 
-                        if (tag_it != tags.end()) {
-                            build_tag_list_from_dense_nodes(builder, tag_it, tags.end());
+                            if (!tags.empty()) {
+                                build_tag_list_from_dense_nodes(builder, tags);
+                            }
                         }
+                        m_buffer.commit();
                     }
 
                 }
@@ -542,24 +591,22 @@ namespace osmium {
                 void decode_dense_nodes(const data_view& data) {
                     bool has_info = false;
 
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> ids;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lats;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> lons;
-
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator>  tags;
-
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator>  versions;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> timestamps;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint64_iterator> changesets;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint32_iterator> uids;
-                    protozero::iterator_range<protozero::pbf_reader::const_sint32_iterator> user_sids;
-                    protozero::iterator_range<protozero::pbf_reader::const_int32_iterator>  visibles;
+                    varint_range ids;
+                    varint_range lats;
+                    varint_range lons;
+                    varint_range tags;
+                    varint_range versions;
+                    varint_range timestamps;
+                    varint_range changesets;
+                    varint_range uids;
+                    varint_range user_sids;
+                    varint_range visibles;
 
                     protozero::pbf_message<OSMFormat::DenseNodes> pbf_dense_nodes{data};
                     while (pbf_dense_nodes.next()) {
                         switch (pbf_dense_nodes.tag_and_type()) {
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_id, protozero::pbf_wire_type::length_delimited):
-                                ids = pbf_dense_nodes.get_packed_sint64();
+                                ids = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::optional_DenseInfo_denseinfo, protozero::pbf_wire_type::length_delimited):
                                 {
@@ -568,22 +615,22 @@ namespace osmium {
                                     while (pbf_dense_info.next()) {
                                         switch (pbf_dense_info.tag_and_type()) {
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_int32_version, protozero::pbf_wire_type::length_delimited):
-                                                versions = pbf_dense_info.get_packed_int32();
+                                                versions = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint64_timestamp, protozero::pbf_wire_type::length_delimited):
-                                                timestamps = pbf_dense_info.get_packed_sint64();
+                                                timestamps = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint64_changeset, protozero::pbf_wire_type::length_delimited):
-                                                changesets = pbf_dense_info.get_packed_sint64();
+                                                changesets = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint32_uid, protozero::pbf_wire_type::length_delimited):
-                                                uids = pbf_dense_info.get_packed_sint32();
+                                                uids = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_sint32_user_sid, protozero::pbf_wire_type::length_delimited):
-                                                user_sids = pbf_dense_info.get_packed_sint32();
+                                                user_sids = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             case protozero::tag_and_type(OSMFormat::DenseInfo::packed_bool_visible, protozero::pbf_wire_type::length_delimited):
-                                                visibles = pbf_dense_info.get_packed_bool();
+                                                visibles = varint_range{pbf_dense_info.get_view()};
                                                 break;
                                             default:
                                                 pbf_dense_info.skip();
@@ -592,13 +639,13 @@ namespace osmium {
                                 }
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lat, protozero::pbf_wire_type::length_delimited):
-                                lats = pbf_dense_nodes.get_packed_sint64();
+                                lats = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_sint64_lon, protozero::pbf_wire_type::length_delimited):
-                                lons = pbf_dense_nodes.get_packed_sint64();
+                                lons = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             case protozero::tag_and_type(OSMFormat::DenseNodes::packed_int32_keys_vals, protozero::pbf_wire_type::length_delimited):
-                                tags = pbf_dense_nodes.get_packed_int32();
+                                tags = varint_range{pbf_dense_nodes.get_view()};
                                 break;
                             default:
                                 pbf_dense_nodes.skip();
@@ -613,8 +660,6 @@ namespace osmium {
                     osmium::DeltaDecode<int64_t> dense_changeset;
                     osmium::DeltaDecode<int64_t> dense_timestamp;
 
-                    auto tag_it = tags.begin();
-
                     while (!ids.empty()) {
                         if (lons.empty() ||
                             lats.empty()) {
@@ -622,89 +667,82 @@ namespace osmium {
                             throw osmium::pbf_error{"PBF format error"};
                         }
 
-                        bool visible = true;
+                        {
+                            bool visible = true;
 
-                        osmium::builder::NodeBuilder builder{m_buffer};
-                        osmium::Node& node = builder.object();
+                            osmium::builder::NodeBuilder builder{m_buffer};
+                            osmium::Node& node = builder.object();
 
-                        node.set_id(dense_id.update(ids.front()));
-                        ids.drop_front();
+                            node.set_id(dense_id.update(ids.next_sint64()));
 
-                        if (has_info) {
-                            if (!versions.empty()) {
-                                const auto version = versions.front();
-                                versions.drop_front();
-                                if (version < -1) {
-                                    throw osmium::pbf_error{"object version must not be negative"};
+                            if (has_info) {
+                                if (!versions.empty()) {
+                                    const auto version = versions.next_int32();
+                                    if (version < -1) {
+                                        throw osmium::pbf_error{"object version must not be negative"};
+                                    }
+
+                                    if (version == -1) {
+                                        node.set_version(0U);
+                                    } else {
+                                        node.set_version(static_cast<osmium::object_version_type>(version));
+                                    }
                                 }
 
-                                if (version == -1) {
-                                    node.set_version(0U);
-                                } else {
-                                    node.set_version(static_cast<osmium::object_version_type>(version));
+                                if (!changesets.empty()) {
+                                    const auto changeset_id = dense_changeset.update(changesets.next_sint64());
+                                    if (changeset_id < -1 || changeset_id >= std::numeric_limits<changeset_id_type>::max()) {
+                                        throw osmium::pbf_error{"object changeset_id must be between 0 and 2^32-1"};
+                                    }
+
+                                    if (changeset_id == -1) {
+                                        node.set_changeset(0U);
+                                    } else {
+                                        node.set_changeset(static_cast<osmium::changeset_id_type>(changeset_id));
+                                    }
+                                }
+
+                                if (!timestamps.empty()) {
+                                    node.set_timestamp(dense_timestamp.update(timestamps.next_sint64()) * m_date_factor / 1000);
+                                }
+
+                                if (!uids.empty()) {
+                                    node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(dense_uid.update(uids.next_sint32())));
+                                }
+
+                                if (!visibles.empty()) {
+                                    visible = (visibles.next_int32() != 0);
+                                }
+                                node.set_visible(visible);
+
+                                if (!user_sids.empty()) {
+                                    const auto& u = m_stringtable.at(dense_user_sid.update(user_sids.next_sint32()));
+                                    builder.set_user(u.first, u.second);
                                 }
                             }
 
-                            if (!changesets.empty()) {
-                                const auto changeset_id = dense_changeset.update(changesets.front());
-                                changesets.drop_front();
-                                if (changeset_id < -1 || changeset_id >= std::numeric_limits<changeset_id_type>::max()) {
-                                    throw osmium::pbf_error{"object changeset_id must be between 0 and 2^32-1"};
-                                }
-
-                                if (changeset_id == -1) {
-                                    node.set_changeset(0U);
-                                } else {
-                                    node.set_changeset(static_cast<osmium::changeset_id_type>(changeset_id));
-                                }
+                            // even if the node isn't visible, there's still a record
+                            // of its lat/lon in the dense arrays.
+                            const auto lon = dense_longitude.update(lons.next_sint64());
+                            const auto lat = dense_latitude.update(lats.next_sint64());
+                            if (visible) {
+                                builder.object().set_location(osmium::Location{
+                                        convert_pbf_lon(lon),
+                                        convert_pbf_lat(lat)
+                                });
                             }
 
-                            if (!timestamps.empty()) {
-                                node.set_timestamp(dense_timestamp.update(timestamps.front()) * m_date_factor / 1000);
-                                timestamps.drop_front();
-                            }
-
-                            if (!uids.empty()) {
-                                node.set_uid_from_signed(static_cast<osmium::signed_user_id_type>(dense_uid.update(uids.front())));
-                                uids.drop_front();
-                            }
-
-                            if (!visibles.empty()) {
-                                visible = (visibles.front() != 0);
-                                visibles.drop_front();
-                            }
-                            node.set_visible(visible);
-
-                            if (!user_sids.empty()) {
-                                const auto& u = m_stringtable.at(dense_user_sid.update(user_sids.front()));
-                                user_sids.drop_front();
-                                builder.set_user(u.first, u.second);
+                            if (!tags.empty()) {
+                                build_tag_list_from_dense_nodes(builder, tags);
                             }
                         }
-
-                        // even if the node isn't visible, there's still a record
-                        // of its lat/lon in the dense arrays.
-                        const auto lon = dense_longitude.update(lons.front());
-                        lons.drop_front();
-                        const auto lat = dense_latitude.update(lats.front());
-                        lats.drop_front();
-                        if (visible) {
-                            builder.object().set_location(osmium::Location{
-                                    convert_pbf_coordinate(lon),
-                                    convert_pbf_coordinate(lat)
-                            });
-                        }
-
-                        if (tag_it != tags.end()) {
-                            build_tag_list_from_dense_nodes(builder, tag_it, tags.end());
-                        }
+                        m_buffer.commit();
                     }
-
                 }
 
             public:
 
-                PBFPrimitiveBlockDecoder(const data_view& data, osmium::osm_entity_bits::type read_types, osmium::io::read_meta read_metadata) :
+                PBFPrimitiveBlockDecoder(const data_view& data, const osmium::osm_entity_bits::type read_types, const osmium::io::read_meta read_metadata) :
                     m_data(data),
                     m_read_types(read_types),
                     m_read_metadata(read_metadata) {
@@ -733,7 +771,8 @@ namespace osmium {
 
             inline data_view decode_blob(const std::string& blob_data, std::string& output) {
                 int32_t raw_size = 0;
-                protozero::data_view zlib_data;
+                protozero::data_view compressed_data;
+                pbf_compression use_compression = pbf_compression::none;
 
                 protozero::pbf_message<FileFormat::Blob> pbf_blob{blob_data};
                 while (pbf_blob.next()) {
@@ -753,22 +792,50 @@ namespace osmium {
                             }
                             break;
                         case protozero::tag_and_type(FileFormat::Blob::optional_bytes_zlib_data, protozero::pbf_wire_type::length_delimited):
-                            zlib_data = pbf_blob.get_view();
+                            use_compression = pbf_compression::zlib;
+                            compressed_data = pbf_blob.get_view();
                             break;
                         case protozero::tag_and_type(FileFormat::Blob::optional_bytes_lzma_data, protozero::pbf_wire_type::length_delimited):
-                            throw osmium::pbf_error{"lzma blobs not implemented"};
+                            throw osmium::pbf_error{"lzma blobs not supported"};
+                        case protozero::tag_and_type(FileFormat::Blob::optional_bytes_lz4_data, protozero::pbf_wire_type::length_delimited):
+#ifdef OSMIUM_WITH_LZ4
+                            use_compression = pbf_compression::lz4;
+                            compressed_data = pbf_blob.get_view();
+                            break;
+#else
+                            throw osmium::pbf_error{"lz4 blobs not supported"};
+#endif
+                        case protozero::tag_and_type(FileFormat::Blob::optional_bytes_zstd_data, protozero::pbf_wire_type::length_delimited):
+                            throw osmium::pbf_error{"zstd blobs not supported"};
                         default:
                             throw osmium::pbf_error{"unknown compression"};
                     }
                 }
 
-                if (!zlib_data.empty() && raw_size != 0) {
-                    return osmium::io::detail::zlib_uncompress_string(
-                        zlib_data.data(),
-                        static_cast<unsigned long>(zlib_data.size()), // NOLINT(google-runtime-int)
-                        static_cast<unsigned long>(raw_size), // NOLINT(google-runtime-int)
-                        output
-                    );
+                if (!compressed_data.empty() && raw_size != 0) {
+                    switch (use_compression) {
+                        case pbf_compression::none:
+                            break;
+                        case pbf_compression::zlib:
+                            return osmium::io::detail::zlib_uncompress_string(
+                                compressed_data.data(),
+                                static_cast<unsigned long>(compressed_data.size()), // NOLINT(google-runtime-int)
+                                static_cast<unsigned long>(raw_size), // NOLINT(google-runtime-int)
+                                output
+                            );
+                        case pbf_compression::lz4:
+#ifdef OSMIUM_WITH_LZ4
+                            return osmium::io::detail::lz4_uncompress_string(
+                                compressed_data.data(),
+                                static_cast<unsigned long>(compressed_data.size()), // NOLINT(google-runtime-int)
+                                static_cast<unsigned long>(raw_size), // NOLINT(google-runtime-int)
+                                output
+                            );
+#else
+                            break;
+#endif
+                    }
+                    std::abort(); // should never be here
                 }
 
                 throw osmium::pbf_error{"blob contains no data"};
@@ -808,8 +875,8 @@ namespace osmium {
                     }
 
                     osmium::Box box;
-                    box.extend(osmium::Location(left  / resolution_convert, bottom / resolution_convert));
-                    box.extend(osmium::Location(right / resolution_convert, top    / resolution_convert));
+                    box.extend(osmium::Location{left  / resolution_convert, bottom / resolution_convert});
+                    box.extend(osmium::Location{right / resolution_convert, top    / resolution_convert});
 
                     return box;
             }
@@ -840,8 +907,13 @@ namespace osmium {
                                 }
                             }
                             break;
-                        case protozero::tag_and_type(OSMFormat::HeaderBlock::repeated_string_optional_features, protozero::pbf_wire_type::length_delimited):
-                            header.set("pbf_optional_feature_" + std::to_string(i++), pbf_header_block.get_string());
+                        case protozero::tag_and_type(OSMFormat::HeaderBlock::repeated_string_optional_features, protozero::pbf_wire_type::length_delimited): {
+                                const auto opt = pbf_header_block.get_string();
+                                header.set("pbf_optional_feature_" + std::to_string(i++), opt);
+                                if (opt == "Sort.Type_then_ID") {
+                                    header.set("sorting", "Type_then_ID");
+                                }
+                            }
                             break;
                         case protozero::tag_and_type(OSMFormat::HeaderBlock::optional_string_writingprogram, protozero::pbf_wire_type::length_delimited):
                             header.set("generator", pbf_header_block.get_string());
@@ -888,7 +960,7 @@ namespace osmium {
 
             public:
 
-                PBFDataBlobDecoder(std::string&& input_buffer, osmium::osm_entity_bits::type read_types, osmium::io::read_meta read_metadata) :
+                PBFDataBlobDecoder(std::string&& input_buffer, const osmium::osm_entity_bits::type read_types, const osmium::io::read_meta read_metadata) :
                     m_input_buffer(std::make_shared<std::string>(std::move(input_buffer))),
                     m_read_types(read_types),
                     m_read_metadata(read_metadata) {
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
index 4edff20cc..06a88069d 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_input_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -37,6 +37,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/detail/pbf_decoder.hpp>
 #include <osmium/io/detail/protobuf_tags.hpp>
+#include <osmium/io/detail/read_write.hpp>
 #include <osmium/io/file_format.hpp>
 #include <osmium/io/header.hpp>
 #include <osmium/osm/entity_bits.hpp>
@@ -62,18 +63,24 @@ namespace osmium {
 
         namespace detail {
 
-            class PBFParser : public Parser {
+            class PBFParser final : public Parser {
 
                 std::string m_input_buffer{};
+                std::atomic<std::size_t>* m_offset_ptr;
+                int m_fd;
+                bool m_want_buffered_pages_removed;
 
                 /**
-                 * Read the given number of bytes from the input queue.
+                 * Make sure the input data contains at least the specified
+                 * number of bytes.
                  *
                  * @param size Number of bytes to read
-                 * @returns String with the data
-                 * @throws osmium::pbf_error If size bytes can't be read
                  */
-                std::string read_from_input_queue(size_t size) {
+                void ensure_available_in_input_queue(size_t size) {
+                    assert(m_fd == -1);
+                    if (m_input_buffer.size() < size) {
+                        m_input_buffer.reserve(size);
+                    }
                     while (m_input_buffer.size() < size) {
                         const std::string new_data{get_input()};
                         if (input_done()) {
@@ -81,14 +88,53 @@ namespace osmium {
                         }
                         m_input_buffer += new_data;
                     }
+                }
 
-                    std::string output{m_input_buffer.substr(size)};
-                    m_input_buffer.resize(size);
+                /**
+                 * Removes the specified number of bytes from the input data.
+                 *
+                 * @param size Number of bytes to remove
+                 */
+                void pop_from_input_queue(size_t size) {
+                    assert(m_fd == -1);
+                    m_input_buffer.erase(0, size);
+                }
 
-                    using std::swap;
-                    swap(output, m_input_buffer);
+                static uint32_t get_size_in_network_byte_order(const char* d) noexcept {
+                    return (static_cast<uint32_t>(d[3])) |
+                           (static_cast<uint32_t>(d[2]) <<  8U) |
+                           (static_cast<uint32_t>(d[1]) << 16U) |
+                           (static_cast<uint32_t>(d[0]) << 24U);
+                }
 
-                    return output;
+                static uint32_t check_size(uint32_t size) {
+                    if (size > static_cast<uint32_t>(max_blob_header_size)) {
+                        throw osmium::pbf_error{"invalid BlobHeader size (> max_blob_header_size)"};
+                    }
+                    return size;
+                }
+
+                /**
+                 * Read exactly size bytes from fd into buffer.
+                 *
+                 * @pre Value in size parameter must fit in unsigned int
+                 * @returns true if size bytes could be read
+                 *          false if EOF was encountered
+                 */
+                bool read_exactly(char* buffer, std::size_t size) {
+                    std::size_t to_read = size;
+
+                    while (to_read > 0) {
+                        auto const read_size = osmium::io::detail::reliable_read(m_fd, buffer + (size - to_read), static_cast<unsigned int>(to_read));
+                        if (read_size == 0) { // EOF
+                            return false;
+                        }
+                        to_read -= read_size;
+                    }
+
+                    *m_offset_ptr += size;
+
+                    return true;
                 }
 
                 /**
@@ -96,22 +142,24 @@ namespace osmium {
                  * the length of the following BlobHeader.
                  */
                 uint32_t read_blob_header_size_from_file() {
-                    uint32_t size_in_network_byte_order;
+                    if (m_fd != -1) {
+                        std::array<char, sizeof(uint32_t)> buffer{};
+                        if (!read_exactly(buffer.data(), buffer.size())) {
+                            return 0; // EOF
+                        }
+                        return check_size(get_size_in_network_byte_order(buffer.data()));
+                    }
+
+                    uint32_t size = 0;
 
                     try {
-                        const std::string input_data{read_from_input_queue(sizeof(size_in_network_byte_order))};
-                        size_in_network_byte_order = *reinterpret_cast<const uint32_t*>(input_data.data());
+                        ensure_available_in_input_queue(sizeof(size));
+                        size = get_size_in_network_byte_order(m_input_buffer.data());
+                        pop_from_input_queue(sizeof(size));
                     } catch (const osmium::pbf_error&) {
                         return 0; // EOF
                     }
 
-                    #ifndef _WIN32
-                    const uint32_t size = ntohl(size_in_network_byte_order);
-                    #else
-                    uint32_t size = size_in_network_byte_order;
-                    protozero::detail::byteswap_inplace(&size);
-                    #endif
-
                     if (size > static_cast<uint32_t>(max_blob_header_size)) {
                         throw osmium::pbf_error{"invalid BlobHeader size (> max_blob_header_size)"};
                     }
@@ -123,7 +171,8 @@ namespace osmium {
                  * Decode the BlobHeader. Make sure it contains the expected
                  * type. Return the size of the following Blob.
                  */
-                size_t decode_blob_header(protozero::pbf_message<FileFormat::BlobHeader>&& pbf_blob_header, const char* expected_type) {
+                static size_t decode_blob_header(const protozero::data_view& data, const char* expected_type) {
+                    protozero::pbf_message<FileFormat::BlobHeader> pbf_blob_header{data};
                     protozero::data_view blob_header_type;
                     size_t blob_header_datasize = 0;
 
@@ -159,9 +208,16 @@ namespace osmium {
                         return 0;
                     }
 
-                    const std::string blob_header{read_from_input_queue(size)};
+                    if (m_fd != -1) {
+                        auto const buffer = read_from_input_queue_with_check(size);
+                        const auto blob_size = decode_blob_header(protozero::data_view{buffer.data(), size}, expected_type);
+                        return blob_size;
+                    }
 
-                    return decode_blob_header(protozero::pbf_message<FileFormat::BlobHeader>(blob_header), expected_type);
+                    ensure_available_in_input_queue(size);
+                    const auto blob_size = decode_blob_header(protozero::data_view{m_input_buffer.data(), size}, expected_type);
+                    pop_from_input_queue(size);
+                    return blob_size;
                 }
 
                 std::string read_from_input_queue_with_check(size_t size) {
@@ -169,7 +225,21 @@ namespace osmium {
                         throw osmium::pbf_error{std::string{"invalid blob size: "} +
                                                 std::to_string(size)};
                     }
-                    return read_from_input_queue(size);
+
+                    std::string buffer;
+                    if (m_fd != -1) {
+                        buffer.resize(size);
+
+                        if (!read_exactly(&*buffer.begin(), size)) {
+                            throw osmium::pbf_error{"unexpected EOF"};
+                        }
+                    } else {
+                        ensure_available_in_input_queue(size);
+                        buffer.append(m_input_buffer, 0, size);
+                        pop_from_input_queue(size);
+                    }
+
+                    return buffer;
                 }
 
                 // Parse the header in the PBF OSMHeader blob.
@@ -180,23 +250,31 @@ namespace osmium {
                 }
 
                 void parse_data_blobs() {
+                    const bool use_pool = osmium::config::use_pool_threads_for_pbf_parsing();
                     while (const auto size = check_type_and_get_blob_size("OSMData")) {
                         std::string input_buffer{read_from_input_queue_with_check(size)};
 
                         PBFDataBlobDecoder data_blob_parser{std::move(input_buffer), read_types(), read_metadata()};
 
-                        if (osmium::config::use_pool_threads_for_pbf_parsing()) {
+                        if (use_pool) {
                             send_to_output_queue(get_pool().submit(std::move(data_blob_parser)));
                         } else {
                             send_to_output_queue(data_blob_parser());
                         }
+
+                        if (m_want_buffered_pages_removed) {
+                            osmium::io::detail::remove_buffered_pages(m_fd, *m_offset_ptr);
+                        }
                     }
                 }
 
             public:
 
                 explicit PBFParser(parser_arguments& args) :
-                    Parser(args) {
+                    Parser(args),
+                    m_offset_ptr(args.offset_ptr),
+                    m_fd(args.fd),
+                    m_want_buffered_pages_removed(args.want_buffered_pages_removed) {
                 }
 
                 PBFParser(const PBFParser&) = delete;
@@ -205,9 +283,9 @@ namespace osmium {
                 PBFParser(PBFParser&&) = delete;
                 PBFParser& operator=(PBFParser&&) = delete;
 
-                ~PBFParser() noexcept final = default;
+                ~PBFParser() noexcept override = default;
 
-                void run() final {
+                void run() override {
                     osmium::thread::set_thread_name("_osmium_pbf_in");
 
                     parse_header_blob();
@@ -215,6 +293,8 @@ namespace osmium {
                     if (read_types() != osmium::osm_entity_bits::nothing) {
                         parse_data_blobs();
                     }
+
+                    osmium::io::detail::reliable_close(m_fd);
                 }
 
             }; // class PBFParser
diff --git a/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
index 777032b96..b73e1da33 100644
--- a/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/pbf_output_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,15 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
 #include <osmium/handler.hpp>
 #include <osmium/io/detail/output_format.hpp>
 #include <osmium/io/detail/pbf.hpp> // IWYU pragma: export
@@ -58,24 +67,18 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/way.hpp>
 #include <osmium/thread/pool.hpp>
-#include <osmium/util/cast.hpp>
 #include <osmium/util/delta.hpp>
 #include <osmium/util/misc.hpp>
 #include <osmium/visitor.hpp>
 
+#ifdef OSMIUM_WITH_LZ4
+# include <osmium/io/detail/lz4.hpp>
+#endif
+
 #include <protozero/pbf_builder.hpp>
 #include <protozero/pbf_writer.hpp>
 #include <protozero/types.hpp>
 
-#include <cassert>
-#include <cmath>
-#include <cstdint>
-#include <cstdlib>
-#include <memory>
-#include <string>
-#include <utility>
-#include <vector>
-
 namespace osmium {
 
     namespace io {
@@ -87,18 +90,17 @@ namespace osmium {
                 /// Which metadata of objects should be added?
                 osmium::metadata_options add_metadata;
 
-                /// Should nodes be encoded in DenseNodes?
-                bool use_dense_nodes = true;
+                /// Compression level used for compression
+                int compression_level = 0;
 
                 /**
-                 * Should the PBF blobs contain zlib compressed data?
-                 *
-                 * The zlib compression is optional, it's possible to store the
-                 * blobs in raw format. Disabling the compression can improve
-                 * the writing speed a little but the output will be 2x to 3x
-                 * bigger.
+                 * Which compression (if any) should be used to compress the
+                 * PBF blobs?
                  */
-                bool use_compression = true;
+                pbf_compression use_compression = pbf_compression::zlib;
+
+                /// Should nodes be encoded in DenseNodes?
+                bool use_dense_nodes = true;
 
                 /// Add the "HistoricalInformation" header flag.
                 bool add_historical_information_flag = false;
@@ -123,101 +125,21 @@ namespace osmium {
              * as well as Osmium implementation always
              * uses at most 8k entities in a block.
              */
-            constexpr int32_t max_entities_per_block = 8000;
-
-            constexpr int location_granularity = 100;
-
-            /**
-             * convert a double lat or lon value to an int, respecting the granularity
-             */
-            inline int64_t lonlat2int(double lonlat) {
-                return static_cast<int64_t>(std::round(lonlat * lonlat_resolution / location_granularity));
-            }
+            enum {
+                max_entities_per_block = 8000
+            };
 
             enum class pbf_blob_type {
                 header = 0,
                 data = 1
             };
 
-            class SerializeBlob {
-
-                std::string m_msg;
-
-                pbf_blob_type m_blob_type;
-
-                bool m_use_compression;
-
-            public:
-
-                /**
-                 * Initialize a blob serializer.
-                 *
-                 * @param msg Protobuf-message containing the blob data
-                 * @param type Type of blob.
-                 * @param use_compression Should the output be compressed using
-                 *        zlib?
-                 */
-                SerializeBlob(std::string&& msg, pbf_blob_type type, bool use_compression) :
-                    m_msg(std::move(msg)),
-                    m_blob_type(type),
-                    m_use_compression(use_compression) {
-                }
-
-                /**
-                 * Serialize a protobuf message into a Blob, optionally apply
-                 * compression and return it together with a BlobHeader ready
-                 * to be written to a file.
-                 */
-                std::string operator()() {
-                    assert(m_msg.size() <= max_uncompressed_blob_size);
-
-                    std::string blob_data;
-                    protozero::pbf_builder<FileFormat::Blob> pbf_blob{blob_data};
-
-                    if (m_use_compression) {
-                        pbf_blob.add_int32(FileFormat::Blob::optional_int32_raw_size, int32_t(m_msg.size()));
-                        pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_zlib_data, osmium::io::detail::zlib_compress(m_msg));
-                    } else {
-                        pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_raw, m_msg);
-                    }
-
-                    std::string blob_header_data;
-                    protozero::pbf_builder<FileFormat::BlobHeader> pbf_blob_header{blob_header_data};
-
-                    pbf_blob_header.add_string(FileFormat::BlobHeader::required_string_type, m_blob_type == pbf_blob_type::data ? "OSMData" : "OSMHeader");
-                    pbf_blob_header.add_int32(FileFormat::BlobHeader::required_int32_datasize, static_cast_with_assert<int32_t>(blob_data.size()));
-
-#ifndef _WIN32
-                    const uint32_t sz = htonl(static_cast_with_assert<uint32_t>(blob_header_data.size()));
-#else
-                    uint32_t sz = static_cast_with_assert<uint32_t>(blob_header_data.size());
-                    protozero::detail::byteswap_inplace(&sz);
-#endif
-
-                    // write to output: the 4-byte BlobHeader-Size followed by the BlobHeader followed by the Blob
-                    std::string output;
-                    output.reserve(sizeof(sz) + blob_header_data.size() + blob_data.size());
-                    output.append(reinterpret_cast<const char*>(&sz), sizeof(sz));
-                    output.append(blob_header_data);
-                    output.append(blob_data);
-
-                    return output;
-                }
-
-            }; // class SerializeBlob
-
             /**
              * Contains the code to pack any number of nodes into a DenseNode
              * structure.
-             *
-             * Because this needs to allocate a lot of memory on the heap,
-             * only one object of this class will be created and then re-used
-             * after calling clear() on it.
              */
             class DenseNodes {
 
-                StringTable& m_stringtable;
-
                 std::vector<int64_t> m_ids;
 
                 std::vector<int32_t> m_versions;
@@ -231,49 +153,45 @@ namespace osmium {
                 std::vector<int64_t> m_lons;
                 std::vector<int32_t> m_tags;
 
+                StringTable* m_stringtable;
+                const pbf_output_options* m_options;
+
                 osmium::DeltaEncode<object_id_type, int64_t> m_delta_id;
 
                 osmium::DeltaEncode<uint32_t, int64_t> m_delta_timestamp;
                 osmium::DeltaEncode<changeset_id_type, int64_t> m_delta_changeset;
                 osmium::DeltaEncode<user_id_type, int32_t> m_delta_uid;
-                osmium::DeltaEncode<uint32_t, int32_t> m_delta_user_sid;
+                osmium::DeltaEncode<int32_t, int32_t> m_delta_user_sid;
 
                 osmium::DeltaEncode<int64_t, int64_t> m_delta_lat;
                 osmium::DeltaEncode<int64_t, int64_t> m_delta_lon;
 
-                const pbf_output_options& m_options;
-
             public:
 
-                DenseNodes(StringTable& stringtable, const pbf_output_options& options) :
+                DenseNodes(StringTable* stringtable, const pbf_output_options* options) :
                     m_stringtable(stringtable),
                     m_options(options) {
-                }
-
-                /// Clear object for re-use. Keep the allocated memory.
-                void clear() {
-                    m_ids.clear();
-
-                    m_versions.clear();
-                    m_timestamps.clear();
-                    m_changesets.clear();
-                    m_uids.clear();
-                    m_user_sids.clear();
-                    m_visibles.clear();
-
-                    m_lats.clear();
-                    m_lons.clear();
-                    m_tags.clear();
-
-                    m_delta_id.clear();
-
-                    m_delta_timestamp.clear();
-                    m_delta_changeset.clear();
-                    m_delta_uid.clear();
-                    m_delta_user_sid.clear();
-
-                    m_delta_lat.clear();
-                    m_delta_lon.clear();
+                    m_ids.reserve(max_entities_per_block);
+                    if (m_options->add_metadata.version()) {
+                        m_versions.reserve(max_entities_per_block);
+                    }
+                    if (m_options->add_metadata.timestamp()) {
+                        m_timestamps.reserve(max_entities_per_block);
+                    }
+                    if (m_options->add_metadata.changeset()) {
+                        m_changesets.reserve(max_entities_per_block);
+                    }
+                    if (m_options->add_metadata.uid()) {
+                        m_uids.reserve(max_entities_per_block);
+                    }
+                    if (m_options->add_metadata.user()) {
+                        m_user_sids.reserve(max_entities_per_block);
+                    }
+                    if (m_options->add_visible_flag) {
+                        m_visibles.reserve(max_entities_per_block);
+                    }
+                    m_lats.reserve(max_entities_per_block);
+                    m_lons.reserve(max_entities_per_block);
                 }
 
                 std::size_t size() const noexcept {
@@ -283,31 +201,32 @@ namespace osmium {
                 void add_node(const osmium::Node& node) {
                     m_ids.push_back(m_delta_id.update(node.id()));
 
-                    if (m_options.add_metadata.version()) {
-                        m_versions.push_back(static_cast_with_assert<int32_t>(node.version()));
+                    if (m_options->add_metadata.version()) {
+                        assert(node.version() <= static_cast<std::size_t>(std::numeric_limits<int32_t>::max()));
+                        m_versions.push_back(static_cast<int32_t>(node.version()));
                     }
-                    if (m_options.add_metadata.timestamp()) {
+                    if (m_options->add_metadata.timestamp()) {
                         m_timestamps.push_back(m_delta_timestamp.update(uint32_t(node.timestamp())));
                     }
-                    if (m_options.add_metadata.changeset()) {
+                    if (m_options->add_metadata.changeset()) {
                         m_changesets.push_back(m_delta_changeset.update(node.changeset()));
                     }
-                    if (m_options.add_metadata.uid()) {
+                    if (m_options->add_metadata.uid()) {
                         m_uids.push_back(m_delta_uid.update(node.uid()));
                     }
-                    if (m_options.add_metadata.user()) {
-                        m_user_sids.push_back(m_delta_user_sid.update(m_stringtable.add(node.user())));
+                    if (m_options->add_metadata.user()) {
+                        m_user_sids.push_back(m_delta_user_sid.update(m_stringtable->add(node.user())));
                     }
-                    if (m_options.add_visible_flag) {
+                    if (m_options->add_visible_flag) {
                         m_visibles.push_back(node.visible());
                     }
 
-                    m_lats.push_back(m_delta_lat.update(lonlat2int(node.location().lat_without_check())));
-                    m_lons.push_back(m_delta_lon.update(lonlat2int(node.location().lon_without_check())));
+                    m_lats.push_back(m_delta_lat.update(node.location().y()));
+                    m_lons.push_back(m_delta_lon.update(node.location().x()));
 
                     for (const auto& tag : node.tags()) {
-                        m_tags.push_back(static_cast_with_assert<int32_t>(m_stringtable.add(tag.key())));
-                        m_tags.push_back(static_cast_with_assert<int32_t>(m_stringtable.add(tag.value())));
+                        m_tags.push_back(m_stringtable->add(tag.key()));
+                        m_tags.push_back(m_stringtable->add(tag.value()));
                     }
                     m_tags.push_back(0);
                 }
@@ -318,24 +237,24 @@ namespace osmium {
 
                     pbf_dense_nodes.add_packed_sint64(OSMFormat::DenseNodes::packed_sint64_id, m_ids.cbegin(), m_ids.cend());
 
-                    if (m_options.add_metadata.any() || m_options.add_visible_flag) {
+                    if (m_options->add_metadata.any() || m_options->add_visible_flag) {
                         protozero::pbf_builder<OSMFormat::DenseInfo> pbf_dense_info{pbf_dense_nodes, OSMFormat::DenseNodes::optional_DenseInfo_denseinfo};
-                        if (m_options.add_metadata.version()) {
+                        if (m_options->add_metadata.version()) {
                             pbf_dense_info.add_packed_int32(OSMFormat::DenseInfo::packed_int32_version, m_versions.cbegin(), m_versions.cend());
                         }
-                        if (m_options.add_metadata.timestamp()) {
+                        if (m_options->add_metadata.timestamp()) {
                             pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_timestamp, m_timestamps.cbegin(), m_timestamps.cend());
                         }
-                        if (m_options.add_metadata.changeset()) {
+                        if (m_options->add_metadata.changeset()) {
                             pbf_dense_info.add_packed_sint64(OSMFormat::DenseInfo::packed_sint64_changeset, m_changesets.cbegin(), m_changesets.cend());
                         }
-                        if (m_options.add_metadata.uid()) {
+                        if (m_options->add_metadata.uid()) {
                             pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_uid, m_uids.cbegin(), m_uids.cend());
                         }
-                        if (m_options.add_metadata.user()) {
+                        if (m_options->add_metadata.user()) {
                             pbf_dense_info.add_packed_sint32(OSMFormat::DenseInfo::packed_sint32_user_sid, m_user_sids.cbegin(), m_user_sids.cend());
                         }
-                        if (m_options.add_visible_flag) {
+                        if (m_options->add_visible_flag) {
                             pbf_dense_info.add_packed_bool(OSMFormat::DenseInfo::packed_bool_visible, m_visibles.cbegin(), m_visibles.cend());
                         }
                     }
@@ -355,32 +274,31 @@ namespace osmium {
                 std::string m_pbf_primitive_group_data;
                 protozero::pbf_builder<OSMFormat::PrimitiveGroup> m_pbf_primitive_group;
                 StringTable m_stringtable;
-                DenseNodes m_dense_nodes;
-                OSMFormat::PrimitiveGroup m_type = OSMFormat::PrimitiveGroup::unknown;
+                pbf_output_options m_options;
+                std::unique_ptr<DenseNodes> m_dense_nodes{};
+                OSMFormat::PrimitiveGroup m_type;
                 int m_count = 0;
 
             public:
 
-                explicit PrimitiveBlock(const pbf_output_options& options) :
+                explicit PrimitiveBlock(const pbf_output_options& options, OSMFormat::PrimitiveGroup type, size_t bucket_count) :
                     m_pbf_primitive_group(m_pbf_primitive_group_data),
-                    m_dense_nodes(m_stringtable, options) {
+                    m_stringtable(StringTable::default_stringtable_chunk_size, bucket_count),
+                    m_options(options),
+                    m_type(type) {
+                }
+
+                std::size_t get_bucket_count() const noexcept {
+                    return m_stringtable.get_bucket_count();
                 }
 
                 const std::string& group_data() {
-                    if (type() == OSMFormat::PrimitiveGroup::optional_DenseNodes_dense) {
-                        m_pbf_primitive_group.add_message(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense, m_dense_nodes.serialize());
+                    if (m_dense_nodes) {
+                        m_pbf_primitive_group.add_message(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense, m_dense_nodes->serialize());
                     }
                     return m_pbf_primitive_group_data;
                 }
 
-                void reset(OSMFormat::PrimitiveGroup type) {
-                    m_pbf_primitive_group_data.clear();
-                    m_stringtable.clear();
-                    m_dense_nodes.clear();
-                    m_type = type;
-                    m_count = 0;
-                }
-
                 void write_stringtable(protozero::pbf_builder<OSMFormat::StringTable>& pbf_string_table) {
                     for (const char* s : m_stringtable) {
                         pbf_string_table.add_bytes(OSMFormat::StringTable::repeated_bytes_s, s);
@@ -393,24 +311,35 @@ namespace osmium {
                 }
 
                 void add_dense_node(const osmium::Node& node) {
-                    m_dense_nodes.add_node(node);
+                    if (!m_dense_nodes) {
+                        m_dense_nodes.reset(new DenseNodes{&m_stringtable, &m_options});
+                    }
+                    m_dense_nodes->add_node(node);
                     ++m_count;
                 }
 
-                uint32_t store_in_stringtable(const char* s) {
+                // There are two functions store_in_stringtable(_unsigned)
+                // here because of an inconsistency in the OSMPBF format
+                // specification. Both uint32 and sint32 types are used in
+                // the format for essentially the same thing.
+
+                int32_t store_in_stringtable(const char* s) {
                     return m_stringtable.add(s);
                 }
 
+                uint32_t store_in_stringtable_unsigned(const char* s) {
+                    // static_cast okay, because result of add is always >= 0
+                    return static_cast<uint32_t>(m_stringtable.add(s));
+                }
+
                 int count() const noexcept {
                     return m_count;
                 }
 
-                OSMFormat::PrimitiveGroup type() const noexcept {
-                    return m_type;
-                }
-
                 std::size_t size() const noexcept {
-                    return m_pbf_primitive_group_data.size() + m_stringtable.size() + m_dense_nodes.size();
+                    return m_pbf_primitive_group_data.size() +
+                           m_stringtable.size() +
+                           (m_dense_nodes ? m_dense_nodes->size() : 0);
                 }
 
                 /**
@@ -419,7 +348,9 @@ namespace osmium {
                  * enough space for the string table (which typically
                  * needs about 0.1 to 0.3% of the block size).
                  */
-                constexpr static std::size_t max_used_blob_size = max_uncompressed_blob_size * 95 / 100;
+                enum {
+                    max_used_blob_size = max_uncompressed_blob_size * 95U / 100U
+                };
 
                 bool can_add(OSMFormat::PrimitiveGroup type) const noexcept {
                     if (type != m_type) {
@@ -433,32 +364,148 @@ namespace osmium {
 
             }; // class PrimitiveBlock
 
+            class SerializeBlob {
+
+                std::shared_ptr<PrimitiveBlock> m_block{};
+
+                std::string m_msg;
+
+                int m_compression_level;
+
+                pbf_blob_type m_blob_type;
+
+                pbf_compression m_use_compression;
+
+            public:
+
+                /**
+                 * Initialize a blob serializer.
+                 *
+                 * @param msg Protobuf-message containing the blob data.
+                 * @param type Type of blob.
+                 * @param use_compression The type of compression to use.
+                 * @param compression_level Compression level.
+                 */
+                SerializeBlob(std::string&& msg, pbf_blob_type type, pbf_compression use_compression, int compression_level) :
+                    m_msg(std::move(msg)),
+                    m_compression_level(compression_level),
+                    m_blob_type(type),
+                    m_use_compression(use_compression) {
+                }
+
+                /**
+                 * Initialize a blob serializer.
+                 *
+                 * @param block Pointer to PrimitiveBlock with data.
+                 * @param type Type of blob.
+                 * @param use_compression The type of compression to use.
+                 * @param compression_level Compression level.
+                 */
+                SerializeBlob(std::shared_ptr<PrimitiveBlock> block, pbf_blob_type type, pbf_compression use_compression, int compression_level) :
+                    m_block(std::move(block)),
+                    m_compression_level(compression_level),
+                    m_blob_type(type),
+                    m_use_compression(use_compression) {
+                }
+
+                /**
+                 * Serialize a protobuf message into a Blob, optionally apply
+                 * compression and return it together with a BlobHeader ready
+                 * to be written to a file.
+                 */
+                std::string operator()() {
+                    if (m_block) {
+                        protozero::pbf_builder<OSMFormat::PrimitiveBlock> primitive_block{m_msg};
+
+                        {
+                            protozero::pbf_builder<OSMFormat::StringTable> pbf_string_table{primitive_block, OSMFormat::PrimitiveBlock::required_StringTable_stringtable};
+                            m_block->write_stringtable(pbf_string_table);
+                        }
+
+                        primitive_block.add_message(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup, m_block->group_data());
+                    }
+
+                    assert(m_msg.size() <= max_uncompressed_blob_size);
+
+                    std::string blob_data;
+                    protozero::pbf_builder<FileFormat::Blob> pbf_blob{blob_data};
+
+                    switch (m_use_compression) {
+                        case pbf_compression::none:
+                            pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_raw, m_msg);
+                            break;
+                        case pbf_compression::zlib:
+                            pbf_blob.add_int32(FileFormat::Blob::optional_int32_raw_size, int32_t(m_msg.size()));
+                            pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_zlib_data, osmium::io::detail::zlib_compress(m_msg, m_compression_level));
+                            break;
+                        case pbf_compression::lz4:
+#ifdef OSMIUM_WITH_LZ4
+                            pbf_blob.add_int32(FileFormat::Blob::optional_int32_raw_size, int32_t(m_msg.size()));
+                            pbf_blob.add_bytes(FileFormat::Blob::optional_bytes_lz4_data, osmium::io::detail::lz4_compress(m_msg, m_compression_level));
+                            break;
+#else
+                            throw osmium::pbf_error{"lz4 blobs not supported"};
+#endif
+                    }
+
+                    std::string blob_header_data;
+                    protozero::pbf_builder<FileFormat::BlobHeader> pbf_blob_header{blob_header_data};
+
+                    pbf_blob_header.add_string(FileFormat::BlobHeader::required_string_type, m_blob_type == pbf_blob_type::data ? "OSMData" : "OSMHeader");
+
+                    // The static_cast is okay, because the size can never
+                    // be much larger than max_uncompressed_blob_size. This
+                    // is due to the assert above and the fact that the zlib
+                    // library will not grow deflated data beyond the original
+                    // data plus a few header bytes (https://zlib.net/zlib_tech.html).
+                    pbf_blob_header.add_int32(FileFormat::BlobHeader::required_int32_datasize, static_cast<int32_t>(blob_data.size()));
+
+                    const auto size = static_cast<uint32_t>(blob_header_data.size());
+
+                    // write to output: the 4-byte BlobHeader size in network
+                    // byte order followed by the BlobHeader followed by the Blob
+                    std::string output;
+                    output.reserve(4 + blob_header_data.size() + blob_data.size());
+                    output += static_cast<char>((size >> 24U) & 0xffU);
+                    output += static_cast<char>((size >> 16U) & 0xffU);
+                    output += static_cast<char>((size >>  8U) & 0xffU);
+                    output += static_cast<char>( size         & 0xffU);
+                    output.append(blob_header_data);
+                    output.append(blob_data);
+
+                    return output;
+                }
+
+            }; // class SerializeBlob
+
             class PBFOutputFormat : public osmium::io::detail::OutputFormat, public osmium::handler::Handler {
 
                 pbf_output_options m_options;
 
-                PrimitiveBlock m_primitive_block;
+                std::shared_ptr<PrimitiveBlock> m_primitive_block{};
+
+                std::size_t m_bucket_count = StringTable::min_bucket_count;
 
                 void store_primitive_block() {
-                    if (m_primitive_block.count() == 0) {
+                    if (!m_primitive_block || m_primitive_block->count() == 0) {
                         return;
                     }
 
-                    std::string primitive_block_data;
-                    protozero::pbf_builder<OSMFormat::PrimitiveBlock> primitive_block{primitive_block_data};
-
-                    {
-                        protozero::pbf_builder<OSMFormat::StringTable> pbf_string_table{primitive_block, OSMFormat::PrimitiveBlock::required_StringTable_stringtable};
-                        m_primitive_block.write_stringtable(pbf_string_table);
-                    }
-
-                    primitive_block.add_message(OSMFormat::PrimitiveBlock::repeated_PrimitiveGroup_primitivegroup, m_primitive_block.group_data());
+                    // Remember the bucket_count of the hash in the string
+                    // table. It will be used when initializing the string
+                    // table for the next block.
+                    //
+                    // Some versions of the std library will set the bucket
+                    // count always larger then what we set it to. We decrease
+                    // the bucket count by one, this way the bucket will not
+                    // grow too much.
+                    m_bucket_count = m_primitive_block->get_bucket_count() - 1;
 
                     m_output_queue.push(m_pool.submit(
-                        SerializeBlob{std::move(primitive_block_data),
+                        SerializeBlob{std::move(m_primitive_block),
                                       pbf_blob_type::data,
-                                      m_options.use_compression}
-                    ));
+                                      m_options.use_compression,
+                                      m_options.compression_level}));
                 }
 
                 template <typename T>
@@ -466,14 +513,14 @@ namespace osmium {
                     {
                         protozero::packed_field_uint32 field{pbf_object, protozero::pbf_tag_type(T::enum_type::packed_uint32_keys)};
                         for (const auto& tag : object.tags()) {
-                            field.add_element(m_primitive_block.store_in_stringtable(tag.key()));
+                            field.add_element(m_primitive_block->store_in_stringtable_unsigned(tag.key()));
                         }
                     }
 
                     {
                         protozero::packed_field_uint32 field{pbf_object, protozero::pbf_tag_type(T::enum_type::packed_uint32_vals)};
                         for (const auto& tag : object.tags()) {
-                            field.add_element(m_primitive_block.store_in_stringtable(tag.value()));
+                            field.add_element(m_primitive_block->store_in_stringtable_unsigned(tag.value()));
                         }
                     }
 
@@ -481,7 +528,8 @@ namespace osmium {
                         protozero::pbf_builder<OSMFormat::Info> pbf_info{pbf_object, T::enum_type::optional_Info_info};
 
                         if (m_options.add_metadata.version()) {
-                            pbf_info.add_int32(OSMFormat::Info::optional_int32_version, static_cast_with_assert<int32_t>(object.version()));
+                            assert(object.version() <= static_cast<std::size_t>(std::numeric_limits<int32_t>::max()));
+                            pbf_info.add_int32(OSMFormat::Info::optional_int32_version, static_cast<int32_t>(object.version()));
                         }
                         if (m_options.add_metadata.timestamp()) {
                             pbf_info.add_int64(OSMFormat::Info::optional_int64_timestamp, uint32_t(object.timestamp()));
@@ -490,10 +538,11 @@ namespace osmium {
                             pbf_info.add_int64(OSMFormat::Info::optional_int64_changeset, object.changeset());
                         }
                         if (m_options.add_metadata.uid()) {
-                            pbf_info.add_int32(OSMFormat::Info::optional_int32_uid, static_cast_with_assert<int32_t>(object.uid()));
+                            assert(object.uid() <= static_cast<std::size_t>(std::numeric_limits<int32_t>::max()));
+                            pbf_info.add_int32(OSMFormat::Info::optional_int32_uid, static_cast<int32_t>(object.uid()));
                         }
                         if (m_options.add_metadata.user()) {
-                            pbf_info.add_uint32(OSMFormat::Info::optional_uint32_user_sid, m_primitive_block.store_in_stringtable(object.user()));
+                            pbf_info.add_uint32(OSMFormat::Info::optional_uint32_user_sid, m_primitive_block->store_in_stringtable_unsigned(object.user()));
                         }
                         if (m_options.add_visible_flag) {
                             pbf_info.add_bool(OSMFormat::Info::optional_bool_visible, object.visible());
@@ -502,28 +551,62 @@ namespace osmium {
                 }
 
                 void switch_primitive_block_type(OSMFormat::PrimitiveGroup type) {
-                    if (!m_primitive_block.can_add(type)) {
+                    if (!m_primitive_block || !m_primitive_block->can_add(type)) {
                         store_primitive_block();
-                        m_primitive_block.reset(type);
+                        m_primitive_block.reset(new PrimitiveBlock{m_options, type, m_bucket_count});
                     }
                 }
 
             public:
 
                 PBFOutputFormat(osmium::thread::Pool& pool, const osmium::io::File& file, future_string_queue_type& output_queue) :
-                    OutputFormat(pool, output_queue),
-                    m_primitive_block(m_options) {
+                    OutputFormat(pool, output_queue) {
 
                     if (!file.get("pbf_add_metadata").empty()) {
                         throw std::invalid_argument{"The 'pbf_add_metadata' option is deprecated. Please use 'add_metadata' instead."};
                     }
 
                     m_options.use_dense_nodes = file.is_not_false("pbf_dense_nodes");
-                    m_options.use_compression = file.get("pbf_compression") != "none" && file.is_not_false("pbf_compression");
+                    m_options.use_compression = get_compression_type(file.get("pbf_compression"));
                     m_options.add_metadata = osmium::metadata_options{file.get("add_metadata")};
                     m_options.add_historical_information_flag = file.has_multiple_object_versions();
                     m_options.add_visible_flag = file.has_multiple_object_versions();
                     m_options.locations_on_ways = file.is_true("locations_on_ways");
+
+                    const auto pbl = file.get("pbf_compression_level");
+                    if (pbl.empty()) {
+                        switch (m_options.use_compression) {
+                            case pbf_compression::none:
+                                break;
+                            case pbf_compression::zlib:
+                                m_options.compression_level = osmium::io::detail::zlib_default_compression_level();
+                                break;
+                            case pbf_compression::lz4:
+#ifdef OSMIUM_WITH_LZ4
+                                m_options.compression_level = osmium::io::detail::lz4_default_compression_level();
+#endif
+                                break;
+                        }
+                    } else {
+                        char* end_ptr = nullptr;
+                        const auto val = std::strtol(pbl.c_str(), &end_ptr, 10);
+                        if (*end_ptr != '\0') {
+                            throw std::invalid_argument{"The 'pbf_compression_level' option must be an integer."};
+                        }
+                        switch (m_options.use_compression) {
+                            case pbf_compression::none:
+                                throw std::invalid_argument{"The 'pbf_compression_level' option doesn't make sense without 'pbf_compression' set."};
+                            case pbf_compression::zlib:
+                                osmium::io::detail::zlib_check_compression_level(val);
+                                break;
+                            case pbf_compression::lz4:
+#ifdef OSMIUM_WITH_LZ4
+                                osmium::io::detail::lz4_check_compression_level(val);
+#endif
+                                break;
+                        }
+                        m_options.compression_level = static_cast<int>(val);
+                    }
                 }
 
                 void write_header(const osmium::io::Header& header) final {
@@ -554,6 +637,10 @@ namespace osmium {
                         pbf_header_block.add_string(OSMFormat::HeaderBlock::repeated_string_optional_features, "LocationsOnWays");
                     }
 
+                    if (header.get("sorting") == "Type_then_ID") {
+                        pbf_header_block.add_string(OSMFormat::HeaderBlock::repeated_string_optional_features, "Sort.Type_then_ID");
+                    }
+
                     pbf_header_block.add_string(OSMFormat::HeaderBlock::optional_string_writingprogram, header.get("generator"));
 
                     const std::string osmosis_replication_timestamp{header.get("osmosis_replication_timestamp")};
@@ -575,8 +662,8 @@ namespace osmium {
                     m_output_queue.push(m_pool.submit(
                         SerializeBlob{std::move(data),
                                       pbf_blob_type::header,
-                                      m_options.use_compression}
-                        ));
+                                      m_options.use_compression,
+                                      m_options.compression_level}));
                 }
 
                 void write_buffer(osmium::memory::Buffer&& buffer) final {
@@ -590,23 +677,23 @@ namespace osmium {
                 void node(const osmium::Node& node) {
                     if (m_options.use_dense_nodes) {
                         switch_primitive_block_type(OSMFormat::PrimitiveGroup::optional_DenseNodes_dense);
-                        m_primitive_block.add_dense_node(node);
+                        m_primitive_block->add_dense_node(node);
                         return;
                     }
 
                     switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Node_nodes);
-                    protozero::pbf_builder<OSMFormat::Node> pbf_node{m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Node_nodes};
+                    protozero::pbf_builder<OSMFormat::Node> pbf_node{m_primitive_block->group(), OSMFormat::PrimitiveGroup::repeated_Node_nodes};
 
                     pbf_node.add_sint64(OSMFormat::Node::required_sint64_id, node.id());
                     add_meta(node, pbf_node);
 
-                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lat, lonlat2int(node.location().lat_without_check()));
-                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lon, lonlat2int(node.location().lon_without_check()));
+                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lat, node.location().y());
+                    pbf_node.add_sint64(OSMFormat::Node::required_sint64_lon, node.location().x());
                 }
 
                 void way(const osmium::Way& way) {
                     switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Way_ways);
-                    protozero::pbf_builder<OSMFormat::Way> pbf_way{m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Way_ways};
+                    protozero::pbf_builder<OSMFormat::Way> pbf_way{m_primitive_block->group(), OSMFormat::PrimitiveGroup::repeated_Way_ways};
 
                     pbf_way.add_int64(OSMFormat::Way::required_int64_id, way.id());
                     add_meta(way, pbf_way);
@@ -621,17 +708,17 @@ namespace osmium {
 
                     if (m_options.locations_on_ways) {
                         {
-                            osmium::DeltaEncode<int64_t, int64_t> delta_id;
+                            osmium::DeltaEncode<int64_t, int64_t> delta;
                             protozero::packed_field_sint64 field{pbf_way, protozero::pbf_tag_type(OSMFormat::Way::packed_sint64_lon)};
                             for (const auto& node_ref : way.nodes()) {
-                                field.add_element(delta_id.update(lonlat2int(node_ref.location().lon_without_check())));
+                                field.add_element(delta.update(node_ref.location().x()));
                             }
                         }
                         {
-                            osmium::DeltaEncode<int64_t, int64_t> delta_id;
+                            osmium::DeltaEncode<int64_t, int64_t> delta;
                             protozero::packed_field_sint64 field{pbf_way, protozero::pbf_tag_type(OSMFormat::Way::packed_sint64_lat)};
                             for (const auto& node_ref : way.nodes()) {
-                                field.add_element(delta_id.update(lonlat2int(node_ref.location().lat_without_check())));
+                                field.add_element(delta.update(node_ref.location().y()));
                             }
                         }
                     }
@@ -639,7 +726,7 @@ namespace osmium {
 
                 void relation(const osmium::Relation& relation) {
                     switch_primitive_block_type(OSMFormat::PrimitiveGroup::repeated_Relation_relations);
-                    protozero::pbf_builder<OSMFormat::Relation> pbf_relation{m_primitive_block.group(), OSMFormat::PrimitiveGroup::repeated_Relation_relations};
+                    protozero::pbf_builder<OSMFormat::Relation> pbf_relation{m_primitive_block->group(), OSMFormat::PrimitiveGroup::repeated_Relation_relations};
 
                     pbf_relation.add_int64(OSMFormat::Relation::required_int64_id, relation.id());
                     add_meta(relation, pbf_relation);
@@ -647,7 +734,7 @@ namespace osmium {
                     {
                         protozero::packed_field_int32 field{pbf_relation, protozero::pbf_tag_type(OSMFormat::Relation::packed_int32_roles_sid)};
                         for (const auto& member : relation.members()) {
-                            field.add_element(m_primitive_block.store_in_stringtable(member.role()));
+                            field.add_element(m_primitive_block->store_in_stringtable(member.role()));
                         }
                     }
 
diff --git a/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp b/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
index 6b6dd93b7..c38d25ad2 100644
--- a/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/protobuf_tags.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -42,7 +42,7 @@ namespace osmium {
         namespace detail {
 
             // directly translated from
-            // https://github.com/scrosby/OSM-binary/blob/master/src/fileformat.proto
+            // https://github.com/openstreetmap/OSM-binary/blob/master/src/fileformat.proto
 
             namespace FileFormat {
 
@@ -50,7 +50,9 @@ namespace osmium {
                     optional_bytes_raw       = 1,
                     optional_int32_raw_size  = 2,
                     optional_bytes_zlib_data = 3,
-                    optional_bytes_lzma_data = 4
+                    optional_bytes_lzma_data = 4,
+                    optional_bytes_lz4_data  = 6,
+                    optional_bytes_zstd_data = 7
                 };
 
                 enum class BlobHeader : protozero::pbf_tag_type {
@@ -62,7 +64,7 @@ namespace osmium {
             } // namespace FileFormat
 
             // directly translated from
-            // https://github.com/scrosby/OSM-binary/blob/master/src/osmformat.proto
+            // https://github.com/openstreetmap/OSM-binary/blob/master/src/osmformat.proto
 
             namespace OSMFormat {
 
diff --git a/third_party/libosmium/include/osmium/io/detail/queue_util.hpp b/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
index bee2c03d3..84ac25c22 100644
--- a/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/queue_util.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -93,7 +93,7 @@ namespace osmium {
                 return data.empty();
             }
 
-            inline bool at_end_of_data(osmium::memory::Buffer& buffer) noexcept {
+            inline bool at_end_of_data(const osmium::memory::Buffer& buffer) noexcept {
                 return !buffer;
             }
 
@@ -101,13 +101,11 @@ namespace osmium {
             class queue_wrapper {
 
                 future_queue_type<T>& m_queue;
-                bool m_has_reached_end_of_data;
 
             public:
 
                 explicit queue_wrapper(future_queue_type<T>& queue) :
-                    m_queue(queue),
-                    m_has_reached_end_of_data(false) {
+                    m_queue(queue) {
                 }
 
                 queue_wrapper(const queue_wrapper&) = delete;
@@ -117,32 +115,30 @@ namespace osmium {
                 queue_wrapper& operator=(queue_wrapper&&) = delete;
 
                 ~queue_wrapper() noexcept {
-                    drain();
-                }
-
-                void drain() {
-                    while (!m_has_reached_end_of_data) {
-                        try {
-                            pop();
-                        } catch (...) {
-                            // Ignore any exceptions.
-                        }
+                    try {
+                        shutdown();
+                    } catch (...) {
                     }
                 }
 
+                void shutdown() {
+                    m_queue.shutdown();
+                }
+
                 bool has_reached_end_of_data() const noexcept {
-                    return m_has_reached_end_of_data;
+                    return !m_queue.in_use();
                 }
 
                 T pop() {
                     T data;
-                    if (!m_has_reached_end_of_data) {
+                    if (m_queue.in_use()) {
                         std::future<T> data_future;
                         m_queue.wait_and_pop(data_future);
-                        assert(data_future.valid());
-                        data = std::move(data_future.get());
-                        if (at_end_of_data(data)) {
-                            m_has_reached_end_of_data = true;
+                        if (data_future.valid()) {
+                            data = std::move(data_future.get());
+                            if (at_end_of_data(data)) {
+                                m_queue.shutdown();
+                            }
                         }
                     }
                     return data;
diff --git a/third_party/libosmium/include/osmium/io/detail/read_thread.hpp b/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
index 91f9cd933..a95a7734a 100644
--- a/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/read_thread.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -72,7 +72,7 @@ namespace osmium {
 
                     try {
                         while (!m_done) {
-                            std::string data {m_decompressor.read()};
+                            std::string data{m_decompressor.read()};
                             if (at_end_of_data(data)) {
                                 break;
                             }
diff --git a/third_party/libosmium/include/osmium/io/detail/read_write.hpp b/third_party/libosmium/include/osmium/io/detail/read_write.hpp
index 91ca26983..47ae87570 100644
--- a/third_party/libosmium/include/osmium/io/detail/read_write.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/read_write.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,6 +34,7 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #include <osmium/io/writer_options.hpp>
+#include <osmium/util/file.hpp>
 
 #include <cerrno>
 #include <cstddef>
@@ -41,12 +42,6 @@ DEALINGS IN THE SOFTWARE.
 #include <string>
 #include <system_error>
 
-#ifndef _MSC_VER
-# include <unistd.h>
-#else
-# include <io.h>
-#endif
-
 namespace osmium {
 
     namespace io {
@@ -66,7 +61,11 @@ namespace osmium {
              * @returns File descriptor of open file.
              * @throws system_error if the file can't be opened.
              */
-            inline int open_for_writing(const std::string& filename, osmium::io::overwrite allow_overwrite = osmium::io::overwrite::no) {
+            inline int open_for_writing(const std::string& filename, const osmium::io::overwrite allow_overwrite = osmium::io::overwrite::no) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
                 if (filename.empty() || filename == "-") {
 #ifdef _WIN32
                     _setmode(1, _O_BINARY);
@@ -76,12 +75,12 @@ namespace osmium {
 
                 int flags = O_WRONLY | O_CREAT; // NOLINT(hicpp-signed-bitwise)
                 if (allow_overwrite == osmium::io::overwrite::allow) {
-                    flags |= O_TRUNC;
+                    flags |= O_TRUNC; // NOLINT(hicpp-signed-bitwise)
                 } else {
-                    flags |= O_EXCL;
+                    flags |= O_EXCL; // NOLINT(hicpp-signed-bitwise)
                 }
 #ifdef _WIN32
-                flags |= O_BINARY;
+                flags |= O_BINARY; // NOLINT(hicpp-signed-bitwise)
 #endif
                 const int fd = ::open(filename.c_str(), flags, 0666);
                 if (fd < 0) {
@@ -99,6 +98,10 @@ namespace osmium {
              * @throws system_error if the file can't be opened.
              */
             inline int open_for_reading(const std::string& filename) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
                 if (filename.empty() || filename == "-") {
                     return 0; // stdin
                 }
@@ -125,7 +128,14 @@ namespace osmium {
              * @throws std::system_error On error.
              */
             inline void reliable_write(const int fd, const unsigned char* output_buffer, const size_t size) {
-                constexpr size_t max_write = 100L * 1024L * 1024L; // Max 100 MByte per write
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
+                enum : std::size_t {
+                    // Max 100 MByte per write
+                    max_write = 100UL * 1024UL * 1024UL
+                };
                 size_t offset = 0;
                 do {
                     auto write_count = size - offset;
@@ -170,10 +180,18 @@ namespace osmium {
              * @throws std::system_error On error.
              */
             inline int64_t reliable_read(const int fd, char* input_buffer, const unsigned int size) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
                 int64_t nread = 0;
 
                 do {
+#ifdef _WIN32
+                    nread = _read(fd, input_buffer, size);
+#else
                     nread = ::read(fd, input_buffer, size);
+#endif
                     if (nread < 0 && errno != EINTR) {
                         throw std::system_error{errno, std::system_category(), "Read failed"};
                     }
@@ -183,6 +201,10 @@ namespace osmium {
             }
 
             inline void reliable_fsync(const int fd) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
 #ifdef _WIN32
                 if (_commit(fd) != 0) {
 #else
@@ -193,11 +215,75 @@ namespace osmium {
             }
 
             inline void reliable_close(const int fd) {
+                if (fd < 0) {
+                    return;
+                }
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
+#ifdef _WIN32
+                if (_close(fd) != 0) {
+#else
                 if (::close(fd) != 0) {
+#endif
                     throw std::system_error{errno, std::system_category(), "Close failed"};
                 }
             }
 
+            inline int reliable_dup(const int fd) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+
+#ifdef _WIN32
+                const int fd2 = _dup(fd);
+#else
+                const int fd2 = ::dup(fd);
+#endif
+                if (fd2 < 0) {
+                    throw std::system_error{errno, std::system_category(), "Dup failed"};
+                }
+                return fd2;
+            }
+
+            /**
+             * Tell the kernel to remove all pages from this file from the
+             * buffer cache. Used when reading a large file that will not be
+             * needed again soon. Keeps the buffer cache clear for other
+             * things.
+             */
+#ifdef __linux__
+            inline void remove_buffered_pages(int fd) noexcept {
+                if (fd > 0) {
+                    ::posix_fadvise(fd, 0, 0, POSIX_FADV_DONTNEED);
+                }
+#else
+            inline void remove_buffered_pages(int /*fd*/) noexcept {
+#endif
+            }
+
+            /**
+             * Tell the kernel to remove all pages from this file up to the
+             * specified size from the buffer cache. Used when reading a large
+             * file that will not be needed again soon. Keeps the buffer cache
+             * clear for other things.
+             */
+#ifdef __linux__
+            inline void remove_buffered_pages(int fd, std::size_t size) noexcept {
+                constexpr const std::size_t block_size = 4096;
+                // Make sure to keep the last 10 blocks around, so were are
+                // definitely not removing something which might be needed
+                // again soon.
+                if (fd > 0 && size > 10 * block_size) {
+                    size -= 10 * block_size;
+                    ::posix_fadvise(fd, 0, (size - 1) & ~(block_size - 1), POSIX_FADV_DONTNEED);
+                }
+#else
+            inline void remove_buffered_pages(int /*fd*/, std::size_t /*size*/) noexcept {
+#endif
+            }
+
         } // namespace detail
 
     } // namespace io
diff --git a/third_party/libosmium/include/osmium/io/detail/string_table.hpp b/third_party/libosmium/include/osmium/io/detail/string_table.hpp
index 4d3fb1ff0..7640d866f 100644
--- a/third_party/libosmium/include/osmium/io/detail/string_table.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/string_table.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -134,7 +134,7 @@ namespace osmium {
 
                     const_iterator& operator++() {
                         assert(m_it != m_last);
-                        const auto last_pos = m_it->c_str() + m_it->size();
+                        const auto* const last_pos = m_it->c_str() + m_it->size();
                         while (m_pos != last_pos && *m_pos) {
                             ++m_pos;
                         }
@@ -213,10 +213,10 @@ namespace osmium {
 
                 std::size_t operator()(const char* str) const noexcept {
                     std::size_t hash = 5381;
-                    int c;
+                    int c = 0;
 
-                    while ((c = *str++)) {
-                        hash = ((hash << 5u) + hash) + c; /* hash * 33 + c */
+                    while ((c = static_cast<signed char>(*str++))) { // NOLINT(bugprone-signed-char-misuse,cert-str34-c)
+                        hash = ((hash << 5U) + hash) + c; /* hash * 33 + c */
                     }
 
                     return hash;
@@ -231,7 +231,15 @@ namespace osmium {
                 // make sure it doesn't. If we had max_uncompressed_blob_size
                 // many entries, we are sure they would never fit into a PBF
                 // Blob.
-                static constexpr const uint32_t max_entries = max_uncompressed_blob_size;
+                enum {
+                    max_entries = static_cast<int32_t>(max_uncompressed_blob_size)
+                };
+
+                StringStore m_strings;
+                std::unordered_map<const char*, int32_t, djb2_hash, str_equal> m_index;
+                int32_t m_size = 0;
+
+            public:
 
                 // There is one string table per PBF primitive block. Most of
                 // them are really small, because most blocks are full of nodes
@@ -240,34 +248,33 @@ namespace osmium {
                 // The chosen size is enough so that 99% of all string tables
                 // in typical OSM files will only need a single memory
                 // allocation.
-                static constexpr const size_t default_stringtable_chunk_size = 100 * 1024;
+                enum {
+                    default_stringtable_chunk_size = 100U * 1024U
+                };
 
-                StringStore m_strings;
-                std::unordered_map<const char*, size_t, djb2_hash, str_equal> m_index;
-                uint32_t m_size = 0;
+                // Minimum bucket count for hash.
+                enum {
+                    min_bucket_count = 1
+                };
 
-            public:
-
-                explicit StringTable(size_t size = default_stringtable_chunk_size) :
-                    m_strings(size) {
+                explicit StringTable(size_t size = default_stringtable_chunk_size, size_t bucket_count = min_bucket_count) :
+                    m_strings(size),
+                    m_index(bucket_count) {
                     m_strings.add("");
                 }
 
-                void clear() {
-                    m_strings.clear();
-                    m_index.clear();
-                    m_size = 0;
-                    m_strings.add("");
-                }
-
-                uint32_t size() const noexcept {
+                int32_t size() const noexcept {
                     return m_size + 1;
                 }
 
-                uint32_t add(const char* s) {
+                std::size_t get_bucket_count() const noexcept {
+                    return m_index.bucket_count();
+                }
+
+                int32_t add(const char* s) {
                     const auto f = m_index.find(s);
                     if (f != m_index.end()) {
-                        return uint32_t(f->second);
+                        return f->second;
                     }
 
                     const char* cs = m_strings.add(s);
diff --git a/third_party/libosmium/include/osmium/io/detail/string_util.hpp b/third_party/libosmium/include/osmium/io/detail/string_util.hpp
index c42761e6d..f9b856694 100644
--- a/third_party/libosmium/include/osmium/io/detail/string_util.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/string_util.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,12 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <utf8.h>
-
 #include <cassert>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
+#include <stdexcept>
 #include <string>
 #include <utility>
 
@@ -56,16 +55,14 @@ namespace osmium {
 
             template <typename... TArgs>
             inline int string_snprintf(std::string& out,
-                                       size_t old_size,
-                                       size_t max_size,
+                                       const std::size_t old_size,
+                                       const std::size_t max_size,
                                        const char* format,
-                                       TArgs&&... args) {
+                                       TArgs... args) {
                 out.resize(old_size + max_size);
 
-                return SNPRINTF(max_size ? const_cast<char*>(out.c_str()) + old_size : nullptr,
-                                max_size,
-                                format,
-                                std::forward<TArgs>(args)...);
+                return SNPRINTF(max_size ? &out[old_size] : nullptr,
+                                max_size, format, args...);
             }
 
 #undef SNPRINTF
@@ -82,8 +79,8 @@ namespace osmium {
              */
             template <typename... TArgs>
             inline void append_printf_formatted_string(std::string& out,
-                                                   const char* format,
-                                                   TArgs&&... args) {
+                                                       const char* format,
+                                                       TArgs... args) {
 
                 // First try to write string with the max_size, if that doesn't
                 // work snprintf will tell us how much space it needs. We
@@ -96,62 +93,122 @@ namespace osmium {
                 // pointer. So we have to take this into account.
 
 #ifndef _MSC_VER
-                static const size_t max_size = 100;
+                static const std::size_t max_size = 100;
 #else
-                static const size_t max_size = 0;
+                static const std::size_t max_size = 0;
 #endif
 
-                const size_t old_size = out.size();
+                const std::size_t old_size = out.size();
 
                 const int len = string_snprintf(out,
                                                 old_size,
                                                 max_size,
                                                 format,
-                                                std::forward<TArgs>(args)...);
+                                                args...);
                 assert(len > 0);
 
-                if (size_t(len) >= max_size) {
+                if (static_cast<std::size_t>(len) >= max_size) {
 #ifndef NDEBUG
                     const int len2 =
 #endif
                                      string_snprintf(out,
                                                      old_size,
-                                                     size_t(len) + 1,
+                                                     std::size_t(len) + 1,
                                                      format,
-                                                     std::forward<TArgs>(args)...);
+                                                     args...);
                     assert(len2 == len);
                 }
 
-                out.resize(old_size + size_t(len));
+                out.resize(old_size + static_cast<std::size_t>(len));
+            }
+
+            inline uint8_t utf8_sequence_length(uint32_t first) noexcept {
+                if (first < 0x80U) {
+                    return 1U;
+                }
+
+                if ((first >> 5U) == 0x6U) {
+                    return 2U;
+                }
+
+                if ((first >> 4U) == 0xeU) {
+                    return 3U;
+                }
+
+                if ((first >> 3U) == 0x1eU) {
+                    return 4U;
+                }
+
+                return 0;
+            }
+
+            inline uint32_t next_utf8_codepoint(char const** begin, const char* end) {
+                const auto* it = reinterpret_cast<const uint8_t*>(*begin);
+                uint32_t cp = 0xffU & *it;
+                const auto length = utf8_sequence_length(cp);
+                if (length == 0) {
+                    throw std::runtime_error{"invalid Unicode codepoint"};
+                }
+                if (std::distance(it, reinterpret_cast<const uint8_t*>(end)) < length) {
+                    throw std::out_of_range{"incomplete Unicode codepoint"};
+                }
+                switch (length) {
+                    case 1:
+                        break;
+                    case 2:
+                        ++it;
+                        cp = ((cp << 6U) & 0x7ffU) + ((*it) & 0x3fU);
+                        break;
+                    case 3:
+                        ++it;
+                        cp = ((cp << 12U) & 0xffffU) + (((0xffU & *it) << 6U) & 0xfffU);
+                        ++it;
+                        cp += (*it) & 0x3fU;
+                        break;
+                    case 4:
+                        ++it;
+                        cp = ((cp << 18U) & 0x1fffffU) + (((0xffU & *it) << 12U) & 0x3ffffU);
+                        ++it;
+                        cp += ((0xffU & *it) << 6U) & 0xfffU;
+                        ++it;
+                        cp += (*it) & 0x3fU;
+                        break;
+                    default:
+                        break;
+                }
+                ++it;
+                *begin = reinterpret_cast<const char*>(it);
+                return cp;
             }
 
             // Write out the value with exactly two hex digits.
             inline void append_2_hex_digits(std::string& out, uint32_t value, const char* const hex_digits) {
-                out += hex_digits[(value >> 4u) & 0xfu];
-                out += hex_digits[ value        & 0xfu];
+                out += hex_digits[(value >> 4U) & 0xfU];
+                out += hex_digits[ value        & 0xfU];
             }
 
             // Write out the value with four or more hex digits.
             inline void append_min_4_hex_digits(std::string& out, uint32_t value, const char* const hex_digits) {
                 auto
-                v = value & 0xf0000000u; if (v) { out += hex_digits[v >> 28u]; }
-                v = value & 0x0f000000u; if (v) { out += hex_digits[v >> 24u]; }
-                v = value & 0x00f00000u; if (v) { out += hex_digits[v >> 20u]; }
-                v = value & 0x000f0000u; if (v) { out += hex_digits[v >> 16u]; }
+                v = value & 0xf0000000U; if (v) { out += hex_digits[v >> 28U]; }
+                v = value & 0x0f000000U; if (v) { out += hex_digits[v >> 24U]; }
+                v = value & 0x00f00000U; if (v) { out += hex_digits[v >> 20U]; }
+                v = value & 0x000f0000U; if (v) { out += hex_digits[v >> 16U]; }
 
-                out += hex_digits[(value >> 12u) & 0xfu];
-                out += hex_digits[(value >>  8u) & 0xfu];
-                out += hex_digits[(value >>  4u) & 0xfu];
-                out += hex_digits[ value         & 0xfu];
+                out += hex_digits[(value >> 12U) & 0xfU];
+                out += hex_digits[(value >>  8U) & 0xfU];
+                out += hex_digits[(value >>  4U) & 0xfU];
+                out += hex_digits[ value         & 0xfU];
             }
 
             inline void append_utf8_encoded_string(std::string& out, const char* data) {
                 static const char* lookup_hex = "0123456789abcdef";
-                const char* end = data + std::strlen(data);
+                assert(data);
+                const char* end_ptr = data + std::strlen(data);
 
-                while (data != end) {
-                    const char* last = data;
-                    const uint32_t c = utf8::next(data, end);
+                while (data != end_ptr) {
+                    const char* prev = data;
+                    const uint32_t c = next_utf8_codepoint(&data, end_ptr);
 
                     // This is a list of Unicode code points that we let
                     // through instead of escaping them. It is incomplete
@@ -166,7 +223,7 @@ namespace osmium {
                         (0x0041 <= c && c <= 0x007e) ||
                         (0x00a1 <= c && c <= 0x00ac) ||
                         (0x00ae <= c && c <= 0x05ff)) {
-                        out.append(last, data);
+                        out.append(prev, data);
                     } else {
                         out += '%';
                         if (c <= 0xff) {
@@ -180,6 +237,7 @@ namespace osmium {
             }
 
             inline void append_xml_encoded_string(std::string& out, const char* data) {
+                assert(data);
                 for (; *data != '\0'; ++data) {
                     switch (*data) {
                         case '&':  out += "&amp;";  break;
@@ -197,11 +255,11 @@ namespace osmium {
 
             inline void append_debug_encoded_string(std::string& out, const char* data, const char* prefix, const char* suffix) {
                 static const char* lookup_hex = "0123456789ABCDEF";
-                const char* end = data + std::strlen(data);
+                const char* end_ptr = data + std::strlen(data);
 
-                while (data != end) {
-                    const char* last = data;
-                    uint32_t c = utf8::next(data, end);
+                while (data != end_ptr) {
+                    const char* prev = data;
+                    uint32_t c = next_utf8_codepoint(&data, end_ptr);
 
                     // This is a list of Unicode code points that we let
                     // through instead of escaping them. It is incomplete
@@ -214,7 +272,7 @@ namespace osmium {
                         (0x003f <= c && c <= 0x007e) ||
                         (0x00a1 <= c && c <= 0x00ac) ||
                         (0x00ae <= c && c <= 0x05ff)) {
-                        out.append(last, data);
+                        out.append(prev, data);
                     } else {
                         out.append(prefix);
                         out.append("<U+");
@@ -225,6 +283,26 @@ namespace osmium {
                 }
             }
 
+            template <typename TOutputIterator>
+            TOutputIterator append_codepoint_as_utf8(uint32_t cp, TOutputIterator out) {
+                if (cp < 0x80UL) {
+                    *(out++) = static_cast<char>(cp);
+                } else if (cp < 0x800UL) {
+                    *(out++) = static_cast<char>( (cp >>  6U)          | 0xc0U);
+                    *(out++) = static_cast<char>(( cp         & 0x3fU) | 0x80U);
+                } else if (cp < 0x10000UL) {
+                    *(out++) = static_cast<char>( (cp >> 12U)          | 0xe0U);
+                    *(out++) = static_cast<char>(((cp >>  6U) & 0x3fU) | 0x80U);
+                    *(out++) = static_cast<char>(( cp         & 0x3fU) | 0x80U);
+                } else {
+                    *(out++) = static_cast<char>( (cp >> 18U)          | 0xf0U);
+                    *(out++) = static_cast<char>(((cp >> 12U) & 0x3fU) | 0x80U);
+                    *(out++) = static_cast<char>(((cp >>  6U) & 0x3fU) | 0x80U);
+                    *(out++) = static_cast<char>(( cp         & 0x3fU) | 0x80U);
+                }
+                return out;
+            }
+
         } // namespace detail
 
     } // namespace io
diff --git a/third_party/libosmium/include/osmium/io/detail/write_thread.hpp b/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
index 810543dc6..ec0c10752 100644
--- a/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/write_thread.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -58,16 +58,19 @@ namespace osmium {
 
                 queue_wrapper<std::string> m_queue;
                 std::unique_ptr<osmium::io::Compressor> m_compressor;
-                std::promise<bool> m_promise;
+                std::promise<std::size_t> m_promise;
+                std::atomic_bool* m_notification;
 
             public:
 
                 WriteThread(future_string_queue_type& input_queue,
                             std::unique_ptr<osmium::io::Compressor>&& compressor,
-                            std::promise<bool>&& promise) :
+                            std::promise<std::size_t>&& promise,
+                            std::atomic_bool* notification) :
                     m_queue(input_queue),
                     m_compressor(std::move(compressor)),
-                    m_promise(std::move(promise)) {
+                    m_promise(std::move(promise)),
+                    m_notification(notification) {
                 }
 
                 WriteThread(const WriteThread&) = delete;
@@ -90,10 +93,11 @@ namespace osmium {
                             m_compressor->write(data);
                         }
                         m_compressor->close();
-                        m_promise.set_value(true);
+                        m_promise.set_value(m_compressor->file_size());
                     } catch (...) {
+                        m_notification->store(true);
                         m_promise.set_exception(std::current_exception());
-                        m_queue.drain();
+                        m_queue.shutdown();
                     }
                 }
 
diff --git a/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp b/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
index 6007a9dae..0025c255a 100644
--- a/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/xml_input_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -60,6 +60,7 @@ DEALINGS IN THE SOFTWARE.
 
 #include <cassert>
 #include <cstring>
+#include <exception>
 #include <future>
 #include <limits>
 #include <memory>
@@ -124,9 +125,7 @@ namespace osmium {
 
         namespace detail {
 
-            class XMLParser : public Parser {
-
-                static constexpr std::size_t buffer_size = 2 * 1000 * 1000;
+            class XMLParser final : public ParserWithBuffer {
 
                 enum class context {
                     osm,
@@ -145,6 +144,7 @@ namespace osmium {
                     discussion,
                     comment,
                     text,
+                    obj_bbox,
                     other
                 }; // enum class context
 
@@ -152,8 +152,6 @@ namespace osmium {
 
                 osmium::io::Header m_header{};
 
-                osmium::memory::Buffer m_buffer;
-
                 std::unique_ptr<osmium::builder::NodeBuilder>                m_node_builder{};
                 std::unique_ptr<osmium::builder::WayBuilder>                 m_way_builder{};
                 std::unique_ptr<osmium::builder::RelationBuilder>            m_relation_builder{};
@@ -173,17 +171,44 @@ namespace osmium {
                 class ExpatXMLParser {
 
                     XML_Parser m_parser;
+                    std::exception_ptr m_exception_ptr{}; // NOLINT(bugprone-throw-keyword-missing) see https://bugs.llvm.org/show_bug.cgi?id=52400
 
-                    static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) {
-                        static_cast<XMLParser*>(data)->start_element(element, attrs);
+                    template <typename TFunc>
+                    void member_wrap(XMLParser& xml_parser, TFunc&& func) noexcept {
+                        if (m_exception_ptr) {
+                            return;
+                        }
+                        try {
+                            func(xml_parser);
+                        } catch (...) {
+                            m_exception_ptr = std::current_exception();
+                            XML_StopParser(m_parser, 0);
+                        }
                     }
 
-                    static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) {
-                        static_cast<XMLParser*>(data)->end_element(element);
+                    template <typename TFunc>
+                    static void wrap(void* data, TFunc&& func) noexcept {
+                        assert(data);
+                        auto& xml_parser = *static_cast<XMLParser*>(data);
+                        xml_parser.m_expat_xml_parser->member_wrap(xml_parser, std::forward<TFunc>(func));
                     }
 
-                    static void XMLCALL character_data_wrapper(void* data, const XML_Char* text, int len) {
-                        static_cast<XMLParser*>(data)->characters(text, len);
+                    static void XMLCALL start_element_wrapper(void* data, const XML_Char* element, const XML_Char** attrs) noexcept {
+                        wrap(data, [&](XMLParser& xml_parser) {
+                            xml_parser.start_element(element, attrs);
+                        });
+                    }
+
+                    static void XMLCALL end_element_wrapper(void* data, const XML_Char* element) noexcept {
+                        wrap(data, [&](XMLParser& xml_parser) {
+                            xml_parser.end_element(element);
+                        });
+                    }
+
+                    static void XMLCALL character_data_wrapper(void* data, const XML_Char* text, int len) noexcept {
+                        wrap(data, [&](XMLParser& xml_parser) {
+                            xml_parser.characters(text, len);
+                        });
                     }
 
                     // This handler is called when there are any XML entities
@@ -191,7 +216,7 @@ namespace osmium {
                     // but they can be misused. See
                     // https://en.wikipedia.org/wiki/Billion_laughs
                     // The handler will just throw an error.
-                    static void entity_declaration_handler(void* /*userData*/,
+                    static void entity_declaration_handler(void* data,
                             const XML_Char* /*entityName*/,
                             int /*is_parameter_entity*/,
                             const XML_Char* /*value*/,
@@ -199,8 +224,10 @@ namespace osmium {
                             const XML_Char* /*base*/,
                             const XML_Char* /*systemId*/,
                             const XML_Char* /*publicId*/,
-                            const XML_Char* /*notationName*/) {
-                        throw osmium::xml_error{"XML entities are not supported"};
+                            const XML_Char* /*notationName*/) noexcept {
+                        wrap(data, [&](XMLParser& /*xml_parser*/) {
+                            throw osmium::xml_error{"XML entities are not supported"};
+                        });
                     }
 
                 public:
@@ -229,16 +256,21 @@ namespace osmium {
                     void operator()(const std::string& data, bool last) {
                         assert(data.size() < std::numeric_limits<int>::max());
                         if (XML_Parse(m_parser, data.data(), static_cast<int>(data.size()), last) == XML_STATUS_ERROR) {
+                            if (m_exception_ptr) {
+                                std::rethrow_exception(m_exception_ptr);
+                            }
                             throw osmium::xml_error{m_parser};
                         }
                     }
 
                 }; // class ExpatXMLParser
 
+                ExpatXMLParser* m_expat_xml_parser{nullptr};
+
                 template <typename T>
                 static void check_attributes(const XML_Char** attrs, T&& check) {
                     while (*attrs) {
-                        std::forward<T>(check)(attrs[0], attrs[1]);
+                        check(attrs[0], attrs[1]);
                         attrs += 2;
                     }
                 }
@@ -271,7 +303,7 @@ namespace osmium {
                     return user;
                 }
 
-                void init_changeset(osmium::builder::ChangesetBuilder& builder, const XML_Char** attrs) {
+                static void init_changeset(osmium::builder::ChangesetBuilder& builder, const XML_Char** attrs) {
                     osmium::Box box;
 
                     check_attributes(attrs, [&builder, &box](const XML_Char* name, const XML_Char* value) {
@@ -318,7 +350,7 @@ namespace osmium {
                 void top_level_element(const XML_Char* element, const XML_Char** attrs) {
                     if (!std::strcmp(element, "osm")) {
                         m_context_stack.push_back(context::osm);
-                    } else if (!std::strcmp(element, "osmChange")){
+                    } else if (!std::strcmp(element, "osmChange")) {
                         m_context_stack.push_back(context::osmChange);
                         m_header.set_has_multiple_object_versions(true);
                     } else {
@@ -333,6 +365,8 @@ namespace osmium {
                             }
                         } else if (!std::strcmp(name, "generator")) {
                             m_header.set("generator", value);
+                        } else if (!std::strcmp(name, "upload")) {
+                            m_header.set("xml_josm_upload", value);
                         }
                         // ignore other attributes
                     });
@@ -356,7 +390,8 @@ namespace osmium {
                         m_context_stack.push_back(context::node);
                         mark_header_as_done();
                         if (read_types() & osmium::osm_entity_bits::node) {
-                            m_node_builder.reset(new osmium::builder::NodeBuilder{m_buffer});
+                            maybe_new_buffer(osmium::item_type::node);
+                            m_node_builder.reset(new osmium::builder::NodeBuilder{buffer()});
                             m_node_builder->set_user(init_object(m_node_builder->object(), attrs));
                         }
                         return;
@@ -366,7 +401,8 @@ namespace osmium {
                         m_context_stack.push_back(context::way);
                         mark_header_as_done();
                         if (read_types() & osmium::osm_entity_bits::way) {
-                            m_way_builder.reset(new osmium::builder::WayBuilder{m_buffer});
+                            maybe_new_buffer(osmium::item_type::way);
+                            m_way_builder.reset(new osmium::builder::WayBuilder{buffer()});
                             m_way_builder->set_user(init_object(m_way_builder->object(), attrs));
                         }
                         return;
@@ -376,7 +412,8 @@ namespace osmium {
                         m_context_stack.push_back(context::relation);
                         mark_header_as_done();
                         if (read_types() & osmium::osm_entity_bits::relation) {
-                            m_relation_builder.reset(new osmium::builder::RelationBuilder{m_buffer});
+                            maybe_new_buffer(osmium::item_type::relation);
+                            m_relation_builder.reset(new osmium::builder::RelationBuilder{buffer()});
                             m_relation_builder->set_user(init_object(m_relation_builder->object(), attrs));
                         }
                         return;
@@ -390,7 +427,8 @@ namespace osmium {
                         m_context_stack.push_back(context::changeset);
                         mark_header_as_done();
                         if (read_types() & osmium::osm_entity_bits::changeset) {
-                            m_changeset_builder.reset(new osmium::builder::ChangesetBuilder{m_buffer});
+                            maybe_new_buffer(osmium::item_type::changeset);
+                            m_changeset_builder.reset(new osmium::builder::ChangesetBuilder{buffer()});
                             init_changeset(*m_changeset_builder, attrs);
                         }
                     } else if (!std::strcmp(element, "create")) {
@@ -491,6 +529,8 @@ namespace osmium {
                                     m_wnl_builder.reset();
                                     get_tag(*m_way_builder, attrs);
                                 }
+                            } else if (!std::strcmp(element, "bbox") || !std::strcmp(element, "bounds")) {
+                                m_context_stack.push_back(context::obj_bbox);
                             } else {
                                 throw xml_error{std::string{"Unknown element in <way>: "} + element};
                             }
@@ -533,6 +573,8 @@ namespace osmium {
                                     m_rml_builder.reset();
                                     get_tag(*m_relation_builder, attrs);
                                 }
+                            } else if (!std::strcmp(element, "bbox") || !std::strcmp(element, "bounds")) {
+                                m_context_stack.push_back(context::obj_bbox);
                             } else {
                                 throw xml_error{std::string{"Unknown element in <relation>: "} + element};
                             }
@@ -595,12 +637,18 @@ namespace osmium {
                             throw osmium::xml_error{"No element in <text> allowed"};
                         case context::bounds:
                             throw osmium::xml_error{"No element in <bounds> allowed"};
+                        case context::obj_bbox:
+                            throw osmium::xml_error{"No element in <bbox>/<bounds> allowed"};
                         case context::other:
                             throw xml_error{"xml file nested too deep"};
                     }
                 }
 
+#ifdef NDEBUG
+                void end_element(const XML_Char* /*element*/) {
+#else
                 void end_element(const XML_Char* element) {
+#endif
                     assert(!m_context_stack.empty());
                     switch (m_context_stack.back()) {
                         case context::osm:
@@ -625,8 +673,8 @@ namespace osmium {
                             if (read_types() & osmium::osm_entity_bits::node) {
                                 m_tl_builder.reset();
                                 m_node_builder.reset();
-                                m_buffer.commit();
-                                flush_buffer();
+                                buffer().commit();
+                                flush_nested_buffer();
                             }
                             break;
                         case context::way:
@@ -635,8 +683,8 @@ namespace osmium {
                                 m_tl_builder.reset();
                                 m_wnl_builder.reset();
                                 m_way_builder.reset();
-                                m_buffer.commit();
-                                flush_buffer();
+                                buffer().commit();
+                                flush_nested_buffer();
                             }
                             break;
                         case context::relation:
@@ -645,8 +693,8 @@ namespace osmium {
                                 m_tl_builder.reset();
                                 m_rml_builder.reset();
                                 m_relation_builder.reset();
-                                m_buffer.commit();
-                                flush_buffer();
+                                buffer().commit();
+                                flush_nested_buffer();
                             }
                             break;
                         case context::tag:
@@ -661,8 +709,8 @@ namespace osmium {
                                 m_tl_builder.reset();
                                 m_changeset_discussion_builder.reset();
                                 m_changeset_builder.reset();
-                                m_buffer.commit();
-                                flush_buffer();
+                                buffer().commit();
+                                flush_nested_buffer();
                             }
                             break;
                         case context::discussion:
@@ -681,6 +729,9 @@ namespace osmium {
                         case context::bounds:
                             assert(!std::strcmp(element, "bounds"));
                             break;
+                        case context::obj_bbox:
+                            assert(!std::strcmp(element, "bbox") || !std::strcmp(element, "bounds"));
+                            break;
                         case context::other:
                             break;
                     }
@@ -695,20 +746,10 @@ namespace osmium {
                     }
                 }
 
-                void flush_buffer() {
-                    if (m_buffer.committed() > buffer_size / 10 * 9) {
-                        send_to_output_queue(std::move(m_buffer));
-                        osmium::memory::Buffer buffer{buffer_size};
-                        using std::swap;
-                        swap(m_buffer, buffer);
-                    }
-                }
-
             public:
 
                 explicit XMLParser(parser_arguments& args) :
-                    Parser(args),
-                    m_buffer(buffer_size) {
+                    ParserWithBuffer(args) {
                 }
 
                 XMLParser(const XMLParser&) = delete;
@@ -717,12 +758,13 @@ namespace osmium {
                 XMLParser(XMLParser&&) = delete;
                 XMLParser& operator=(XMLParser&&) = delete;
 
-                ~XMLParser() noexcept final = default;
+                ~XMLParser() noexcept override = default;
 
-                void run() final {
+                void run() override {
                     osmium::thread::set_thread_name("_osmium_xml_in");
 
                     ExpatXMLParser parser{this};
+                    m_expat_xml_parser = &parser;
 
                     while (!input_done()) {
                         const std::string data{get_input()};
@@ -733,10 +775,7 @@ namespace osmium {
                     }
 
                     mark_header_as_done();
-
-                    if (m_buffer.committed() > 0) {
-                        send_to_output_queue(std::move(m_buffer));
-                    }
+                    flush_final_buffer();
                 }
 
             }; // class XMLParser
diff --git a/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp b/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
index fa0c9edf1..e6f285ad4 100644
--- a/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/xml_output_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -116,7 +116,7 @@ namespace osmium {
                     op_delete = 3
                 }; // enum class operation
 
-                operation m_last_op {operation::op_none};
+                operation m_last_op{operation::op_none};
 
                 xml_output_options m_options;
 
@@ -126,7 +126,7 @@ namespace osmium {
                     }
                 }
 
-                int prefix_spaces() {
+                int prefix_spaces() const noexcept {
                     return m_options.use_change_ops ? 4 : 2;
                 }
 
@@ -152,7 +152,7 @@ namespace osmium {
 
                     if (m_options.add_metadata.timestamp() && object.timestamp()) {
                         *m_out += " timestamp=\"";
-                        *m_out += object.timestamp().to_iso();
+                        *m_out += object.timestamp().to_iso_all();
                         *m_out += "\"";
                     }
 
@@ -198,7 +198,7 @@ namespace osmium {
                         *m_out += " user=\"";
                         append_xml_encoded_string(*m_out, comment.user());
                         *m_out += "\" date=\"";
-                        *m_out += comment.date().to_iso();
+                        *m_out += comment.date().to_iso_all();
                         *m_out += "\">\n";
                         *m_out += "    <text>";
                         append_xml_encoded_string(*m_out, comment.text());
diff --git a/third_party/libosmium/include/osmium/io/detail/zlib.hpp b/third_party/libosmium/include/osmium/io/detail/zlib.hpp
index 925966c12..260b86a11 100644
--- a/third_party/libosmium/include/osmium/io/detail/zlib.hpp
+++ b/third_party/libosmium/include/osmium/io/detail/zlib.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -55,6 +55,16 @@ namespace osmium {
 
         namespace detail {
 
+            constexpr inline int zlib_default_compression_level() noexcept {
+                return Z_DEFAULT_COMPRESSION;
+            }
+
+            inline void zlib_check_compression_level(int value) {
+                if (value < 0 || value > 9) {
+                    throw std::invalid_argument{"The 'pbf_compression_level' for zlib compression must be between 0 and 9."};
+                }
+            }
+
             /**
              * Compress data using zlib.
              *
@@ -62,20 +72,21 @@ namespace osmium {
              * what fits in an unsigned long, on Windows this is usually 32bit.
              *
              * @param input Data to compress.
+             * @param compression_level Compression level.
              * @returns Compressed data.
              */
-            inline std::string zlib_compress(const std::string& input) {
+            inline std::string zlib_compress(const std::string& input, int compression_level = Z_DEFAULT_COMPRESSION) {
                 assert(input.size() < std::numeric_limits<unsigned long>::max());
                 unsigned long output_size = ::compressBound(static_cast<unsigned long>(input.size())); // NOLINT(google-runtime-int)
 
                 std::string output(output_size, '\0');
 
-                const auto result = ::compress(
-                    reinterpret_cast<unsigned char*>(const_cast<char *>(output.data())),
+                const auto result = ::compress2(
+                    reinterpret_cast<unsigned char*>(&*output.begin()),
                     &output_size,
                     reinterpret_cast<const unsigned char*>(input.data()),
-                    static_cast<unsigned long>(input.size()) // NOLINT(google-runtime-int)
-                );
+                    static_cast<unsigned long>(input.size()), // NOLINT(google-runtime-int)
+                    compression_level);
 
                 if (result != Z_OK) {
                     throw io_error{std::string{"failed to compress data: "} + zError(result)};
@@ -104,8 +115,7 @@ namespace osmium {
                     reinterpret_cast<unsigned char*>(&*output.begin()),
                     &raw_size,
                     reinterpret_cast<const unsigned char*>(input),
-                    input_size
-                );
+                    input_size);
 
                 if (result != Z_OK) {
                     throw io_error{std::string{"failed to uncompress data: "} + zError(result)};
diff --git a/third_party/libosmium/include/osmium/io/error.hpp b/third_party/libosmium/include/osmium/io/error.hpp
index 742df53b3..57c2b5e65 100644
--- a/third_party/libosmium/include/osmium/io/error.hpp
+++ b/third_party/libosmium/include/osmium/io/error.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+
 #include <stdexcept>
 #include <string>
 
@@ -41,7 +43,7 @@ namespace osmium {
     /**
      * Exception thrown when some kind of input/output operation failed.
      */
-    struct io_error : public std::runtime_error {
+    struct OSMIUM_EXPORT io_error : public std::runtime_error {
 
         explicit io_error(const std::string& what) :
             std::runtime_error(what) {
diff --git a/third_party/libosmium/include/osmium/io/file.hpp b/third_party/libosmium/include/osmium/io/file.hpp
index 5bfd4ff07..54c42a1a8 100644
--- a/third_party/libosmium/include/osmium/io/file.hpp
+++ b/third_party/libosmium/include/osmium/io/file.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -225,6 +225,9 @@ namespace osmium {
                 } else if (suffixes.back() == "blackhole") {
                     m_file_format = file_format::blackhole;
                     suffixes.pop_back();
+                } else if (suffixes.back() == "ids") {
+                    m_file_format = file_format::ids;
+                    suffixes.pop_back();
                 }
 
                 if (suffixes.empty()) {
diff --git a/third_party/libosmium/include/osmium/io/file_compression.hpp b/third_party/libosmium/include/osmium/io/file_compression.hpp
index 11ea70d94..a17659fcc 100644
--- a/third_party/libosmium/include/osmium/io/file_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/file_compression.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/file_format.hpp b/third_party/libosmium/include/osmium/io/file_format.hpp
index 4c5b3af2c..f02031c7a 100644
--- a/third_party/libosmium/include/osmium/io/file_format.hpp
+++ b/third_party/libosmium/include/osmium/io/file_format.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -48,7 +48,8 @@ namespace osmium {
             o5m       = 5,
             debug     = 6,
             blackhole = 7,
-            last      = 7 // must have the same value as the last real value
+            ids       = 8,
+            last      = 8 // must have the same value as the last real value
         };
 
         enum class read_meta {
@@ -56,6 +57,11 @@ namespace osmium {
             yes = 1
         };
 
+        enum class buffers_type {
+            any    = 0,
+            single = 1
+        };
+
         inline const char* as_string(const file_format format) noexcept {
             switch (format) {
                 case file_format::xml:
@@ -72,6 +78,8 @@ namespace osmium {
                     return "DEBUG";
                 case file_format::blackhole:
                     return "BLACKHOLE";
+                case file_format::ids:
+                    return "IDS";
                 default: // file_format::unknown
                     break;
             }
diff --git a/third_party/libosmium/include/osmium/io/gzip_compression.hpp b/third_party/libosmium/include/osmium/io/gzip_compression.hpp
index 687f7be29..47e488390 100644
--- a/third_party/libosmium/include/osmium/io/gzip_compression.hpp
+++ b/third_party/libosmium/include/osmium/io/gzip_compression.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,7 +36,7 @@ DEALINGS IN THE SOFTWARE.
 /**
  * @file
  *
- * Include this file if you want to read or write gzip-compressed OSM XML
+ * Include this file if you want to read or write gzip-compressed OSM
  * files.
  *
  * @attention If you include this file, you'll need to link with `libz`.
@@ -47,7 +47,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/error.hpp>
 #include <osmium/io/file_compression.hpp>
 #include <osmium/io/writer_options.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <zlib.h>
 
@@ -69,13 +68,19 @@ namespace osmium {
      */
     struct gzip_error : public io_error {
 
-        int gzip_error_code;
-        int system_errno;
+        int gzip_error_code = 0;
+        int system_errno = 0;
 
-        gzip_error(const std::string& what, int error_code) :
+        explicit gzip_error(const std::string& what) :
+            io_error(what) {
+        }
+
+        gzip_error(const std::string& what, const int error_code) :
             io_error(what),
-            gzip_error_code(error_code),
-            system_errno(error_code == Z_ERRNO ? errno : 0) {
+            gzip_error_code(error_code) {
+            if (error_code == Z_ERRNO) {
+                system_errno = errno;
+            }
         }
 
     }; // struct gzip_error
@@ -84,34 +89,36 @@ namespace osmium {
 
         namespace detail {
 
-            OSMIUM_NORETURN inline void throw_gzip_error(gzFile gzfile, const char* msg, int zlib_error = 0) {
+            [[noreturn]] inline void throw_gzip_error(gzFile gzfile, const char* msg) {
                 std::string error{"gzip error: "};
                 error += msg;
                 error += ": ";
-                int errnum = zlib_error;
-                if (zlib_error) {
-                    error += std::to_string(zlib_error);
-                } else {
-                    error += ::gzerror(gzfile, &errnum);
+                int error_code = 0;
+                if (gzfile) {
+                    error += ::gzerror(gzfile, &error_code);
                 }
-                throw osmium::gzip_error{error, errnum};
+                throw osmium::gzip_error{error, error_code};
             }
 
         } // namespace detail
 
-        class GzipCompressor : public Compressor {
+        class GzipCompressor final : public Compressor {
 
+            std::size_t m_file_size = 0;
             int m_fd;
             gzFile m_gzfile;
 
         public:
 
-            explicit GzipCompressor(int fd, fsync sync) :
+            explicit GzipCompressor(const int fd, const fsync sync) :
                 Compressor(sync),
-                m_fd(::dup(fd)),
-                m_gzfile(::gzdopen(fd, "w")) {
+                m_fd(fd) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                m_gzfile = ::gzdopen(osmium::io::detail::reliable_dup(fd), "wb");
                 if (!m_gzfile) {
-                    detail::throw_gzip_error(m_gzfile, "write initialization failed");
+                    throw gzip_error{"gzip error: write initialization failed"};
                 }
             }
 
@@ -121,7 +128,7 @@ namespace osmium {
             GzipCompressor(GzipCompressor&&) = delete;
             GzipCompressor& operator=(GzipCompressor&&) = delete;
 
-            ~GzipCompressor() noexcept final {
+            ~GzipCompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -129,9 +136,13 @@ namespace osmium {
                 }
             }
 
-            void write(const std::string& data) final {
+            void write(const std::string& data) override {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                assert(m_gzfile);
+                assert(data.size() < std::numeric_limits<unsigned int>::max());
                 if (!data.empty()) {
-                    assert(data.size() < std::numeric_limits<unsigned int>::max());
                     const int nwrite = ::gzwrite(m_gzfile, data.data(), static_cast<unsigned int>(data.size()));
                     if (nwrite == 0) {
                         detail::throw_gzip_error(m_gzfile, "write failed");
@@ -139,13 +150,24 @@ namespace osmium {
                 }
             }
 
-            void close() final {
+            void close() override {
                 if (m_gzfile) {
-                    const int result = ::gzclose(m_gzfile);
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    const int result = ::gzclose_w(m_gzfile);
                     m_gzfile = nullptr;
                     if (result != Z_OK) {
-                        detail::throw_gzip_error(m_gzfile, "write close failed", result);
+                        throw gzip_error{"gzip error: write close failed", result};
                     }
+
+                    // Do not sync or close stdout
+                    if (m_fd == 1) {
+                        return;
+                    }
+
+                    m_file_size = osmium::file_size(m_fd);
+
                     if (do_fsync()) {
                         osmium::io::detail::reliable_fsync(m_fd);
                     }
@@ -153,18 +175,30 @@ namespace osmium {
                 }
             }
 
+            std::size_t file_size() const override {
+                return m_file_size;
+            }
+
         }; // class GzipCompressor
 
-        class GzipDecompressor : public Decompressor {
+        class GzipDecompressor final : public Decompressor {
 
-            gzFile m_gzfile;
+            gzFile m_gzfile = nullptr;
+            int m_fd;
 
         public:
 
-            explicit GzipDecompressor(int fd) :
-                m_gzfile(::gzdopen(fd, "r")) {
+            explicit GzipDecompressor(const int fd) : m_fd(fd) {
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                m_gzfile = ::gzdopen(fd, "rb");
                 if (!m_gzfile) {
-                    detail::throw_gzip_error(m_gzfile, "read initialization failed");
+                    try {
+                        osmium::io::detail::reliable_close(fd);
+                    } catch (...) {
+                    }
+                    throw gzip_error{"gzip error: read initialization failed"};
                 }
             }
 
@@ -174,7 +208,7 @@ namespace osmium {
             GzipDecompressor(GzipDecompressor&&) = delete;
             GzipDecompressor& operator=(GzipDecompressor&&) = delete;
 
-            ~GzipDecompressor() noexcept final {
+            ~GzipDecompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -182,41 +216,58 @@ namespace osmium {
                 }
             }
 
-            std::string read() final {
+            std::string read() override {
+                assert(m_gzfile);
+#ifdef _MSC_VER
+                osmium::detail::disable_invalid_parameter_handler diph;
+#else
+# if ZLIB_VERNUM >= 0x1240
+                const auto offset = ::gzoffset(m_gzfile);
+                if (offset > 0 && want_buffered_pages_removed()) {
+                    osmium::io::detail::remove_buffered_pages(m_fd, static_cast<std::size_t>(offset));
+                }
+# endif
+#endif
                 std::string buffer(osmium::io::Decompressor::input_buffer_size, '\0');
                 assert(buffer.size() < std::numeric_limits<unsigned int>::max());
-                int nread = ::gzread(m_gzfile, const_cast<char*>(buffer.data()), static_cast<unsigned int>(buffer.size()));
+                int nread = ::gzread(m_gzfile, &*buffer.begin(), static_cast<unsigned int>(buffer.size()));
                 if (nread < 0) {
                     detail::throw_gzip_error(m_gzfile, "read failed");
                 }
                 buffer.resize(static_cast<std::string::size_type>(nread));
 #if ZLIB_VERNUM >= 0x1240
-                set_offset(size_t(::gzoffset(m_gzfile)));
+                set_offset(static_cast<std::size_t>(::gzoffset(m_gzfile)));
 #endif
                 return buffer;
             }
 
-            void close() final {
+            void close() override {
                 if (m_gzfile) {
-                    const int result = ::gzclose(m_gzfile);
+                    if (want_buffered_pages_removed()) {
+                        osmium::io::detail::remove_buffered_pages(m_fd);
+                    }
+#ifdef _MSC_VER
+                    osmium::detail::disable_invalid_parameter_handler diph;
+#endif
+                    const int result = ::gzclose_r(m_gzfile);
                     m_gzfile = nullptr;
                     if (result != Z_OK) {
-                        detail::throw_gzip_error(m_gzfile, "read close failed", result);
+                        throw gzip_error{"gzip error: read close failed", result};
                     }
                 }
             }
 
         }; // class GzipDecompressor
 
-        class GzipBufferDecompressor : public Decompressor {
+        class GzipBufferDecompressor final : public Decompressor {
 
             const char* m_buffer;
-            size_t m_buffer_size;
+            std::size_t m_buffer_size;
             z_stream m_zstream;
 
         public:
 
-            GzipBufferDecompressor(const char* buffer, size_t size) :
+            GzipBufferDecompressor(const char* buffer, const std::size_t size) :
                 m_buffer(buffer),
                 m_buffer_size(size),
                 m_zstream() {
@@ -239,7 +290,7 @@ namespace osmium {
             GzipBufferDecompressor(GzipBufferDecompressor&&) = delete;
             GzipBufferDecompressor& operator=(GzipBufferDecompressor&&) = delete;
 
-            ~GzipBufferDecompressor() noexcept final {
+            ~GzipBufferDecompressor() noexcept override {
                 try {
                     close();
                 } catch (...) {
@@ -247,13 +298,13 @@ namespace osmium {
                 }
             }
 
-            std::string read() final {
+            std::string read() override {
                 std::string output;
 
                 if (m_buffer) {
-                    const size_t buffer_size = 10240;
+                    const std::size_t buffer_size = 10240;
                     output.append(buffer_size, '\0');
-                    m_zstream.next_out = reinterpret_cast<unsigned char*>(const_cast<char*>(output.data()));
+                    m_zstream.next_out = reinterpret_cast<unsigned char*>(&*output.begin());
                     m_zstream.avail_out = buffer_size;
                     const int result = inflate(&m_zstream, Z_SYNC_FLUSH);
 
@@ -263,7 +314,7 @@ namespace osmium {
                     }
 
                     if (result != Z_OK && result != Z_STREAM_END) {
-                        std::string message("gzip error: inflate failed: ");
+                        std::string message{"gzip error: inflate failed: "};
                         if (m_zstream.msg) {
                             message.append(m_zstream.msg);
                         }
@@ -276,7 +327,7 @@ namespace osmium {
                 return output;
             }
 
-            void close() final {
+            void close() override {
                 inflateEnd(&m_zstream);
             }
 
@@ -287,9 +338,9 @@ namespace osmium {
             // we want the register_compression() function to run, setting
             // the variable is only a side-effect, it will never be used
             const bool registered_gzip_compression = osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip,
-                [](int fd, fsync sync) { return new osmium::io::GzipCompressor{fd, sync}; },
-                [](int fd) { return new osmium::io::GzipDecompressor{fd}; },
-                [](const char* buffer, size_t size) { return new osmium::io::GzipBufferDecompressor{buffer, size}; }
+                [](const int fd, const fsync sync) { return new osmium::io::GzipCompressor{fd, sync}; },
+                [](const int fd) { return new osmium::io::GzipDecompressor{fd}; },
+                [](const char* buffer, const std::size_t size) { return new osmium::io::GzipBufferDecompressor{buffer, size}; }
             );
 
             // dummy function to silence the unused variable warning from above
diff --git a/third_party/libosmium/include/osmium/io/header.hpp b/third_party/libosmium/include/osmium/io/header.hpp
index ff5d89b2f..54ce5aa14 100644
--- a/third_party/libosmium/include/osmium/io/header.hpp
+++ b/third_party/libosmium/include/osmium/io/header.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -62,7 +62,7 @@ namespace osmium {
          * with additional information. Most often this is used to set the
          * "generator", the program that generated the file. Depending on
          * the file format some of these key-value pairs are handled
-         * specially. The the Options parent class for details on how to
+         * specially. See the Options parent class for details on how to
          * set and get those key-value pairs.
          */
         class Header : public osmium::Options {
@@ -124,11 +124,11 @@ namespace osmium {
              * Returns an empty, invalid box if there is none.
              */
             osmium::Box joined_boxes() const {
-                osmium::Box box;
+                osmium::Box result_box;
                 for (const auto& b : m_boxes) {
-                    box.extend(b);
+                    result_box.extend(b);
                 }
-                return box;
+                return result_box;
             }
 
             /**
diff --git a/third_party/libosmium/include/utf8.h b/third_party/libosmium/include/osmium/io/ids_output.hpp
similarity index 75%
rename from third_party/libosmium/include/utf8.h
rename to third_party/libosmium/include/osmium/io/ids_output.hpp
index 82b13f59f..395d3abfd 100644
--- a/third_party/libosmium/include/utf8.h
+++ b/third_party/libosmium/include/osmium/io/ids_output.hpp
@@ -1,6 +1,14 @@
-// Copyright 2006 Nemanja Trifunovic
+#ifndef OSMIUM_IO_IDS_OUTPUT_HPP
+#define OSMIUM_IO_IDS_OUTPUT_HPP
 
 /*
+
+This file is part of Osmium (https://osmcode.org/libosmium).
+
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
 Permission is hereby granted, free of charge, to any person or organization
 obtaining a copy of the software and accompanying documentation covered by
 this license (the "Software") to use, reproduce, display, distribute,
@@ -22,13 +30,10 @@ SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
 FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
+
 */
 
+#include <osmium/io/detail/ids_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/writer.hpp> // IWYU pragma: export
 
-#ifndef UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "utf8/checked.h"
-#include "utf8/unchecked.h"
-
-#endif // header guard
+#endif // OSMIUM_IO_IDS_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/input_iterator.hpp b/third_party/libosmium/include/osmium/io/input_iterator.hpp
index d89e48e45..03f86a956 100644
--- a/third_party/libosmium/include/osmium/io/input_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/input_iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -105,7 +105,7 @@ namespace osmium {
             }
 
             InputIterator operator++(int) {
-                InputIterator tmp(*this);
+                InputIterator tmp{*this};
                 operator++();
                 return tmp;
             }
@@ -154,11 +154,11 @@ namespace osmium {
                 return m_end;
             }
 
-            const InputIterator<TSource, TItem> cbegin() const noexcept {
+            InputIterator<TSource, TItem> cbegin() const noexcept {
                 return m_begin;
             }
 
-            const InputIterator<TSource, TItem> cend() const noexcept {
+            InputIterator<TSource, TItem> cend() const noexcept {
                 return m_end;
             }
 
@@ -167,7 +167,7 @@ namespace osmium {
         template <typename TItem, typename TSource>
         InputIteratorRange<TSource, TItem> make_input_iterator_range(TSource& source) {
             using it_type = InputIterator<TSource, TItem>;
-            return InputIteratorRange<TSource, TItem>(it_type{source}, it_type{});
+            return InputIteratorRange<TSource, TItem>{it_type{source}, it_type{}};
         }
 
     } // namespace io
diff --git a/third_party/libosmium/include/osmium/io/o5m_input.hpp b/third_party/libosmium/include/osmium/io/o5m_input.hpp
index 08390ba41..59209880a 100644
--- a/third_party/libosmium/include/osmium/io/o5m_input.hpp
+++ b/third_party/libosmium/include/osmium/io/o5m_input.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/opl_input.hpp b/third_party/libosmium/include/osmium/io/opl_input.hpp
index 7b75fbfea..f74c69766 100644
--- a/third_party/libosmium/include/osmium/io/opl_input.hpp
+++ b/third_party/libosmium/include/osmium/io/opl_input.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/opl_output.hpp b/third_party/libosmium/include/osmium/io/opl_output.hpp
index 7fa448969..faa3edfd5 100644
--- a/third_party/libosmium/include/osmium/io/opl_output.hpp
+++ b/third_party/libosmium/include/osmium/io/opl_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/output_iterator.hpp b/third_party/libosmium/include/osmium/io/output_iterator.hpp
index 190128146..127bb5af1 100644
--- a/third_party/libosmium/include/osmium/io/output_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/output_iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,7 +34,6 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #include <osmium/osm/diff_object.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <cstddef>
 #include <iterator>
@@ -64,26 +63,6 @@ namespace osmium {
                 m_destination(&destination) {
             }
 
-            /**
-             * @deprecated
-             * Use of buffer size argument on OutputIterator
-             * constructor is deprecated. Call Writer::set_buffer_size()
-             * instead if you want to change the default.
-             */
-            OSMIUM_DEPRECATED OutputIterator(TDest& destination, const size_t buffer_size) :
-                m_destination(&destination) {
-                destination.set_buffer_size(buffer_size);
-            }
-
-            /**
-             * @deprecated
-             * Calling OutputIterator<Writer>::flush() is usually not
-             * needed any more. Call flush() on the Writer instead if needed.
-             */
-            OSMIUM_DEPRECATED void flush() {
-                m_destination->flush();
-            }
-
             OutputIterator& operator=(const osmium::memory::Item& item) {
                 (*m_destination)(item);
                 return *this;
@@ -117,18 +96,6 @@ namespace osmium {
             return OutputIterator<TDest>{destination};
         }
 
-        /**
-         * @deprecated
-         * Use of buffer size argument on make_output_iterator is deprecated.
-         * Call Writer::set_buffer_size() instead if you want to change the
-         * default.
-         */
-        template <typename TDest>
-        OSMIUM_DEPRECATED OutputIterator<TDest> make_output_iterator(TDest& destination, const size_t buffer_size) {
-            destination.set_buffer_size(buffer_size);
-            return OutputIterator<TDest>{destination};
-        }
-
     } // namespace io
 
 } // namespace osmium
diff --git a/third_party/libosmium/include/osmium/io/overwrite.hpp b/third_party/libosmium/include/osmium/io/overwrite.hpp
index c8fa539bc..628a41429 100644
--- a/third_party/libosmium/include/osmium/io/overwrite.hpp
+++ b/third_party/libosmium/include/osmium/io/overwrite.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/EXTERNAL_LICENSES.txt b/third_party/libosmium/include/osmium/io/pbf.hpp
similarity index 63%
rename from third_party/libosmium/EXTERNAL_LICENSES.txt
rename to third_party/libosmium/include/osmium/io/pbf.hpp
index 9484c0891..2aa22be6e 100644
--- a/third_party/libosmium/EXTERNAL_LICENSES.txt
+++ b/third_party/libosmium/include/osmium/io/pbf.hpp
@@ -1,7 +1,13 @@
+#ifndef OSMIUM_IO_PBF_HPP
+#define OSMIUM_IO_PBF_HPP
 
-==== For utf8.h
+/*
 
-Copyright 2006 Nemanja Trifunovic
+This file is part of Osmium (https://osmcode.org/libosmium).
+
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
 
 Permission is hereby granted, free of charge, to any person or organization
 obtaining a copy of the software and accompanying documentation covered by
@@ -25,3 +31,30 @@ FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
 ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 DEALINGS IN THE SOFTWARE.
 
+*/
+
+#include <string>
+#include <vector>
+
+namespace osmium {
+
+    namespace io {
+
+        /**
+         * Get a list of all compression types supported for PBF files.
+         */
+        inline std::vector<std::string> supported_pbf_compression_types() {
+            std::vector<std::string> types{"none", "zlib"};
+
+#ifdef OSMIUM_WITH_LZ4
+            types.emplace_back("lz4");
+#endif
+
+            return types;
+        }
+
+    } // namespace io
+
+} // namespace osmium
+
+#endif // OSMIUM_IO_PBF_HPP
diff --git a/third_party/libosmium/include/osmium/io/pbf_input.hpp b/third_party/libosmium/include/osmium/io/pbf_input.hpp
index c745d36cb..4a7eb681e 100644
--- a/third_party/libosmium/include/osmium/io/pbf_input.hpp
+++ b/third_party/libosmium/include/osmium/io/pbf_input.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -43,6 +43,7 @@ DEALINGS IN THE SOFTWARE.
  */
 
 #include <osmium/io/detail/pbf_input_format.hpp> // IWYU pragma: export
+#include <osmium/io/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/reader.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_PBF_INPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/pbf_output.hpp b/third_party/libosmium/include/osmium/io/pbf_output.hpp
index 4e493f442..ba6413b79 100644
--- a/third_party/libosmium/include/osmium/io/pbf_output.hpp
+++ b/third_party/libosmium/include/osmium/io/pbf_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -43,6 +43,7 @@ DEALINGS IN THE SOFTWARE.
  */
 
 #include <osmium/io/detail/pbf_output_format.hpp> // IWYU pragma: export
+#include <osmium/io/pbf.hpp> // IWYU pragma: export
 #include <osmium/io/writer.hpp> // IWYU pragma: export
 
 #endif // OSMIUM_IO_PBF_OUTPUT_HPP
diff --git a/third_party/libosmium/include/osmium/io/reader.hpp b/third_party/libosmium/include/osmium/io/reader.hpp
index 9ffacb935..bd6522f3c 100644
--- a/third_party/libosmium/include/osmium/io/reader.hpp
+++ b/third_party/libosmium/include/osmium/io/reader.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -72,13 +72,11 @@ namespace osmium {
         namespace detail {
 
             inline std::size_t get_input_queue_size() noexcept {
-                const std::size_t n = osmium::config::get_max_queue_size("INPUT", 20);
-                return n > 2 ? n : 2;
+                return osmium::config::get_max_queue_size("INPUT", 20);
             }
 
             inline std::size_t get_osmdata_queue_size() noexcept {
-                const std::size_t n = osmium::config::get_max_queue_size("OSMDATA", 20);
-                return n > 2 ? n : 2;
+                return osmium::config::get_max_queue_size("OSMDATA", 20);
             }
 
         } // namespace detail
@@ -91,10 +89,17 @@ namespace osmium {
          */
         class Reader {
 
+            // The Reader::read() function reads from a queue of buffers which
+            // can contain nested buffers. These nested buffers will be in
+            // here, because read() can only return a single unnested buffer.
+            osmium::memory::Buffer m_back_buffers{};
+
             osmium::io::File m_file;
 
             osmium::thread::Pool* m_pool = nullptr;
 
+            std::atomic<std::size_t> m_offset{0};
+
             detail::ParserFactory::create_parser_type m_creator;
 
             enum class status {
@@ -108,6 +113,10 @@ namespace osmium {
 
             detail::future_string_queue_type m_input_queue;
 
+            int m_fd = -1;
+
+            std::size_t m_file_size = 0;
+
             std::unique_ptr<osmium::io::Decompressor> m_decompressor;
 
             osmium::io::detail::ReadThreadManager m_read_thread_manager;
@@ -120,10 +129,9 @@ namespace osmium {
 
             osmium::thread::thread_handler m_thread{};
 
-            std::size_t m_file_size = 0;
-
             osmium::osm_entity_bits::type m_read_which_entities = osmium::osm_entity_bits::all;
             osmium::io::read_meta m_read_metadata = osmium::io::read_meta::yes;
+            osmium::io::buffers_type m_buffers_kind = osmium::io::buffers_type::any;
 
             void set_option(osmium::thread::Pool& pool) noexcept {
                 m_pool = &pool;
@@ -134,26 +142,42 @@ namespace osmium {
             }
 
             void set_option(osmium::io::read_meta value) noexcept {
-                m_read_metadata = value;
+                // Ignore this setting if we have a history/change file,
+                // because if this is set to "no", we don't see the difference
+                // between visible and deleted objects.
+                if (!m_file.has_multiple_object_versions()) {
+                    m_read_metadata = value;
+                }
+            }
+
+            void set_option(osmium::io::buffers_type value) noexcept {
+                m_buffers_kind = value;
             }
 
             // This function will run in a separate thread.
             static void parser_thread(osmium::thread::Pool& pool,
+                                      int fd,
                                       const detail::ParserFactory::create_parser_type& creator,
                                       detail::future_string_queue_type& input_queue,
                                       detail::future_buffer_queue_type& osmdata_queue,
                                       std::promise<osmium::io::Header>&& header_promise,
+                                      std::atomic<std::size_t>* offset_ptr,
                                       osmium::osm_entity_bits::type read_which_entities,
-                                      osmium::io::read_meta read_metadata) {
+                                      osmium::io::read_meta read_metadata,
+                                      osmium::io::buffers_type buffers_kind,
+                                      bool want_buffered_pages_removed) {
                 std::promise<osmium::io::Header> promise{std::move(header_promise)};
                 osmium::io::detail::parser_arguments args = {
                     pool,
+                    fd,
                     input_queue,
                     osmdata_queue,
                     promise,
+                    offset_ptr,
                     read_which_entities,
-                    read_metadata
-                };
+                    read_metadata,
+                    buffers_kind,
+                    want_buffered_pages_removed};
                 creator(args)->parse();
             }
 
@@ -186,7 +210,7 @@ namespace osmium {
                         }
                     }
                     if (dup2(pipefd[1], 1) < 0) { // put end of pipe as stdout/stdin
-                        exit(1);
+                        std::exit(1); // NOLINT(concurrency-mt-unsafe)
                     }
 
                     ::open("/dev/null", O_RDONLY); // stdin
@@ -196,7 +220,7 @@ namespace osmium {
                     // in theory this execute() function could be used for other commands, but it is
                     // only used for curl at the moment, so this is okay.
                     if (::execlp(command.c_str(), command.c_str(), "-g", filename.c_str(), nullptr) < 0) {
-                        exit(1);
+                        std::exit(1); // NOLINT(concurrency-mt-unsafe)
                     }
                 }
                 // parent
@@ -223,7 +247,30 @@ namespace osmium {
                     throw io_error{"Reading OSM files from the network currently not supported on Windows."};
 #endif
                 }
-                return osmium::io::detail::open_for_reading(filename);
+                const int fd = osmium::io::detail::open_for_reading(filename);
+#if __linux__
+                if (fd >= 0) {
+                    // Tell the kernel we are going to read this file sequentially
+                    ::posix_fadvise(fd, 0, 0, POSIX_FADV_SEQUENTIAL);
+                }
+#endif
+                return fd;
+            }
+
+            static std::unique_ptr<Decompressor> make_decompressor(const osmium::io::File& file, int fd, std::atomic<std::size_t>* offset_ptr) {
+                const auto& factory = osmium::io::CompressionFactory::instance();
+                std::unique_ptr<Decompressor> decompressor;
+
+                if (file.buffer()) {
+                    decompressor = factory.create_decompressor(file.compression(), file.buffer(), file.buffer_size());
+                } else if (file.format() == file_format::pbf) {
+                    decompressor = std::unique_ptr<Decompressor>{new DummyDecompressor{}};
+                } else {
+                    decompressor = factory.create_decompressor(file.compression(), fd);
+                }
+
+                decompressor->set_offset_ptr(offset_ptr);
+                return decompressor;
             }
 
         public:
@@ -245,7 +292,25 @@ namespace osmium {
              *      is read normally. If you set this to
              *      osmium::io::read_meta::no, meta data (like version, uid,
              *      etc.) is not read possibly speeding up the read. Not all
-             *      file formats use this setting.
+             *      file formats use this setting. Do *not* set this to
+             *      osmium::io::read_meta::no for history or change files
+             *      because you will loose the information whether an object
+             *      is visible!
+             *
+             * * osmium::io::buffers_type: Fill entities into buffers until
+             *      the buffers are full (osmium::io::buffers_type::any) or
+             *      only fill entities of the same type into a buffer
+             *      (osmium::io::buffers_type::single). Every time a new
+             *      entity type is seen a new buffer will be started. Do not
+             *      use in "single" mode if the input file is not sorted by
+             *      type, otherwise this will be rather inefficient.
+             *
+             * * osmium::thread::Pool&: Reference to a thread pool that should
+             *      be used for reading instead of the default pool. Usually
+             *      it is okay to use the statically initialized shared
+             *      default pool, but sometimes you want or need your own.
+             *      For instance when your program will fork, using the
+             *      statically initialized pool will not work.
              *
              * @throws osmium::io_error If there was an error.
              * @throws std::system_error If the file could not be opened.
@@ -255,17 +320,14 @@ namespace osmium {
                 m_file(file.check()),
                 m_creator(detail::ParserFactory::instance().get_creator_function(m_file)),
                 m_input_queue(detail::get_input_queue_size(), "raw_input"),
-                m_decompressor(m_file.buffer() ?
-                    osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), m_file.buffer(), m_file.buffer_size()) :
-                    osmium::io::CompressionFactory::instance().create_decompressor(file.compression(), open_input_file_or_url(m_file.filename(), &m_childpid))),
+                m_fd(m_file.buffer() ? -1 : open_input_file_or_url(m_file.filename(), &m_childpid)),
+                m_file_size(m_fd > 2 ? osmium::file_size(m_fd) : 0),
+                m_decompressor(make_decompressor(m_file, m_fd, &m_offset)),
                 m_read_thread_manager(*m_decompressor, m_input_queue),
                 m_osmdata_queue(detail::get_osmdata_queue_size(), "parser_results"),
-                m_osmdata_queue_wrapper(m_osmdata_queue),
-                m_file_size(m_decompressor->file_size()) {
+                m_osmdata_queue_wrapper(m_osmdata_queue) {
 
-                (void)std::initializer_list<int>{
-                    (set_option(args), 0)...
-                };
+                (void)std::initializer_list<int>{(set_option(args), 0)...};
 
                 if (!m_pool) {
                     m_pool = &thread::Pool::default_instance();
@@ -273,7 +335,18 @@ namespace osmium {
 
                 std::promise<osmium::io::Header> header_promise;
                 m_header_future = header_promise.get_future();
-                m_thread = osmium::thread::thread_handler{parser_thread, std::ref(*m_pool), std::ref(m_creator), std::ref(m_input_queue), std::ref(m_osmdata_queue), std::move(header_promise), m_read_which_entities, m_read_metadata};
+
+                const auto cpc = osmium::config::clean_page_cache_after_read();
+                if (cpc >= 0) {
+                    m_decompressor->set_want_buffered_pages_removed(true);
+                }
+
+                const int fd_for_parser = m_decompressor->is_real() ? -1 : m_fd;
+                m_thread = osmium::thread::thread_handler{parser_thread, std::ref(*m_pool), fd_for_parser, std::ref(m_creator),
+                                                          std::ref(m_input_queue), std::ref(m_osmdata_queue),
+                                                          std::move(header_promise), &m_offset, m_read_which_entities,
+                                                          m_read_metadata, m_buffers_kind,
+                                                          m_decompressor->want_buffered_pages_removed()};
             }
 
             template <typename... TArgs>
@@ -313,7 +386,7 @@ namespace osmium {
 
                 m_read_thread_manager.stop();
 
-                m_osmdata_queue_wrapper.drain();
+                m_osmdata_queue_wrapper.shutdown();
 
                 try {
                     m_read_thread_manager.close();
@@ -323,7 +396,7 @@ namespace osmium {
 
 #ifndef _WIN32
                 if (m_childpid) {
-                    int status;
+                    int status = 0;
                     const pid_t pid = ::waitpid(m_childpid, &status, 0);
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
@@ -371,6 +444,17 @@ namespace osmium {
             osmium::memory::Buffer read() {
                 osmium::memory::Buffer buffer;
 
+                // If there are buffers on the stack, return those first.
+                if (m_back_buffers) {
+                    if (m_back_buffers.has_nested_buffers()) {
+                        buffer = std::move(*m_back_buffers.get_last_nested());
+                    } else {
+                        buffer = std::move(m_back_buffers);
+                        m_back_buffers = osmium::memory::Buffer{};
+                    }
+                    return buffer;
+                }
+
                 if (m_status != status::okay) {
                     throw io_error{"Can not read from reader when in status 'closed', 'eof', or 'error'"};
                 }
@@ -392,6 +476,10 @@ namespace osmium {
                             m_read_thread_manager.close();
                             return buffer;
                         }
+                        if (buffer.has_nested_buffers()) {
+                            m_back_buffers = std::move(buffer);
+                            buffer = std::move(*m_back_buffers.get_last_nested());
+                        }
                         if (buffer.committed() > 0) {
                             return buffer;
                         }
@@ -434,7 +522,7 @@ namespace osmium {
              * do an expensive system call.
              */
             std::size_t offset() const noexcept {
-                return m_decompressor->offset();
+                return m_offset;
             }
 
         }; // class Reader
@@ -449,7 +537,7 @@ namespace osmium {
          */
         template <typename... TArgs>
         osmium::memory::Buffer read_file(TArgs&&... args) {
-            osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+            osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
             Reader reader{std::forward<TArgs>(args)...};
             while (auto read_buffer = reader.read()) {
diff --git a/third_party/libosmium/include/osmium/io/reader_iterator.hpp b/third_party/libosmium/include/osmium/io/reader_iterator.hpp
index 242a7260e..13cf42bfa 100644
--- a/third_party/libosmium/include/osmium/io/reader_iterator.hpp
+++ b/third_party/libosmium/include/osmium/io/reader_iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -45,7 +45,7 @@ namespace osmium {
         }
 
         inline InputIterator<Reader> end(Reader& /*reader*/) {
-            return InputIterator<Reader>();
+            return {};
         }
 
     } // namespace io
diff --git a/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp b/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp
index 9bd8d3c08..e3370fa00 100644
--- a/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp
+++ b/third_party/libosmium/include/osmium/io/reader_with_progress_bar.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -60,7 +60,7 @@ namespace osmium {
              * All other parameters are forwarded to the Reader.
              */
             template <typename... TArgs>
-            ReaderWithProgressBar(bool enable, TArgs&&... args) :
+            explicit ReaderWithProgressBar(bool enable, TArgs&&... args) :
                 Reader(std::forward<TArgs>(args)...),
                 m_progress_bar(file_size(), enable) {
             }
diff --git a/third_party/libosmium/include/osmium/io/writer.hpp b/third_party/libosmium/include/osmium/io/writer.hpp
index 31f5832ee..44a0445d7 100644
--- a/third_party/libosmium/include/osmium/io/writer.hpp
+++ b/third_party/libosmium/include/osmium/io/writer.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -68,9 +68,8 @@ namespace osmium {
 
         namespace detail {
 
-            inline size_t get_output_queue_size() noexcept {
-                size_t n = osmium::config::get_max_queue_size("OUTPUT", 20);
-                return n > 2 ? n : 2;
+            inline std::size_t get_output_queue_size() noexcept {
+                return osmium::config::get_max_queue_size("OUTPUT", 20);
             }
 
         } // namespace detail
@@ -100,7 +99,9 @@ namespace osmium {
          */
         class Writer {
 
-            static constexpr size_t default_buffer_size = 10 * 1024 * 1024;
+            enum {
+                default_buffer_size = 10UL * 1024UL * 1024UL
+            };
 
             osmium::io::File m_file;
 
@@ -110,36 +111,66 @@ namespace osmium {
 
             osmium::memory::Buffer m_buffer{};
 
+            osmium::io::Header m_header;
+
             size_t m_buffer_size = default_buffer_size;
 
-            std::future<bool> m_write_future{};
+            std::future<std::size_t> m_write_future{};
 
             osmium::thread::thread_handler m_thread{};
 
+            // Checking the m_write_future is much more expensive then checking
+            // one atomic bool, so we set this bool in the write_thread when
+            // the writer should check the future...
+            std::atomic_bool m_notification{false};
+
             enum class status {
                 okay   = 0, // normal writing
                 error  = 1, // some error occurred while writing
                 closed = 2  // close() called successfully
             } m_status = status::okay;
 
+            // Has the header already bin written to the file?
+            bool m_header_written = false;
+
             // This function will run in a separate thread.
             static void write_thread(detail::future_string_queue_type& output_queue,
                                      std::unique_ptr<osmium::io::Compressor>&& compressor,
-                                     std::promise<bool>&& write_promise) {
+                                     std::promise<std::size_t>&& write_promise,
+                                     std::atomic_bool* notification) {
                 detail::WriteThread write_thread{output_queue,
                                                  std::move(compressor),
-                                                 std::move(write_promise)};
+                                                 std::move(write_promise),
+                                                 notification};
                 write_thread();
             }
 
+            void write_header() {
+                if (m_header.get("generator").empty()) {
+                    m_header.set("generator", "libosmium/" LIBOSMIUM_VERSION_STRING);
+                }
+
+                m_output->write_header(m_header);
+
+                m_header_written = true;
+            }
+
             void do_write(osmium::memory::Buffer&& buffer) {
+                if (!m_header_written) {
+                    write_header();
+                }
                 if (buffer && buffer.committed() > 0) {
                     m_output->write_buffer(std::move(buffer));
                 }
             }
 
             void do_flush() {
-                osmium::thread::check_for_exception(m_write_future);
+                if (!m_header_written) {
+                    write_header();
+                }
+                if (m_notification) {
+                    osmium::thread::check_for_exception(m_write_future);
+                }
                 if (m_buffer && m_buffer.committed() > 0) {
                     osmium::memory::Buffer buffer{m_buffer_size,
                                                   osmium::memory::Buffer::auto_grow::no};
@@ -191,7 +222,7 @@ namespace osmium {
 
             void do_close() {
                 if (m_status == status::okay) {
-                    ensure_cleanup([&](){
+                    ensure_cleanup([&]() {
                         do_write(std::move(m_buffer));
                         m_output->write_end();
                         m_status = status::closed;
@@ -222,6 +253,13 @@ namespace osmium {
              *       before closing it? Can be osmium::io::fsync::yes or
              *       osmium::io::fsync::no (default).
              *
+             * * osmium::thread::Pool&: Reference to a thread pool that should
+             *      be used for writing instead of the default pool. Usually
+             *      it is okay to use the statically initialized shared
+             *      default pool, but sometimes you want or need your own.
+             *      For instance when your program will fork, using the
+             *      statically initialized pool will not work.
+             *
              * @throws osmium::io_error If there was an error.
              * @throws std::system_error If the file could not be opened.
              */
@@ -231,32 +269,24 @@ namespace osmium {
                 assert(!m_file.buffer()); // XXX can't handle pseudo-files
 
                 options_type options;
-                (void)std::initializer_list<int>{
-                    (set_option(options, args), 0)...
-                };
+                (void)std::initializer_list<int>{(set_option(options, args), 0)...};
 
                 if (!options.pool) {
                     options.pool = &thread::Pool::default_instance();
                 }
 
-                m_output = osmium::io::detail::OutputFormatFactory::instance().create_output(*options.pool, m_file, m_output_queue);
+                m_header = options.header;
 
-                if (options.header.get("generator").empty()) {
-                    options.header.set("generator", "libosmium/" LIBOSMIUM_VERSION_STRING);
-                }
+                m_output = osmium::io::detail::OutputFormatFactory::instance().create_output(*options.pool, m_file, m_output_queue);
 
                 std::unique_ptr<osmium::io::Compressor> compressor =
                     CompressionFactory::instance().create_compressor(file.compression(),
                                                                      osmium::io::detail::open_for_writing(m_file.filename(), options.allow_overwrite),
                                                                      options.sync);
 
-                std::promise<bool> write_promise;
+                std::promise<std::size_t> write_promise;
                 m_write_future = write_promise.get_future();
-                m_thread = osmium::thread::thread_handler{write_thread, std::ref(m_output_queue), std::move(compressor), std::move(write_promise)};
-
-                ensure_cleanup([&](){
-                    m_output->write_header(options.header);
-                });
+                m_thread = osmium::thread::thread_handler{write_thread, std::ref(m_output_queue), std::move(compressor), std::move(write_promise), &m_notification};
             }
 
             template <typename... TArgs>
@@ -298,6 +328,16 @@ namespace osmium {
                 m_buffer_size = size;
             }
 
+            /**
+             * Set header. This will overwrite a header set in the constructor.
+             *
+             * Has to be called before writing anything to the file, otherwise
+             * this will not do anything.
+             */
+            void set_header(const osmium::io::Header& header) {
+                m_header = header;
+            }
+
             /**
              * Flush the internal buffer if it contains any data. This is
              * usually not needed as the buffer gets flushed on close()
@@ -306,7 +346,7 @@ namespace osmium {
              * @throws Some form of osmium::io_error when there is a problem.
              */
             void flush() {
-                ensure_cleanup([&](){
+                ensure_cleanup([&]() {
                     do_flush();
                 });
             }
@@ -320,7 +360,7 @@ namespace osmium {
              * @throws Some form of osmium::io_error when there is a problem.
              */
             void operator()(osmium::memory::Buffer&& buffer) {
-                ensure_cleanup([&](){
+                ensure_cleanup([&]() {
                     do_flush();
                     do_write(std::move(buffer));
                 });
@@ -334,7 +374,7 @@ namespace osmium {
              * @throws Some form of osmium::io_error when there is a problem.
              */
             void operator()(const osmium::memory::Item& item) {
-                ensure_cleanup([&](){
+                ensure_cleanup([&]() {
                     if (!m_buffer) {
                         m_buffer = osmium::memory::Buffer{m_buffer_size,
                                                           osmium::memory::Buffer::auto_grow::no};
@@ -355,14 +395,18 @@ namespace osmium {
              * the destructor will ignore, it is better to call close()
              * explicitly.
              *
+             * @returns Number of bytes written to the file (or 0 if it can
+             *          not be determined).
              * @throws Some form of osmium::io_error when there is a problem.
              */
-            void close() {
+            std::size_t close() {
                 do_close();
 
                 if (m_write_future.valid()) {
-                    m_write_future.get();
+                    return m_write_future.get();
                 }
+
+                return 0;
             }
 
         }; // class Writer
diff --git a/third_party/libosmium/include/osmium/io/writer_options.hpp b/third_party/libosmium/include/osmium/io/writer_options.hpp
index d73c905da..4931b77ed 100644
--- a/third_party/libosmium/include/osmium/io/writer_options.hpp
+++ b/third_party/libosmium/include/osmium/io/writer_options.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/xml_input.hpp b/third_party/libosmium/include/osmium/io/xml_input.hpp
index 9de7df2ea..cc4d0ba75 100644
--- a/third_party/libosmium/include/osmium/io/xml_input.hpp
+++ b/third_party/libosmium/include/osmium/io/xml_input.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/io/xml_output.hpp b/third_party/libosmium/include/osmium/io/xml_output.hpp
index 3c4be9b26..cd79fc13e 100644
--- a/third_party/libosmium/include/osmium/io/xml_output.hpp
+++ b/third_party/libosmium/include/osmium/io/xml_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/memory/buffer.hpp b/third_party/libosmium/include/osmium/memory/buffer.hpp
index 392c6bf76..5d8bbbf15 100644
--- a/third_party/libosmium/include/osmium/memory/buffer.hpp
+++ b/third_party/libosmium/include/osmium/memory/buffer.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -55,7 +55,7 @@ namespace osmium {
      * to write data into a buffer and it doesn't fit. Buffers with internal
      * memory management will not throw this exception, but increase their size.
      */
-    struct buffer_is_full : public std::runtime_error {
+    struct OSMIUM_EXPORT buffer_is_full : public std::runtime_error {
 
         buffer_is_full() :
             std::runtime_error{"Osmium buffer is full"} {
@@ -101,14 +101,16 @@ namespace osmium {
             // This is needed so we can call std::back_inserter() on a Buffer.
             using value_type = Item;
 
-            enum class auto_grow : bool {
-                yes = true,
-                no  = false
+            enum class auto_grow {
+                no       = 0,
+                yes      = 1,
+                internal = 2
             }; // enum class auto_grow
 
         private:
 
-            std::unique_ptr<unsigned char[]> m_memory;
+            std::unique_ptr<Buffer> m_next_buffer;
+            std::unique_ptr<unsigned char[]> m_memory{};
             unsigned char* m_data = nullptr;
             std::size_t m_capacity = 0;
             std::size_t m_written = 0;
@@ -117,17 +119,37 @@ namespace osmium {
             uint8_t m_builder_count = 0;
 #endif
             auto_grow m_auto_grow{auto_grow::no};
-            std::function<void(Buffer&)> m_full;
 
             static std::size_t calculate_capacity(std::size_t capacity) noexcept {
-                // The majority of all Nodes will fit into this size.
-                constexpr static const std::size_t min_capacity = 64;
+                enum {
+                    // The majority of all Nodes will fit into this size.
+                    min_capacity = 64
+                };
+
                 if (capacity < min_capacity) {
                     return min_capacity;
                 }
                 return padded_length(capacity);
             }
 
+            void grow_internal() {
+                assert(m_data && "This must be a valid buffer");
+                if (!m_memory) {
+                    throw std::logic_error{"Can't grow Buffer if it doesn't use internal memory management."};
+                }
+
+                std::unique_ptr<Buffer> old{new Buffer{std::move(m_memory), m_capacity, m_committed}};
+                m_memory = std::unique_ptr<unsigned char[]>{new unsigned char[m_capacity]};
+                m_data = m_memory.get();
+
+                m_written -= m_committed;
+                std::copy_n(old->data() + m_committed, m_written, m_data);
+                m_committed = 0;
+
+                old->m_next_buffer = std::move(m_next_buffer);
+                m_next_buffer = std::move(old);
+            }
+
         public:
 
             /**
@@ -138,9 +160,7 @@ namespace osmium {
              * Most methods of the Buffer class will not work with an invalid
              * buffer.
              */
-            Buffer() noexcept :
-                m_memory() {
-            }
+            Buffer() noexcept = default;
 
             /**
              * Constructs a valid externally memory-managed buffer using the
@@ -153,7 +173,6 @@ namespace osmium {
              *         the alignment.
              */
             explicit Buffer(unsigned char* data, std::size_t size) :
-                m_memory(),
                 m_data(data),
                 m_capacity(size),
                 m_written(size),
@@ -176,7 +195,6 @@ namespace osmium {
              *         than capacity.
              */
             explicit Buffer(unsigned char* data, std::size_t capacity, std::size_t committed) :
-                m_memory(),
                 m_data(data),
                 m_capacity(capacity),
                 m_written(committed),
@@ -192,6 +210,36 @@ namespace osmium {
                 }
             }
 
+            /**
+             * Constructs a valid internally memory-managed buffer with the
+             * given capacity that already contains 'committed' bytes of data.
+             *
+             * @param data A unique pointer to some (possibly initialized) data.
+             *             The Buffer will manage this memory.
+             * @param capacity The size of the memory for this buffer.
+             * @param committed The size of the initialized data. If this is 0, the buffer startes out empty.
+             *
+             * @throws std::invalid_argument if the capacity or committed isn't
+             *         a multiple of the alignment or if committed is larger
+             *         than capacity.
+             */
+            explicit Buffer(std::unique_ptr<unsigned char[]> data, std::size_t capacity, std::size_t committed) :
+                m_memory(std::move(data)),
+                m_data(m_memory.get()),
+                m_capacity(capacity),
+                m_written(committed),
+                m_committed(committed) {
+                if (capacity % align_bytes != 0) {
+                    throw std::invalid_argument{"buffer capacity needs to be multiple of alignment"};
+                }
+                if (committed % align_bytes != 0) {
+                    throw std::invalid_argument{"buffer parameter 'committed' needs to be multiple of alignment"};
+                }
+                if (committed > capacity) {
+                    throw std::invalid_argument{"buffer parameter 'committed' can not be larger than capacity"};
+                }
+            }
+
             /**
              * Constructs a valid internally memory-managed buffer with the
              * given capacity.
@@ -216,10 +264,48 @@ namespace osmium {
             Buffer& operator=(const Buffer&) = delete;
 
             // buffers can be moved
-            Buffer(Buffer&&) = default;
-            Buffer& operator=(Buffer&&) = default;
+            Buffer(Buffer&& other) noexcept :
+                m_next_buffer(std::move(other.m_next_buffer)),
+                m_memory(std::move(other.m_memory)),
+                m_data(other.m_data),
+                m_capacity(other.m_capacity),
+                m_written(other.m_written),
+                m_committed(other.m_committed),
+#ifndef NDEBUG
+                m_builder_count(other.m_builder_count),
+#endif
+                m_auto_grow(other.m_auto_grow) {
+                other.m_data = nullptr;
+                other.m_capacity = 0;
+                other.m_written = 0;
+                other.m_committed = 0;
+#ifndef NDEBUG
+                other.m_builder_count = 0;
+#endif
+            }
 
-            ~Buffer() = default;
+            Buffer& operator=(Buffer&& other) noexcept {
+                m_next_buffer = std::move(other.m_next_buffer);
+                m_memory = std::move(other.m_memory);
+                m_data = other.m_data;
+                m_capacity = other.m_capacity;
+                m_written = other.m_written;
+                m_committed = other.m_committed;
+#ifndef NDEBUG
+                m_builder_count = other.m_builder_count;
+#endif
+                m_auto_grow = other.m_auto_grow;
+                other.m_data = nullptr;
+                other.m_capacity = 0;
+                other.m_written = 0;
+                other.m_committed = 0;
+#ifndef NDEBUG
+                other.m_builder_count = 0;
+#endif
+                return *this;
+            }
+
+            ~Buffer() noexcept = default;
 
 #ifndef NDEBUG
             void increment_builder_count() noexcept {
@@ -282,26 +368,6 @@ namespace osmium {
                 return (m_written % align_bytes == 0) && (m_committed % align_bytes == 0);
             }
 
-            /**
-             * Set functor to be called whenever the buffer is full
-             * instead of throwing buffer_is_full.
-             *
-             * The behaviour is undefined if you call this on an invalid
-             * buffer.
-             *
-             * @pre The buffer must be valid.
-             *
-             * @deprecated
-             * Callback functionality will be removed in the future. Either
-             * detect the buffer_is_full exception or use a buffer with
-             * auto_grow::yes. If you want to avoid growing buffers, check
-             * the CallbackBuffer class.
-             */
-            OSMIUM_DEPRECATED void set_full_callback(const std::function<void(Buffer&)>& full) {
-                assert(m_data && "This must be a valid buffer");
-                m_full = full;
-            }
-
             /**
              * Grow capacity of this buffer to the given size (which will be
              * rounded up to the alignment needed).
@@ -324,7 +390,7 @@ namespace osmium {
                 }
                 size = calculate_capacity(size);
                 if (m_capacity < size) {
-                    std::unique_ptr<unsigned char[]> memory(new unsigned char[size]);
+                    std::unique_ptr<unsigned char[]> memory{new unsigned char[size]};
                     std::copy_n(m_memory.get(), m_capacity, memory.get());
                     using std::swap;
                     swap(m_memory, memory);
@@ -333,6 +399,31 @@ namespace osmium {
                 }
             }
 
+            /**
+             * Does this buffer have nested buffers inside. This happens
+             * when a buffer is full and auto_grow is defined as internal.
+             *
+             * @returns Are there nested buffers or not?
+             */
+            bool has_nested_buffers() const noexcept {
+                return m_next_buffer != nullptr;
+            }
+
+            /**
+             * Return the most deeply nested buffer. The buffer will be moved
+             * out.
+             *
+             * @pre has_nested_buffers()
+             */
+            std::unique_ptr<Buffer> get_last_nested() {
+                assert(has_nested_buffers());
+                Buffer* buffer = this;
+                while (buffer->m_next_buffer->has_nested_buffers()) {
+                    buffer = buffer->m_next_buffer.get();
+                }
+                return std::move(buffer->m_next_buffer);
+            }
+
             /**
              * Mark currently written bytes in the buffer as committed.
              *
@@ -378,10 +469,10 @@ namespace osmium {
              */
             std::size_t clear() {
                 assert(m_builder_count == 0 && "Make sure there are no Builder objects still in scope");
-                const std::size_t committed = m_committed;
+                const std::size_t num_used_bytes = m_committed;
                 m_written = 0;
                 m_committed = 0;
-                return committed;
+                return num_used_bytes;
             }
 
             /**
@@ -397,6 +488,7 @@ namespace osmium {
             template <typename T>
             T& get(const std::size_t offset) const {
                 assert(m_data && "This must be a valid buffer");
+                assert(offset % alignof(T) == 0 && "Wrong alignment");
                 return *reinterpret_cast<T*>(&m_data[offset]);
             }
 
@@ -435,26 +527,26 @@ namespace osmium {
              */
             unsigned char* reserve_space(const std::size_t size) {
                 assert(m_data && "This must be a valid buffer");
-                // try to flush the buffer empty first.
-                if (m_written + size > m_capacity && m_full) {
-                    m_full(*this);
-                }
                 // if there's still not enough space, then try growing the buffer.
                 if (m_written + size > m_capacity) {
-                    if (m_memory && (m_auto_grow == auto_grow::yes)) {
+                    if (!m_memory || m_auto_grow == auto_grow::no) {
+                        throw osmium::buffer_is_full{};
+                    }
+                    if (m_auto_grow == auto_grow::internal && m_committed != 0) {
+                        grow_internal();
+                    }
+                    if (m_written + size > m_capacity) {
                         // double buffer size until there is enough space
                         std::size_t new_capacity = m_capacity * 2;
                         while (m_written + size > new_capacity) {
                             new_capacity *= 2;
                         }
                         grow(new_capacity);
-                    } else {
-                        throw osmium::buffer_is_full{};
                     }
                 }
-                unsigned char* data = &m_data[m_written];
+                unsigned char* reserved_space = &m_data[m_written];
                 m_written += size;
-                return data;
+                return reserved_space;
             }
 
             /**
@@ -590,6 +682,7 @@ namespace osmium {
             template <typename T>
             t_iterator<T> get_iterator(std::size_t offset) {
                 assert(m_data && "This must be a valid buffer");
+                assert(offset % alignof(T) == 0 && "Wrong alignment");
                 return {m_data + offset, m_data + m_committed};
             }
 
@@ -604,6 +697,7 @@ namespace osmium {
              */
             iterator get_iterator(std::size_t offset) {
                 assert(m_data && "This must be a valid buffer");
+                assert(offset % alignof(OSMEntity) == 0 && "Wrong alignment");
                 return {m_data + offset, m_data + m_committed};
             }
 
@@ -648,11 +742,13 @@ namespace osmium {
             template <typename T>
             t_const_iterator<T> get_iterator(std::size_t offset) const {
                 assert(m_data && "This must be a valid buffer");
+                assert(offset % alignof(T) == 0 && "Wrong alignment");
                 return {m_data + offset, m_data + m_committed};
             }
 
             const_iterator get_iterator(std::size_t offset) const {
                 assert(m_data && "This must be a valid buffer");
+                assert(offset % alignof(OSMEntity) == 0 && "Wrong alignment");
                 return {m_data + offset, m_data + m_committed};
             }
 
@@ -695,13 +791,13 @@ namespace osmium {
             void swap(Buffer& other) {
                 using std::swap;
 
+                swap(m_next_buffer, other.m_next_buffer);
                 swap(m_memory, other.m_memory);
                 swap(m_data, other.m_data);
                 swap(m_capacity, other.m_capacity);
                 swap(m_written, other.m_written);
                 swap(m_committed, other.m_committed);
                 swap(m_auto_grow, other.m_auto_grow);
-                swap(m_full, other.m_full);
             }
 
             /**
@@ -719,10 +815,13 @@ namespace osmium {
              * indexes.
              *
              * @pre The buffer must be valid.
+             * @pre @code callback != nullptr @endptr
              */
             template <typename TCallbackClass>
             void purge_removed(TCallbackClass* callback) {
                 assert(m_data && "This must be a valid buffer");
+                assert(callback);
+
                 if (begin() == end()) {
                     return;
                 }
@@ -750,6 +849,42 @@ namespace osmium {
                 m_committed = m_written;
             }
 
+            /**
+             * Purge removed items from the buffer. This is done by moving all
+             * non-removed items forward in the buffer overwriting removed
+             * items and then correcting the m_written and m_committed numbers.
+             *
+             * Note that calling this function invalidates all iterators on
+             * this buffer and all offsets in this buffer.
+             *
+             * @pre The buffer must be valid.
+             */
+            void purge_removed() {
+                assert(m_data && "This must be a valid buffer");
+                if (begin() == end()) {
+                    return;
+                }
+
+                iterator it_write = begin();
+
+                iterator next;
+                for (iterator it_read = begin(); it_read != end(); it_read = next) {
+                    next = std::next(it_read);
+                    if (!it_read->removed()) {
+                        if (it_read != it_write) {
+                            assert(it_read.data() >= data());
+                            assert(it_write.data() >= data());
+                            std::memmove(it_write.data(), it_read.data(), it_read->padded_size());
+                        }
+                        it_write.advance_once();
+                    }
+                }
+
+                assert(it_write.data() >= data());
+                m_written = static_cast<std::size_t>(it_write.data() - data());
+                m_committed = m_written;
+            }
+
         }; // class Buffer
 
         inline void swap(Buffer& lhs, Buffer& rhs) {
diff --git a/third_party/libosmium/include/osmium/memory/callback_buffer.hpp b/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
index 7dd291cb1..967d51b50 100644
--- a/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
+++ b/third_party/libosmium/include/osmium/memory/callback_buffer.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -76,8 +76,13 @@ namespace osmium {
 
         private:
 
-            static constexpr const std::size_t default_initial_buffer_size = 1024 * 1024;
-            static constexpr const std::size_t default_max_buffer_size     =  800 * 1024;
+            enum {
+                default_initial_buffer_size = 1024UL * 1024UL
+            };
+
+            enum {
+                default_max_buffer_size = 800UL * 1024UL
+            };
 
             osmium::memory::Buffer m_buffer;
             std::size_t m_initial_buffer_size;
@@ -174,10 +179,10 @@ namespace osmium {
              * callback.
              */
             osmium::memory::Buffer read() {
-                osmium::memory::Buffer buffer{m_initial_buffer_size, osmium::memory::Buffer::auto_grow::yes};
+                osmium::memory::Buffer new_buffer{m_initial_buffer_size, osmium::memory::Buffer::auto_grow::yes};
                 using std::swap;
-                swap(buffer, m_buffer);
-                return buffer;
+                swap(new_buffer, m_buffer);
+                return new_buffer;
             }
 
         }; // class CallbackBuffer
diff --git a/third_party/libosmium/include/osmium/memory/collection.hpp b/third_party/libosmium/include/osmium/memory/collection.hpp
index 5a98b1666..5219e7f53 100644
--- a/third_party/libosmium/include/osmium/memory/collection.hpp
+++ b/third_party/libosmium/include/osmium/memory/collection.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -75,7 +75,7 @@ namespace osmium {
             }
 
             CollectionIterator<TMember> operator++(int) {
-                CollectionIterator<TMember> tmp(*this);
+                CollectionIterator<TMember> tmp{*this};
                 operator++();
                 return tmp;
             }
@@ -85,7 +85,7 @@ namespace osmium {
             }
 
             bool operator!=(const CollectionIterator<TMember>& rhs) const noexcept {
-                return m_data != rhs.m_data;
+                return !(*this == rhs);
             }
 
             unsigned char* data() const noexcept {
@@ -113,6 +113,70 @@ namespace osmium {
             return out;
         }
 
+        template <typename TFilter, typename TMember>
+        class CollectionFilterIterator {
+
+            TFilter m_filter;
+            CollectionIterator<TMember> m_it;
+            CollectionIterator<TMember> m_end;
+
+            void advance() {
+                while (m_it != m_end) {
+                    if (m_filter(*m_it)) {
+                        break;
+                    }
+                    ++m_it;
+                }
+            }
+
+        public:
+
+            using iterator_category = std::forward_iterator_tag;
+            using value_type        = const TMember;
+            using difference_type   = std::ptrdiff_t;
+            using pointer           = value_type*;
+            using reference         = value_type&;
+
+            CollectionFilterIterator(TFilter filter, CollectionIterator<TMember> begin, CollectionIterator<TMember> end) :
+                m_filter(std::move(filter)),
+                m_it(begin),
+                m_end(end) {
+                advance();
+            }
+
+            CollectionFilterIterator& operator++() {
+                assert(m_it != m_end);
+                ++m_it;
+                advance();
+                return *this;
+            }
+
+            CollectionFilterIterator operator++(int) const {
+                CollectionFilterIterator tmp{*this};
+                operator++();
+                return tmp;
+            }
+
+            bool operator==(const CollectionFilterIterator& rhs) const noexcept {
+                return m_it == rhs.m_it && m_end == rhs.m_end;
+            }
+
+            bool operator!=(const CollectionFilterIterator& rhs) const noexcept {
+                return !(*this == rhs);
+            }
+
+            reference operator*() const noexcept {
+                assert(m_it != m_end);
+                return *m_it;
+            }
+
+            pointer operator->() const noexcept {
+                assert(m_it != m_end);
+                return &*m_it;
+            }
+
+        }; // class CollectionFilterIterator
+
         template <typename TMember, osmium::item_type TCollectionItemType>
         class Collection : public Item {
 
@@ -123,11 +187,11 @@ namespace osmium {
             using const_reference = const TMember&;
             using iterator        = CollectionIterator<TMember>;
             using const_iterator  = CollectionIterator<const TMember>;
-            using size_type       = size_t;
+            using size_type       = std::size_t;
 
             static constexpr osmium::item_type itemtype = TCollectionItemType;
 
-            constexpr static bool is_compatible_to(osmium::item_type t) noexcept {
+            constexpr static bool is_compatible_to(const osmium::item_type t) noexcept {
                 return t == itemtype;
             }
 
@@ -154,19 +218,19 @@ namespace osmium {
             }
 
             iterator begin() noexcept {
-                return iterator(data() + sizeof(Collection<TMember, TCollectionItemType>));
+                return iterator{data() + sizeof(Collection<TMember, TCollectionItemType>)};
             }
 
             iterator end() noexcept {
-                return iterator(data() + byte_size());
+                return iterator{data() + byte_size()};
             }
 
             const_iterator cbegin() const noexcept {
-                return const_iterator(data() + sizeof(Collection<TMember, TCollectionItemType>));
+                return const_iterator{data() + sizeof(Collection<TMember, TCollectionItemType>)};
             }
 
             const_iterator cend() const noexcept {
-                return const_iterator(data() + byte_size());
+                return const_iterator{data() + byte_size()};
             }
 
             const_iterator begin() const noexcept {
diff --git a/third_party/libosmium/include/osmium/memory/item.hpp b/third_party/libosmium/include/osmium/memory/item.hpp
index e938127cf..054067d20 100644
--- a/third_party/libosmium/include/osmium/memory/item.hpp
+++ b/third_party/libosmium/include/osmium/memory/item.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -57,7 +57,9 @@ namespace osmium {
         using item_size_type = uint32_t;
 
         // align datastructures to this many bytes
-        constexpr const std::size_t align_bytes = 8;
+        enum : std::size_t {
+            align_bytes = 8UL
+        };
 
         inline constexpr std::size_t padded_length(std::size_t length) noexcept {
             return (length + align_bytes - 1) & ~(align_bytes - 1);
@@ -123,7 +125,7 @@ namespace osmium {
 
         protected:
 
-            explicit Item(item_size_type size = 0, item_type type = item_type()) noexcept :
+            explicit Item(item_size_type size = 0, item_type type = item_type{}) noexcept :
                 m_size(size),
                 m_type(type),
                 m_removed(false),
@@ -174,7 +176,7 @@ namespace osmium {
                 return m_removed;
             }
 
-            void set_removed(bool removed) noexcept {
+            void set_removed(const bool removed) noexcept {
                 m_removed = removed;
             }
 
@@ -187,7 +189,7 @@ namespace osmium {
                 return diff_chars[m_diff];
             }
 
-            void set_diff(diff_indicator_type diff) noexcept {
+            void set_diff(const diff_indicator_type diff) noexcept {
                 m_diff = uint16_t(diff);
             }
 
diff --git a/third_party/libosmium/include/osmium/memory/item_iterator.hpp b/third_party/libosmium/include/osmium/memory/item_iterator.hpp
index 5cbe9cffc..9cca8a9dc 100644
--- a/third_party/libosmium/include/osmium/memory/item_iterator.hpp
+++ b/third_party/libosmium/include/osmium/memory/item_iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -49,7 +49,7 @@ namespace osmium {
         namespace detail {
 
             template <typename T>
-            constexpr inline bool type_is_compatible(osmium::item_type t) noexcept {
+            constexpr inline bool type_is_compatible(const osmium::item_type t) noexcept {
                 return T::is_compatible_to(t);
             }
 
@@ -120,7 +120,7 @@ namespace osmium {
             }
 
             ItemIterator<TMember> operator++(int) noexcept {
-                ItemIterator<TMember> tmp(*this);
+                ItemIterator<TMember> tmp{*this};
                 operator++();
                 return tmp;
             }
@@ -223,7 +223,7 @@ namespace osmium {
              *
              * Complexity: Linear in the number of items.
              */
-            size_t size() const noexcept {
+            std::size_t size() const noexcept {
                 if (m_begin == m_end) {
                     return 0;
                 }
diff --git a/third_party/libosmium/include/osmium/object_pointer_collection.hpp b/third_party/libosmium/include/osmium/object_pointer_collection.hpp
index e519903a1..c08c88b27 100644
--- a/third_party/libosmium/include/osmium/object_pointer_collection.hpp
+++ b/third_party/libosmium/include/osmium/object_pointer_collection.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,8 +36,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/handler.hpp>
 #include <osmium/osm/object.hpp>
 
-#include <boost/iterator/indirect_iterator.hpp>
-
 #include <algorithm>
 #include <utility>
 #include <vector>
@@ -46,6 +44,31 @@ DEALINGS IN THE SOFTWARE.
 
 namespace osmium {
 
+    template <typename TBaseIterator, typename TValue>
+    class indirect_iterator : public TBaseIterator {
+
+    public:
+
+        using iterator_category = std::random_access_iterator_tag;
+        using value_type        = TValue;
+        using difference_type   = std::ptrdiff_t;
+        using pointer           = value_type*;
+        using reference         = value_type&;
+
+        explicit indirect_iterator(TBaseIterator it) :
+            TBaseIterator(it) {
+        }
+
+        reference operator*() const noexcept {
+            return *TBaseIterator::operator*();
+        }
+
+        pointer operator->() const noexcept {
+            return &*TBaseIterator::operator*();
+        }
+
+    }; // class indirect_iterator
+
     /**
      * A collection of pointers to OSM objects. The pointers can be easily
      * and quickly sorted or otherwise manipulated, while the objects
@@ -71,8 +94,10 @@ namespace osmium {
 
     public:
 
-        using iterator       = boost::indirect_iterator<std::vector<osmium::OSMObject*>::iterator, osmium::OSMObject>;
-        using const_iterator = boost::indirect_iterator<std::vector<osmium::OSMObject*>::const_iterator, const osmium::OSMObject>;
+        using iterator       = indirect_iterator<std::vector<osmium::OSMObject*>::iterator, osmium::OSMObject>;
+        using const_iterator = indirect_iterator<std::vector<osmium::OSMObject*>::const_iterator, const osmium::OSMObject>;
+
+        using ptr_iterator = std::vector<osmium::OSMObject*>::iterator;
 
         ObjectPointerCollection() = default;
 
@@ -84,11 +109,12 @@ namespace osmium {
         }
 
         /**
-         * Sort objects according to the specified order functor.
+         * Sort objects according to the specified order functor. This function
+         * uses a stable sort.
          */
         template <typename TCompare>
         void sort(TCompare&& compare) {
-            std::sort(m_objects.begin(), m_objects.end(), std::forward<TCompare>(compare));
+            std::stable_sort(m_objects.begin(), m_objects.end(), std::forward<TCompare>(compare));
         }
 
         /**
@@ -126,19 +152,29 @@ namespace osmium {
         }
 
         iterator begin() {
-            return {m_objects.begin()};
+            return iterator{m_objects.begin()};
         }
 
         iterator end() {
-            return {m_objects.end()};
+            return iterator{m_objects.end()};
         }
 
         const_iterator cbegin() const {
-            return {m_objects.cbegin()};
+            return const_iterator{m_objects.cbegin()};
         }
 
         const_iterator cend() const {
-            return {m_objects.cend()};
+            return const_iterator{m_objects.cend()};
+        }
+
+        /// Access to begin of pointer vector.
+        ptr_iterator ptr_begin() noexcept {
+            return m_objects.begin();
+        }
+
+        /// Access to end of pointer vector.
+        ptr_iterator ptr_end() noexcept {
+            return m_objects.end();
         }
 
     }; // class ObjectPointerCollection
diff --git a/third_party/libosmium/include/osmium/opl.hpp b/third_party/libosmium/include/osmium/opl.hpp
index 52b705b33..60e70ef57 100644
--- a/third_party/libosmium/include/osmium/opl.hpp
+++ b/third_party/libosmium/include/osmium/opl.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,6 +36,8 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/io/detail/opl_parser_functions.hpp>
 #include <osmium/memory/buffer.hpp>
 
+#include <cassert>
+
 namespace osmium {
 
     /**
@@ -51,9 +53,9 @@ namespace osmium {
      * @throws osmium::opl_error If the parsing fails.
      */
     inline bool opl_parse(const char* data, osmium::memory::Buffer& buffer) {
+        assert(data);
         try {
             const bool wrote_something = osmium::io::detail::opl_parse_line(0, data, buffer);
-            buffer.commit();
             return wrote_something;
         } catch (const osmium::opl_error&) {
             buffer.rollback();
diff --git a/third_party/libosmium/include/osmium/osm.hpp b/third_party/libosmium/include/osmium/osm.hpp
index 30f024b40..3a17dbca7 100644
--- a/third_party/libosmium/include/osmium/osm.hpp
+++ b/third_party/libosmium/include/osmium/osm.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/area.hpp b/third_party/libosmium/include/osmium/osm/area.hpp
index 84b1b4916..2a986a6fe 100644
--- a/third_party/libosmium/include/osmium/osm/area.hpp
+++ b/third_party/libosmium/include/osmium/osm/area.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -41,7 +41,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/node_ref_list.hpp>
 #include <osmium/osm/object.hpp>
 #include <osmium/osm/types.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <cassert>
 #include <cstdlib>
@@ -149,7 +148,7 @@ namespace osmium {
          * Complexity: Constant.
          */
         bool from_way() const noexcept {
-            return (positive_id() & 0x1u) == 0;
+            return (positive_id() & 0x1U) == 0;
         }
 
         /**
@@ -202,38 +201,12 @@ namespace osmium {
 
         /**
          * Check whether this area is a multipolygon, ie. whether it has more
-         * than one outer ring?
+         * than one outer ring.
          */
         bool is_multipolygon() const {
             return num_rings().first > 1;
         }
 
-        /**
-         * @deprecated Use inner_rings() instead.
-         *
-         * Get iterator for iterating over all inner rings in a specified outer
-         * ring.
-         *
-         * @param it Iterator specifying outer ring.
-         * @returns Iterator to first inner ring in specified outer ring.
-         */
-        OSMIUM_DEPRECATED osmium::memory::ItemIterator<const osmium::InnerRing> inner_ring_cbegin(const osmium::memory::ItemIterator<const osmium::OuterRing>& it) const {
-            return it.cast<const osmium::InnerRing>();
-        }
-
-        /**
-         * @deprecated Use inner_rings() instead.
-         *
-         * Get iterator for iterating over all inner rings in a specified outer
-         * ring.
-         *
-         * @param it Iterator specifying outer ring.
-         * @returns Iterator one past last inner ring in specified outer ring.
-         */
-        OSMIUM_DEPRECATED osmium::memory::ItemIterator<const osmium::InnerRing> inner_ring_cend(const osmium::memory::ItemIterator<const osmium::OuterRing>& it) const {
-            return std::next(it).cast<const osmium::InnerRing>();
-        }
-
         /**
          * Return an iterator range for all outer rings.
          * You can use the usual begin() and end() functions to iterate over
diff --git a/third_party/libosmium/include/osmium/osm/box.hpp b/third_party/libosmium/include/osmium/osm/box.hpp
index 7eb331ac8..da222685d 100644
--- a/third_party/libosmium/include/osmium/osm/box.hpp
+++ b/third_party/libosmium/include/osmium/osm/box.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -60,7 +60,7 @@ namespace osmium {
         constexpr Box() noexcept = default;
 
         /**
-         * Create box from minimum and maximum coordinates.
+         * Create box from minimum and maximum coordinates in WGS84.
          *
          * @pre @code minx <= maxx && miny <= maxy @endcode
          */
@@ -84,8 +84,7 @@ namespace osmium {
             m_top_right(top_right) {
             assert(
                 (!!bottom_left && !!top_right) ||
-                (bottom_left.x() <= top_right.x() && bottom_left.y() <= top_right.y())
-            );
+                (bottom_left.x() <= top_right.x() && bottom_left.y() <= top_right.y()));
         }
 
         /**
@@ -176,6 +175,46 @@ namespace osmium {
             return m_top_right;
         }
 
+        /**
+         * Get left boundary.
+         *
+         * @pre @code valid() == true @encode
+         */
+        double left() const noexcept {
+            assert(valid());
+            return m_bottom_left.lon_without_check();
+        }
+
+        /**
+         * Get right boundary.
+         *
+         * @pre @code valid() == true @encode
+         */
+        double right() const noexcept {
+            assert(valid());
+            return m_top_right.lon_without_check();
+        }
+
+        /**
+         * Get top boundary.
+         *
+         * @pre @code valid() == true @encode
+         */
+        double top() const noexcept {
+            assert(valid());
+            return m_top_right.lat_without_check();
+        }
+
+        /**
+         * Get bottom boundary.
+         *
+         * @pre @code valid() == true @encode
+         */
+        double bottom() const noexcept {
+            assert(valid());
+            return m_bottom_left.lat_without_check();
+        }
+
         /**
          * Check whether the location is inside the box.
          *
@@ -223,15 +262,11 @@ namespace osmium {
     template <typename TChar, typename TTraits>
     inline std::basic_ostream<TChar, TTraits>& operator<<(std::basic_ostream<TChar, TTraits>& out, const osmium::Box& box) {
         if (box) {
-            out << '('
-                << box.bottom_left().lon()
-                << ','
-                << box.bottom_left().lat()
-                << ','
-                << box.top_right().lon()
-                << ','
-                << box.top_right().lat()
-                << ')';
+            out << '(';
+            box.bottom_left().as_string_without_check(std::ostream_iterator<char>(out));
+            out << ',';
+            box.top_right().as_string_without_check(std::ostream_iterator<char>(out));
+            out << ')';
         } else {
             out << "(undefined)";
         }
diff --git a/third_party/libosmium/include/osmium/osm/changeset.hpp b/third_party/libosmium/include/osmium/osm/changeset.hpp
index fab004302..334a94a32 100644
--- a/third_party/libosmium/include/osmium/osm/changeset.hpp
+++ b/third_party/libosmium/include/osmium/osm/changeset.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -80,7 +80,7 @@ namespace osmium {
             return endpos();
         }
 
-        unsigned const char* next() const {
+        const unsigned char* next() const {
             return endpos();
         }
 
@@ -366,6 +366,11 @@ namespace osmium {
             return reinterpret_cast<const char*>(data() + sizeof(Changeset));
         }
 
+        /// Clear user name.
+        void clear_user() noexcept {
+            std::memset(data() + sizeof(Changeset), 0, user_size());
+        }
+
         /// Get the list of tags.
         const TagList& tags() const {
             return osmium::detail::subitem_of_type<const TagList>(cbegin(), cend());
diff --git a/third_party/libosmium/include/osmium/osm/crc.hpp b/third_party/libosmium/include/osmium/osm/crc.hpp
index fd40ccdba..0019395d8 100644
--- a/third_party/libosmium/include/osmium/osm/crc.hpp
+++ b/third_party/libosmium/include/osmium/osm/crc.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -83,8 +83,21 @@ namespace osmium {
 #endif
         }
 
-    } // inline namespace util
+    } // namespace util
 
+    /**
+     * Framework for computing a checksum from OSM data. This class must be
+     * instantiated with a policy class that does the actual CRC calculations.
+     * It must have the process_byte(), process_bytes(), and checksum()
+     * member functions implemented according to the description in Boost
+     * (https://www.boost.org/doc/libs/release/libs/crc/crc.html).
+     *
+     * Typically you will either use the boost::crc_32_type from the Boost
+     * CRC library or the osmium::CRC_zlib class which uses the zlib library
+     * for this, but other checksums are possible.
+     *
+     * @tparam TCRC A CRC type.
+     */
     template <typename TCRC>
     class CRC {
 
@@ -156,7 +169,7 @@ namespace osmium {
         }
 
         void update(const NodeRef& node_ref) noexcept {
-            update_int64(node_ref.ref());
+            update_int64(static_cast<uint64_t>(node_ref.ref()));
             update(node_ref.location());
         }
 
@@ -174,7 +187,7 @@ namespace osmium {
         }
 
         void update(const osmium::RelationMember& member) noexcept {
-            update_int64(member.ref());
+            update_int64(static_cast<uint64_t>(member.ref()));
             update_int16(uint16_t(member.type()));
             update_string(member.role());
         }
@@ -185,8 +198,10 @@ namespace osmium {
             }
         }
 
+        // XXX Changeset id is not added to the CRC. This is an oversight,
+        // but we don't want to change this now to keep compatibility.
         void update(const osmium::OSMObject& object) noexcept {
-            update_int64(object.id());
+            update_int64(static_cast<uint64_t>(object.id()));
             update_bool(object.visible());
             update_int32(object.version());
             update(object.timestamp());
@@ -230,7 +245,9 @@ namespace osmium {
         }
 
         void update(const osmium::Changeset& changeset) noexcept {
-            update_int64(changeset.id());
+            // The static_cast and use of update_int64 is necessary here
+            // for backwards compatibility. It should have used update_int32.
+            update_int64(static_cast<uint64_t>(changeset.id()));
             update(changeset.created_at());
             update(changeset.closed_at());
             update(changeset.bounds());
diff --git a/third_party/libosmium/include/osmium/osm/crc_zlib.hpp b/third_party/libosmium/include/osmium/osm/crc_zlib.hpp
new file mode 100644
index 000000000..4d3776cb1
--- /dev/null
+++ b/third_party/libosmium/include/osmium/osm/crc_zlib.hpp
@@ -0,0 +1,77 @@
+#ifndef OSMIUM_OSM_CRC_ZLIB_HPP
+#define OSMIUM_OSM_CRC_ZLIB_HPP
+
+/*
+
+This file is part of Osmium (https://osmcode.org/libosmium).
+
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
+
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+*/
+
+#include <zlib.h>
+
+#include <cstddef>
+
+namespace osmium {
+
+    /**
+     * This class is used together with the CRC class to implement a CRC32
+     * checksum based on the implementation from zlib.
+     *
+     * Usage:
+     *
+     * @code
+     * osmium::CRC<osmium::CRC_zlib> crc32;
+     * const osmium::Node& node = ...;
+     * crc32.update(node);
+     * std::cout << crc32.checksum() << '\n';
+     * @endcode
+     */
+    class CRC_zlib {
+
+        unsigned long m_crc32 = ::crc32(0, nullptr, 0); // NOLINT(google-runtime-int)
+
+    public:
+
+        void process_byte(const unsigned char byte) noexcept {
+            m_crc32 = ::crc32(m_crc32, &byte, 1U);
+        }
+
+        void process_bytes(const void* buffer, std::size_t byte_count) noexcept {
+            m_crc32 = ::crc32(m_crc32, reinterpret_cast<const unsigned char*>(buffer), static_cast<unsigned int>(byte_count));
+        }
+
+        unsigned long checksum() const noexcept { // NOLINT(google-runtime-int)
+            return m_crc32;
+        }
+
+    }; // class CRC_zlib
+
+} // namespace osmium
+
+#endif // OSMIUM_OSM_CRC_ZLIB_HPP
diff --git a/third_party/libosmium/include/osmium/osm/diff_object.hpp b/third_party/libosmium/include/osmium/osm/diff_object.hpp
index 0e3ff3612..3dddcbeb7 100644
--- a/third_party/libosmium/include/osmium/osm/diff_object.hpp
+++ b/third_party/libosmium/include/osmium/osm/diff_object.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -192,7 +192,7 @@ namespace osmium {
          *
          * @pre DiffObject must not be empty.
          */
-        const osmium::Timestamp start_time() const noexcept {
+        osmium::Timestamp start_time() const noexcept {
             assert(m_prev && m_curr && m_next);
             return m_curr->timestamp();
         }
@@ -206,7 +206,7 @@ namespace osmium {
          *
          * @pre DiffObject must not be empty.
          */
-        const osmium::Timestamp end_time() const noexcept {
+        osmium::Timestamp end_time() const noexcept {
             assert(m_prev && m_curr && m_next);
             return last() ? osmium::end_of_time() : m_next->timestamp();
         }
diff --git a/third_party/libosmium/include/osmium/osm/entity.hpp b/third_party/libosmium/include/osmium/osm/entity.hpp
index 4f83462fa..92c68e757 100644
--- a/third_party/libosmium/include/osmium/osm/entity.hpp
+++ b/third_party/libosmium/include/osmium/osm/entity.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -44,14 +44,14 @@ namespace osmium {
         template <typename TSubitem, typename TIter>
         inline TSubitem& subitem_of_type(TIter it, const TIter& end) {
             for (; it != end; ++it) {
-                if (TSubitem::is_compatible_to(it->type())) {
+                if (TSubitem::is_compatible_to(it->type()) && !it->removed()) {
                     return reinterpret_cast<TSubitem&>(*it);
                 }
             }
 
             // If no subitem of the TSubitem type was found,
             // return a default constructed one.
-            static TSubitem subitem{};
+            static TSubitem subitem;
             return subitem;
         }
 
diff --git a/third_party/libosmium/include/osmium/osm/entity_bits.hpp b/third_party/libosmium/include/osmium/osm/entity_bits.hpp
index 27848a3fc..cd3edd1a4 100644
--- a/third_party/libosmium/include/osmium/osm/entity_bits.hpp
+++ b/third_party/libosmium/include/osmium/osm/entity_bits.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -111,7 +111,7 @@ namespace osmium {
             if (ut == 0) {
                 return nothing;
             }
-            return static_cast<osmium::osm_entity_bits::type>(1u << (ut - 1u));
+            return static_cast<osmium::osm_entity_bits::type>(1U << (ut - 1U));
         }
 
     } // namespace osm_entity_bits
diff --git a/third_party/libosmium/include/osmium/osm/item_type.hpp b/third_party/libosmium/include/osmium/osm/item_type.hpp
index 4c8f7e1a6..804d10a0b 100644
--- a/third_party/libosmium/include/osmium/osm/item_type.hpp
+++ b/third_party/libosmium/include/osmium/osm/item_type.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,8 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <osmium/util/compatibility.hpp>
+
 #include <cassert>
 #include <cstdint> // IWYU pragma: keep
 #include <iosfwd>
@@ -192,10 +194,10 @@ namespace osmium {
      * probably means the buffer contains different kinds of objects than were
      * expected or that there is some kind of data corruption.
      */
-    struct unknown_type : public std::runtime_error {
+    struct OSMIUM_EXPORT unknown_type : public std::runtime_error {
 
         unknown_type() :
-            std::runtime_error("unknown item type") {
+            std::runtime_error{"unknown item type"} {
         }
 
     }; // struct unknown_type
diff --git a/third_party/libosmium/include/osmium/osm/location.hpp b/third_party/libosmium/include/osmium/osm/location.hpp
index af9f01f9e..fa3d03724 100644
--- a/third_party/libosmium/include/osmium/osm/location.hpp
+++ b/third_party/libosmium/include/osmium/osm/location.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -64,7 +64,9 @@ namespace osmium {
 
     namespace detail {
 
-        constexpr const int coordinate_precision = 10000000;
+        enum {
+            coordinate_precision = 10000000
+        };
 
         // Convert string with a floating point number into integer suitable
         // for use as coordinate in a Location.
@@ -93,7 +95,7 @@ namespace osmium {
                     result = *str - '0';
                     ++str;
                 } else {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
 
                 // optional additional digits before decimal point
@@ -104,13 +106,13 @@ namespace osmium {
                 }
 
                 if (max_digits == 0) {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
             } else {
                 // need at least one digit after decimal dot if there was no
                 // digit before decimal dot
                 if (*(str + 1) < '0' || *(str + 1) > '9') {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
             }
 
@@ -131,7 +133,7 @@ namespace osmium {
                 }
 
                 if (max_digits == 0) {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
             }
 
@@ -153,7 +155,7 @@ namespace osmium {
                     eresult = *str - '0';
                     ++str;
                 } else {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
 
                 // optional additional digits in exponent
@@ -165,7 +167,7 @@ namespace osmium {
                 }
 
                 if (max_digits == 0) {
-                    goto error;
+                    throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
                 }
 
                 scale += eresult * esign;
@@ -185,15 +187,11 @@ namespace osmium {
 
             if (result > std::numeric_limits<int32_t>::max() ||
                 result < std::numeric_limits<int32_t>::min()) {
-                goto error;
+                throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
             }
 
             *data = str;
             return static_cast<int32_t>(result);
-
-        error:
-
-            throw invalid_location{std::string{"wrong format for coordinate: '"} + full + "'"};
         }
 
         // Convert integer as used by location for coordinates into a string.
@@ -216,7 +214,7 @@ namespace osmium {
             char temp[10];
             char* t = temp;
             do {
-                *t++ = char(v % 10) + '0';
+                *t++ = static_cast<char>(v % 10) + '0'; // NOLINT(bugprone-narrowing-conversions, cppcoreguidelines-narrowing-conversions)
                 v /= 10;
             } while (v != 0);
 
@@ -272,23 +270,29 @@ namespace osmium {
      */
     class Location {
 
-        int32_t m_x;
-        int32_t m_y;
+        int32_t m_x; // NOLINT(modernize-use-default-member-init)
+        int32_t m_y; // NOLINT(modernize-use-default-member-init)
+
+        constexpr static double precision() noexcept {
+            return static_cast<double>(detail::coordinate_precision);
+        }
 
     public:
 
         // this value is used for a coordinate to mark it as undefined
         // MSVC doesn't declare std::numeric_limits<int32_t>::max() as
         // constexpr, so we hard code this for the time being.
-        // static constexpr int32_t undefined_coordinate = std::numeric_limits<int32_t>::max();
-        static constexpr int32_t undefined_coordinate = 2147483647;
+        // undefined_coordinate = std::numeric_limits<int32_t>::max();
+        enum {
+            undefined_coordinate = 2147483647
+        };
 
         static int32_t double_to_fix(const double c) noexcept {
-            return static_cast<int32_t>(std::round(c * detail::coordinate_precision));
+            return static_cast<int32_t>(std::round(c * precision()));
         }
 
         static constexpr double fix_to_double(const int32_t c) noexcept {
-            return static_cast<double>(c) / detail::coordinate_precision;
+            return static_cast<double>(c) / precision();
         }
 
         /**
@@ -320,7 +324,8 @@ namespace osmium {
         }
 
         /**
-         * Create Location with given longitude and latitude.
+         * Create Location with given longitude and latitude in WGS84
+         * coordinates.
          */
         Location(const double lon, const double lat) :
             m_x(double_to_fix(lon)),
@@ -345,10 +350,10 @@ namespace osmium {
          * See also is_defined() and is_undefined().
          */
         constexpr bool valid() const noexcept {
-            return m_x >= -180 * detail::coordinate_precision
-                && m_x <=  180 * detail::coordinate_precision
-                && m_y >=  -90 * detail::coordinate_precision
-                && m_y <=   90 * detail::coordinate_precision;
+            return m_x >= -180 * precision()
+                && m_x <=  180 * precision()
+                && m_y >=  -90 * precision()
+                && m_y <=   90 * precision();
         }
 
         /**
@@ -402,7 +407,7 @@ namespace osmium {
         /**
          * Get longitude without checking the validity.
          */
-        double lon_without_check() const {
+        double lon_without_check() const noexcept {
             return fix_to_double(m_x);
         }
 
@@ -421,7 +426,7 @@ namespace osmium {
         /**
          * Get latitude without checking the validity.
          */
-        double lat_without_check() const {
+        double lat_without_check() const noexcept {
             return fix_to_double(m_y);
         }
 
@@ -539,7 +544,7 @@ namespace osmium {
         template <>
         inline size_t hash<8>(const osmium::Location& location) noexcept {
             uint64_t h = location.x();
-            h <<= 32;
+            h <<= 32U;
             return static_cast<size_t>(h ^ static_cast<uint64_t>(location.y()));
         }
 
diff --git a/third_party/libosmium/include/osmium/osm/metadata_options.hpp b/third_party/libosmium/include/osmium/osm/metadata_options.hpp
index ccb708612..b134c6cc2 100644
--- a/third_party/libosmium/include/osmium/osm/metadata_options.hpp
+++ b/third_party/libosmium/include/osmium/osm/metadata_options.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -43,9 +43,10 @@ DEALINGS IN THE SOFTWARE.
 namespace osmium {
 
     /**
-     * Describes which metadata fields are available in an OSMObject. This is most often used to
-     * describe which metadata fields are available in the objects of an OSM file or which
-     * metadata information should be written to an OSM file.
+     * Describes which metadata fields are available in an OSMObject. This is
+     * most often used to describe which metadata fields are available in the
+     * objects of an OSM file or which metadata information should be written
+     * to an OSM file.
      */
     class metadata_options {
 
@@ -73,7 +74,7 @@ namespace osmium {
             }
 
             const auto attrs = osmium::split_string(attributes, '+', true);
-            int opts = 0;
+            unsigned int opts = 0;
             for (const auto& attr : attrs) {
                 if (attr == "version") {
                     opts |= options::md_version;
@@ -207,7 +208,7 @@ namespace osmium {
             }
 
             if (user()) {
-                 result += "user+";
+                result += "user+";
             }
 
             // remove last '+' character
diff --git a/third_party/libosmium/include/osmium/osm/node.hpp b/third_party/libosmium/include/osmium/osm/node.hpp
index 40a223bba..ab68e09d1 100644
--- a/third_party/libosmium/include/osmium/osm/node.hpp
+++ b/third_party/libosmium/include/osmium/osm/node.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/node_ref.hpp b/third_party/libosmium/include/osmium/osm/node_ref.hpp
index 4c782ffd2..7de91cad2 100644
--- a/third_party/libosmium/include/osmium/osm/node_ref.hpp
+++ b/third_party/libosmium/include/osmium/osm/node_ref.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/node_ref_list.hpp b/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
index da84cc1ae..60213af49 100644
--- a/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
+++ b/third_party/libosmium/include/osmium/osm/node_ref_list.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -149,6 +149,7 @@ namespace osmium {
          * @pre @code !empty() @endcode
          */
         bool is_closed() const noexcept {
+            assert(!empty());
             return ends_have_same_id();
         }
 
@@ -161,6 +162,7 @@ namespace osmium {
          * @pre @code !empty() @endcode
          */
         bool ends_have_same_id() const noexcept {
+            assert(!empty());
             return front().ref() == back().ref();
         }
 
@@ -174,6 +176,7 @@ namespace osmium {
          * @pre @code front().location() && back().location() @endcode
          */
         bool ends_have_same_location() const {
+            assert(!empty());
             assert(front().location() && back().location());
             return front().location() == back().location();
         }
diff --git a/third_party/libosmium/include/osmium/osm/object.hpp b/third_party/libosmium/include/osmium/osm/object.hpp
index 14cac072c..fb948adee 100644
--- a/third_party/libosmium/include/osmium/osm/object.hpp
+++ b/third_party/libosmium/include/osmium/osm/object.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -105,10 +105,6 @@ namespace osmium {
             m_version(0) {
         }
 
-        void set_user_size(string_size_type size) {
-            *reinterpret_cast<string_size_type*>(user_position()) = size;
-        }
-
     public:
 
         constexpr static bool is_compatible_to(osmium::item_type t) noexcept {
@@ -304,11 +300,16 @@ namespace osmium {
          *
          * @param timestamp Timestamp in ISO format.
          * @returns Reference to object to make calls chainable.
+         * @throws std::invalid_argment if the timestamp isn't a correctly ISO
+         *                              formatted string with the Z timezone.
+         *
+         * @pre @code timestamp != nullptr @endcode
          */
         OSMObject& set_timestamp(const char* timestamp) {
+            assert(timestamp);
             m_timestamp = detail::parse_timestamp(timestamp);
             if (timestamp[20] != '\0') {
-                throw std::invalid_argument{"can not parse timestamp"};
+                throw std::invalid_argument{"can not parse timestamp: garbage after timestamp"};
             }
             return *this;
         }
@@ -318,6 +319,11 @@ namespace osmium {
             return reinterpret_cast<const char*>(data() + sizeof_object());
         }
 
+        /// Clear user name.
+        void clear_user() noexcept {
+            std::memset(data() + sizeof_object(), 0, user_size());
+        }
+
         /// Get the list of tags for this object.
         const TagList& tags() const {
             return osmium::detail::subitem_of_type<const TagList>(cbegin(), cend());
@@ -361,6 +367,20 @@ namespace osmium {
         using iterator       = osmium::memory::CollectionIterator<Item>;
         using const_iterator = osmium::memory::CollectionIterator<const Item>;
 
+        /**
+         * Remove all tags from this object.
+         *
+         * (This will not change the size of the object, the tags are simply
+         * marked as removed.)
+         */
+        void remove_tags() noexcept {
+            for (auto& subitem : *this) {
+                if (subitem.type() == osmium::item_type::tag_list) {
+                    subitem.set_removed(true);
+                }
+            }
+        }
+
         iterator begin() {
             return iterator(subitems_position());
         }
diff --git a/third_party/libosmium/include/osmium/osm/object_comparisons.hpp b/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
index 2dce5d266..c1be95088 100644
--- a/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
+++ b/third_party/libosmium/include/osmium/osm/object_comparisons.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -87,8 +87,24 @@ namespace osmium {
     struct id_order {
 
         bool operator()(const object_id_type lhs, const object_id_type rhs) const noexcept {
-            return const_tie(lhs > 0, std::abs(lhs)) <
-                   const_tie(rhs > 0, std::abs(rhs));
+            if (rhs == 0) {
+                return false;
+            }
+            if (lhs == 0) {
+                return true;
+            }
+            if (lhs < 0) {
+                if (rhs > 0) {
+                    return true;
+                }
+                // rhs < 0
+                return lhs > rhs;
+            }
+            // lhs > 0
+            if (rhs < 0) {
+                return false;
+            }
+            return lhs < rhs;
         }
 
     }; // struct id_order
diff --git a/third_party/libosmium/include/osmium/osm/relation.hpp b/third_party/libosmium/include/osmium/osm/relation.hpp
index b9742e009..e06c100f2 100644
--- a/third_party/libosmium/include/osmium/osm/relation.hpp
+++ b/third_party/libosmium/include/osmium/osm/relation.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -39,7 +39,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/object.hpp>
 #include <osmium/osm/types.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <cstdint>
 #include <cstdlib>
@@ -81,7 +80,7 @@ namespace osmium {
             return endpos();
         }
 
-        unsigned const char* next() const {
+        const unsigned char* next() const {
             if (full_member()) {
                 return endpos() + reinterpret_cast<const osmium::memory::Item*>(endpos())->byte_size();
             }
@@ -114,12 +113,6 @@ namespace osmium {
             return m_ref;
         }
 
-        /// @deprecated Use set_ref() instead.
-        OSMIUM_DEPRECATED RelationMember& ref(object_id_type ref) noexcept {
-            m_ref = ref;
-            return *this;
-        }
-
         unsigned_object_id_type positive_ref() const noexcept {
             return static_cast<unsigned_object_id_type>(std::abs(m_ref));
         }
diff --git a/third_party/libosmium/include/osmium/osm/segment.hpp b/third_party/libosmium/include/osmium/osm/segment.hpp
index 07c05f6b8..81b15a8b0 100644
--- a/third_party/libosmium/include/osmium/osm/segment.hpp
+++ b/third_party/libosmium/include/osmium/osm/segment.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/tag.hpp b/third_party/libosmium/include/osmium/osm/tag.hpp
index af4fc507b..c07753aea 100644
--- a/third_party/libosmium/include/osmium/osm/tag.hpp
+++ b/third_party/libosmium/include/osmium/osm/tag.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -50,19 +50,19 @@ namespace osmium {
         template <typename TMember>
         friend class osmium::memory::CollectionIterator;
 
-        static unsigned char* after_null(unsigned char* ptr) {
+        static unsigned char* after_null(unsigned char* ptr) noexcept {
             return reinterpret_cast<unsigned char*>(std::strchr(reinterpret_cast<char*>(ptr), 0) + 1);
         }
 
-        static const unsigned char* after_null(const unsigned char* ptr) {
+        static const unsigned char* after_null(const unsigned char* ptr) noexcept {
             return reinterpret_cast<const unsigned char*>(std::strchr(reinterpret_cast<const char*>(ptr), 0) + 1);
         }
 
-        unsigned char* next() {
+        unsigned char* next() noexcept {
             return after_null(after_null(data()));
         }
 
-        const unsigned char* next() const {
+        const unsigned char* next() const noexcept {
             return after_null(after_null(data()));
         }
 
@@ -78,22 +78,32 @@ namespace osmium {
 
         static constexpr item_type collection_type = item_type::tag_list;
 
+        /**
+         * Get a pointer to the C string containing the tag key.
+         *
+         * Complexity: Constant.
+         */
         const char* key() const noexcept {
             return reinterpret_cast<const char*>(data());
         }
 
-        const char* value() const {
+        /**
+         * Get a pointer to the C string containing the tag value.
+         *
+         * Complexity: Linear on the number of characters in the key!
+         */
+        const char* value() const noexcept {
             return reinterpret_cast<const char*>(after_null(data()));
         }
 
     }; // class Tag
 
-    inline bool operator==(const Tag& lhs, const Tag& rhs) {
+    inline bool operator==(const Tag& lhs, const Tag& rhs) noexcept {
         return !std::strcmp(lhs.key(), rhs.key()) &&
                !std::strcmp(lhs.value(), rhs.value());
     }
 
-    inline bool operator<(const Tag& lhs, const Tag& rhs) {
+    inline bool operator<(const Tag& lhs, const Tag& rhs) noexcept {
         const auto c = std::strcmp(lhs.key(), rhs.key());
         return (c == 0 ? std::strcmp(lhs.value(), rhs.value()) : c) < 0;
     }
diff --git a/third_party/libosmium/include/osmium/osm/timestamp.hpp b/third_party/libosmium/include/osmium/osm/timestamp.hpp
index 54c0ae64d..5fbe9ba05 100644
--- a/third_party/libosmium/include/osmium/osm/timestamp.hpp
+++ b/third_party/libosmium/include/osmium/osm/timestamp.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,9 +33,9 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/util/compatibility.hpp>
 #include <osmium/util/minmax.hpp> // IWYU pragma: keep
 
+#include <array>
 #include <cassert>
 #include <cstdint>
 #include <ctime>
@@ -80,10 +80,11 @@ namespace osmium {
         }
 
         inline time_t parse_timestamp(const char* str) {
-            static const int mon_lengths[] = {
+            static const std::array<int, 12> mon_lengths = {{
                 31, 29, 31, 30, 31, 30,
                 31, 31, 30, 31, 30, 31
-            };
+            }};
+
             if (str[ 0] >= '0' && str[ 0] <= '9' &&
                 str[ 1] >= '0' && str[ 1] <= '9' &&
                 str[ 2] >= '0' && str[ 2] <= '9' &&
@@ -104,7 +105,7 @@ namespace osmium {
                 str[17] >= '0' && str[17] <= '9' &&
                 str[18] >= '0' && str[18] <= '9' &&
                 str[19] == 'Z') {
-                struct tm tm;
+                std::tm tm; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
                 tm.tm_year = (str[ 0] - '0') * 1000 +
                              (str[ 1] - '0') *  100 +
                              (str[ 2] - '0') *   10 +
@@ -130,7 +131,7 @@ namespace osmium {
 #endif
                 }
             }
-            throw std::invalid_argument{"can not parse timestamp"};
+            throw std::invalid_argument{std::string{"can not parse timestamp: '"} + str + "'"};
         }
 
     } // namespace detail
@@ -146,6 +147,34 @@ namespace osmium {
 
         uint32_t m_timestamp = 0;
 
+        void to_iso_str(std::string& s) const {
+            std::tm tm; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init)
+            time_t sse = seconds_since_epoch();
+#ifndef NDEBUG
+            auto result =
+#endif
+#ifndef _WIN32
+            gmtime_r(&sse, &tm);
+            assert(result != nullptr);
+#else
+            gmtime_s(&tm, &sse);
+            assert(result == 0);
+#endif
+
+            detail::add_4digit_int_to_string(tm.tm_year + 1900, s);
+            s += '-';
+            detail::add_2digit_int_to_string(tm.tm_mon + 1, s);
+            s += '-';
+            detail::add_2digit_int_to_string(tm.tm_mday, s);
+            s += 'T';
+            detail::add_2digit_int_to_string(tm.tm_hour, s);
+            s += ':';
+            detail::add_2digit_int_to_string(tm.tm_min, s);
+            s += ':';
+            detail::add_2digit_int_to_string(tm.tm_sec, s);
+            s += 'Z';
+        }
+
     public:
 
         /**
@@ -173,8 +202,8 @@ namespace osmium {
          *
          * @throws std::invalid_argument if the timestamp can not be parsed.
          */
-        explicit Timestamp(const char* timestamp) {
-            m_timestamp = static_cast<uint32_t>(detail::parse_timestamp(timestamp));
+        explicit Timestamp(const char* timestamp) :
+            m_timestamp(static_cast<uint32_t>(detail::parse_timestamp(timestamp))) {
         }
 
         /**
@@ -215,15 +244,6 @@ namespace osmium {
             return uint64_t(m_timestamp);
         }
 
-        /**
-         * Implicit conversion into time_t.
-         *
-         * @deprecated You should call seconds_since_epoch() explicitly instead.
-         */
-        OSMIUM_DEPRECATED constexpr operator time_t() const noexcept { // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
-            return static_cast<time_t>(m_timestamp);
-        }
-
         template <typename T>
         void operator+=(T time_difference) noexcept {
             m_timestamp += time_difference;
@@ -243,36 +263,25 @@ namespace osmium {
             std::string s;
 
             if (m_timestamp != 0) {
-                struct tm tm;
-                time_t sse = seconds_since_epoch();
-#ifndef NDEBUG
-                auto result =
-#endif
-#ifndef _WIN32
-                gmtime_r(&sse, &tm);
-                assert(result != nullptr);
-#else
-                gmtime_s(&tm, &sse);
-                assert(result == 0);
-#endif
-
-                detail::add_4digit_int_to_string(tm.tm_year + 1900, s);
-                s += '-';
-                detail::add_2digit_int_to_string(tm.tm_mon + 1, s);
-                s += '-';
-                detail::add_2digit_int_to_string(tm.tm_mday, s);
-                s += 'T';
-                detail::add_2digit_int_to_string(tm.tm_hour, s);
-                s += ':';
-                detail::add_2digit_int_to_string(tm.tm_min, s);
-                s += ':';
-                detail::add_2digit_int_to_string(tm.tm_sec, s);
-                s += 'Z';
+                to_iso_str(s);
             }
 
             return s;
         }
 
+        /**
+         * Return the timestamp as string in ISO date/time
+         * ("yyyy-mm-ddThh:mm:ssZ") format. If the timestamp is invalid, the
+         * string "1970-01-01T00:00:00Z" will be returned.
+         */
+        std::string to_iso_all() const {
+            std::string s;
+
+            to_iso_str(s);
+
+            return s;
+        }
+
     }; // class Timestamp
 
     /**
diff --git a/third_party/libosmium/include/osmium/osm/types.hpp b/third_party/libosmium/include/osmium/osm/types.hpp
index fbd1dcf02..2b7566bd0 100644
--- a/third_party/libosmium/include/osmium/osm/types.hpp
+++ b/third_party/libosmium/include/osmium/osm/types.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -65,8 +65,10 @@ namespace osmium {
      */
     using changeset_comment_size_type = uint32_t;
 
-    // maximum of 256 characters of max 4 bytes each (in UTF-8 encoding)
-    constexpr const int max_osm_string_length = 256 * 4;
+    /// Maximum of 256 characters of max 4 bytes each (in UTF-8 encoding)
+    enum {
+        max_osm_string_length = 256 * 4
+    };
 
 } // namespace osmium
 
diff --git a/third_party/libosmium/include/osmium/osm/types_from_string.hpp b/third_party/libosmium/include/osmium/osm/types_from_string.hpp
index d1d9038ae..c60d9bb32 100644
--- a/third_party/libosmium/include/osmium/osm/types_from_string.hpp
+++ b/third_party/libosmium/include/osmium/osm/types_from_string.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,7 +36,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/entity_bits.hpp>
 #include <osmium/osm/item_type.hpp>
 #include <osmium/osm/types.hpp>
-#include <osmium/util/compatibility.hpp>
 
 #include <cassert>
 #include <cctype>
@@ -60,7 +59,7 @@ namespace osmium {
     inline object_id_type string_to_object_id(const char* input) {
         assert(input);
         if (*input != '\0' && !std::isspace(*input)) {
-            char* end;
+            char* end = nullptr;
             const auto id = std::strtoll(input, &end, 10);
             if (id != std::numeric_limits<long long>::min() && // NOLINT(google-runtime-int)
                 id != std::numeric_limits<long long>::max() && // NOLINT(google-runtime-int)
@@ -112,7 +111,7 @@ namespace osmium {
                 return 0;
             }
             if (*input != '\0' && *input != '-' && !std::isspace(*input)) {
-                char* end;
+                char* end = nullptr;
                 const auto value = std::strtoul(input, &end, 10);
                 if (value < std::numeric_limits<uint32_t>::max() && *end == '\0') {
                     return static_cast<uint32_t>(value);
@@ -151,29 +150,6 @@ namespace osmium {
         return detail::string_to_ulong(input, "changeset");
     }
 
-    /**
-     * Convert string with user id to signed_user_id_type.
-     *
-     * @pre input must not be nullptr.
-     *
-     * @param input Input string.
-     *
-     * @throws std::range_error if the value is out of range.
-     *
-     * @deprecated Use string_to_uid() instead.
-     */
-    OSMIUM_DEPRECATED inline signed_user_id_type string_to_user_id(const char* input) {
-        assert(input);
-        if (input[0] == '-' && input[1] == '1' && input[2] == '\0') {
-            return -1;
-        }
-        const auto value = detail::string_to_ulong(input, "user id");
-        if (value > static_cast<uint32_t>(std::numeric_limits<int32_t>::max())) {
-            throw std::range_error{"illegal user id"};
-        }
-        return static_cast<signed_user_id_type>(value);
-    }
-
     /**
      * Convert string with user id to user_id_type.
      *
diff --git a/third_party/libosmium/include/osmium/osm/undirected_segment.hpp b/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
index 7a0eb4180..30fb0a204 100644
--- a/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
+++ b/third_party/libosmium/include/osmium/osm/undirected_segment.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/osm/way.hpp b/third_party/libosmium/include/osmium/osm/way.hpp
index 69bb5ad9e..0e2eb9854 100644
--- a/third_party/libosmium/include/osmium/osm/way.hpp
+++ b/third_party/libosmium/include/osmium/osm/way.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -108,16 +108,38 @@ namespace osmium {
         }
 
         /**
-         * Do the nodes in this way form a closed ring?
+         * Checks whether the first and last node in the way have the
+         * same ID. The locations are not checked.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code !empty() @endcode
          */
-        bool is_closed() const {
+        bool is_closed() const noexcept {
             return nodes().is_closed();
         }
 
-        bool ends_have_same_id() const {
+        /**
+         * Checks whether the first and last node in the way have the
+         * same ID. The locations are not checked.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code !empty() @endcode
+         */
+        bool ends_have_same_id() const noexcept {
             return nodes().ends_have_same_id();
         }
 
+        /**
+         * Checks whether the first and last node in the way have the
+         * same location. The IDs are not checked.
+         *
+         * Complexity: Constant.
+         *
+         * @pre @code !empty() @endcode
+         * @pre @code front().location() && back().location() @endcode
+         */
         bool ends_have_same_location() const {
             return nodes().ends_have_same_location();
         }
diff --git a/third_party/libosmium/include/osmium/relations/collector.hpp b/third_party/libosmium/include/osmium/relations/collector.hpp
index 63bfe3d74..91244b09a 100644
--- a/third_party/libosmium/include/osmium/relations/collector.hpp
+++ b/third_party/libosmium/include/osmium/relations/collector.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -46,6 +46,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/visitor.hpp>
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
@@ -185,14 +186,16 @@ namespace osmium {
              */
             using mm_vector_type = std::vector<MemberMeta>;
             using mm_iterator = mm_vector_type::iterator;
-            mm_vector_type m_member_meta[3];
+            std::array<mm_vector_type, 3> m_member_meta;
 
             int m_count_complete = 0;
 
             using callback_func_type = std::function<void(osmium::memory::Buffer&&)>;
             callback_func_type m_callback;
 
-            static constexpr size_t initial_buffer_size = 1024 * 1024;
+            enum {
+                initial_buffer_size = 1024UL * 1024UL
+            };
 
             iterator_range<mm_iterator> find_member_meta(osmium::item_type type, osmium::object_id_type id) {
                 auto& mmv = member_meta(type);
@@ -366,7 +369,7 @@ namespace osmium {
             }
 
             static typename iterator_range<mm_iterator>::iterator::difference_type count_not_removed(const iterator_range<mm_iterator>& range) {
-                return std::count_if(range.begin(), range.end(), [](MemberMeta& mm) {
+                return std::count_if(range.begin(), range.end(), [](const MemberMeta& mm) {
                     return !mm.removed();
                 });
             }
@@ -390,22 +393,22 @@ namespace osmium {
                     members_buffer().add_item(object);
                     const size_t member_offset = members_buffer().commit();
 
-                    for (auto& member_meta : range) {
-                        member_meta.set_buffer_offset(member_offset);
+                    for (auto& member : range) {
+                        member.set_buffer_offset(member_offset);
                     }
                 }
 
-                for (auto& member_meta : range) {
-                    if (member_meta.removed()) {
+                for (auto& member : range) {
+                    if (member.removed()) {
                         break;
                     }
-                    assert(member_meta.member_id() == object.id());
-                    assert(member_meta.relation_pos() < m_relations.size());
-                    RelationMeta& relation_meta = m_relations[member_meta.relation_pos()];
-                    assert(member_meta.member_pos() < get_relation(relation_meta).members().size());
+                    assert(member.member_id() == object.id());
+                    assert(member.relation_pos() < m_relations.size());
+                    RelationMeta& relation_meta = m_relations[member.relation_pos()];
+                    assert(member.member_pos() < get_relation(relation_meta).members().size());
                     relation_meta.got_one_member();
                     if (relation_meta.has_all_members()) {
-                        const size_t relation_offset = member_meta.relation_pos();
+                        const size_t relation_offset = member.relation_pos();
                         static_cast<TCollector*>(this)->complete_relation(relation_meta);
                         clear_member_metas(relation_meta);
                         m_relations[relation_offset] = RelationMeta{};
@@ -444,7 +447,7 @@ namespace osmium {
             uint64_t used_memory() const {
                 const uint64_t nmembers = m_member_meta[0].capacity() + m_member_meta[1].capacity() + m_member_meta[2].capacity();
                 const uint64_t members = nmembers * sizeof(MemberMeta);
-                const uint64_t relations = m_relations.capacity() * sizeof(RelationMeta);
+                const uint64_t relations_size = m_relations.capacity() * sizeof(RelationMeta);
                 const uint64_t relations_buffer_capacity = m_relations_buffer.capacity();
                 const uint64_t members_buffer_capacity = m_members_buffer.capacity();
 
@@ -457,17 +460,17 @@ namespace osmium {
                 std::cerr << "  sRM = sizeof(RelationMeta) ............. = " << std::setw(12) << sizeof(RelationMeta) << "\n";
                 std::cerr << "  sMM = sizeof(MemberMeta) ............... = " << std::setw(12) << sizeof(MemberMeta) << "\n\n";
 
-                std::cerr << "  nR * sRM ............................... = " << std::setw(12) << relations << "\n";
+                std::cerr << "  nR * sRM ............................... = " << std::setw(12) << relations_size << "\n";
                 std::cerr << "  nM * sMM ............................... = " << std::setw(12) << members << "\n";
                 std::cerr << "  relations_buffer_capacity .............. = " << std::setw(12) << relations_buffer_capacity << "\n";
                 std::cerr << "  members_buffer_capacity ................ = " << std::setw(12) << members_buffer_capacity << "\n";
 
-                const uint64_t total = relations + members + relations_buffer_capacity + members_buffer_capacity;
+                const uint64_t total = relations_size + members + relations_buffer_capacity + members_buffer_capacity;
 
                 std::cerr << "  total .................................. = " << std::setw(12) << total << "\n";
                 std::cerr << "  =======================================================\n";
 
-                return relations_buffer_capacity + members_buffer_capacity + relations + members;
+                return relations_buffer_capacity + members_buffer_capacity + relations_size + members;
             }
 
             /**
@@ -542,8 +545,8 @@ namespace osmium {
 
             template <typename TIter>
             void read_relations(TIter begin, TIter end) {
-                HandlerPass1 handler(*static_cast<TCollector*>(this));
-                osmium::apply(begin, end, handler);
+                HandlerPass1 handler_pass1{*static_cast<TCollector*>(this)};
+                osmium::apply(begin, end, handler_pass1);
                 sort_member_meta();
             }
 
@@ -558,9 +561,9 @@ namespace osmium {
             void moving_in_buffer(size_t old_offset, size_t new_offset) {
                 const osmium::OSMObject& object = m_members_buffer.get<osmium::OSMObject>(old_offset);
                 auto range = find_member_meta(object.type(), object.id());
-                for (auto& member_meta : range) {
-                    assert(member_meta.buffer_offset() == old_offset);
-                    member_meta.set_buffer_offset(new_offset);
+                for (auto& member : range) {
+                    assert(member.buffer_offset() == old_offset);
+                    member.set_buffer_offset(new_offset);
                 }
             }
 
@@ -595,13 +598,13 @@ namespace osmium {
              * owned by the Collector object.
              */
             std::vector<const osmium::Relation*> get_incomplete_relations() const {
-                std::vector<const osmium::Relation*> relations;
+                std::vector<const osmium::Relation*> incomplete_relations;
                 for (const auto& relation_meta : m_relations) {
                     if (!relation_meta.has_all_members()) {
-                        relations.push_back(&get_relation(relation_meta));
+                        incomplete_relations.push_back(&get_relation(relation_meta));
                     }
                 }
-                return relations;
+                return incomplete_relations;
             }
 
         }; // class Collector
diff --git a/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp b/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
index 54140b374..cc80536d8 100644
--- a/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
+++ b/third_party/libosmium/include/osmium/relations/detail/member_meta.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp b/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
index 221050adf..b2dc7bb68 100644
--- a/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
+++ b/third_party/libosmium/include/osmium/relations/detail/relation_meta.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -121,7 +121,7 @@ namespace osmium {
             /**
              * @returns true if this relation is complete, false otherwise.
              */
-            bool operator()(RelationMeta& relation_info) const {
+            bool operator()(const RelationMeta& relation_info) const {
                 return relation_info.has_all_members();
             }
 
diff --git a/third_party/libosmium/include/osmium/relations/manager_util.hpp b/third_party/libosmium/include/osmium/relations/manager_util.hpp
index 3248b488c..51e3dd125 100644
--- a/third_party/libosmium/include/osmium/relations/manager_util.hpp
+++ b/third_party/libosmium/include/osmium/relations/manager_util.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -118,14 +118,12 @@ namespace osmium {
          *                 to.
          */
         template <typename ...TManager>
-        void read_relations(const osmium::io::File& file, TManager&& ...managers) {
+        void read_relations(const osmium::io::File& file, TManager& ...managers) {
             static_assert(sizeof...(TManager) > 0, "Need at least one manager as parameter.");
             osmium::io::Reader reader{file, osmium::osm_entity_bits::relation};
-            osmium::apply(reader, std::forward<TManager>(managers)...);
+            osmium::apply(reader, managers...);
             reader.close();
-            (void)std::initializer_list<int>{
-                (std::forward<TManager>(managers).prepare_for_lookup(), 0)...
-            };
+            (void)std::initializer_list<int>{(managers.prepare_for_lookup(), 0)...};
         }
 
         /**
@@ -145,17 +143,15 @@ namespace osmium {
          *                 to.
          */
         template <typename ...TManager>
-        void read_relations(osmium::ProgressBar& progress_bar, const osmium::io::File& file, TManager&& ...managers) {
+        void read_relations(osmium::ProgressBar& progress_bar, const osmium::io::File& file, TManager& ...managers) {
             static_assert(sizeof...(TManager) > 0, "Need at least one manager as parameter.");
             osmium::io::Reader reader{file, osmium::osm_entity_bits::relation};
             while (auto buffer = reader.read()) {
                 progress_bar.update(reader.offset());
-                osmium::apply(buffer, std::forward<TManager>(managers)...);
+                osmium::apply(buffer, managers...);
             }
             reader.close();
-            (void)std::initializer_list<int>{
-                (std::forward<TManager>(managers).prepare_for_lookup(), 0)...
-            };
+            (void)std::initializer_list<int>{(managers.prepare_for_lookup(), 0)...};
             progress_bar.file_done(file.size());
         }
 
diff --git a/third_party/libosmium/include/osmium/relations/members_database.hpp b/third_party/libosmium/include/osmium/relations/members_database.hpp
index b66d3b388..a0b2b7367 100644
--- a/third_party/libosmium/include/osmium/relations/members_database.hpp
+++ b/third_party/libosmium/include/osmium/relations/members_database.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -67,7 +67,9 @@ namespace osmium {
                  * Special value used for member_num to mark the element as
                  * removed.
                  */
-                static const size_t removed_value = std::numeric_limits<std::size_t>::max();
+                enum {
+                    removed_value = std::numeric_limits<std::size_t>::max()
+                };
 
                 /**
                  * Object ID of this relation member. Can be a node, way,
@@ -203,11 +205,11 @@ namespace osmium {
              */
             struct counts {
                 /// The number of members tracked and not found yet.
-                std::size_t tracked   = 0;
+                std::size_t tracked = 0;
                 /// The number of members tracked and found already.
                 std::size_t available = 0;
                 /// The number of members that were tracked, found and then removed because of a completed relation.
-                std::size_t removed   = 0;
+                std::size_t removed = 0;
             };
 
             /**
diff --git a/third_party/libosmium/include/osmium/relations/relations_database.hpp b/third_party/libosmium/include/osmium/relations/relations_database.hpp
index fbe114cc0..dc4580836 100644
--- a/third_party/libosmium/include/osmium/relations/relations_database.hpp
+++ b/third_party/libosmium/include/osmium/relations/relations_database.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -323,7 +323,7 @@ namespace osmium {
         void RelationsDatabase::for_each_relation(TFunc&& func) {
             for (std::size_t pos = 0; pos < m_elements.size(); ++pos) {
                 if (m_elements[pos].handle.valid()) {
-                    std::forward<TFunc>(func)(RelationHandle{this, pos});
+                    func(RelationHandle{this, pos});
                 }
             }
         }
diff --git a/third_party/libosmium/include/osmium/relations/relations_manager.hpp b/third_party/libosmium/include/osmium/relations/relations_manager.hpp
index 93ba510e2..b4f900a53 100644
--- a/third_party/libosmium/include/osmium/relations/relations_manager.hpp
+++ b/third_party/libosmium/include/osmium/relations/relations_manager.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -138,7 +138,7 @@ namespace osmium {
              *
              * @param type osmium::item_type::node, way, or relation.
              */
-            relations::MembersDatabaseCommon& member_database(osmium::item_type type) {
+            relations::MembersDatabaseCommon& member_database(osmium::item_type type) noexcept {
                 switch (type) {
                     case osmium::item_type::node:
                         return m_member_nodes_db;
@@ -149,7 +149,9 @@ namespace osmium {
                     default:
                         break;
                 }
-                throw std::logic_error{"Should not be here."};
+
+                assert(false && "Should not be here");
+                return m_member_nodes_db;
             }
 
             /**
@@ -158,7 +160,7 @@ namespace osmium {
              *
              * @param type osmium::item_type::node, way, or relation.
              */
-            const relations::MembersDatabaseCommon& member_database(osmium::item_type type) const {
+            const relations::MembersDatabaseCommon& member_database(osmium::item_type type) const noexcept {
                 switch (type) {
                     case osmium::item_type::node:
                         return m_member_nodes_db;
@@ -169,7 +171,9 @@ namespace osmium {
                     default:
                         break;
                 }
-                throw std::logic_error{"Should not be here."};
+
+                assert(false && "Should not be here");
+                return m_member_nodes_db;
             }
 
             /**
diff --git a/third_party/libosmium/include/osmium/storage/item_stash.hpp b/third_party/libosmium/include/osmium/storage/item_stash.hpp
index 566fe0365..1d682a021 100644
--- a/third_party/libosmium/include/osmium/storage/item_stash.hpp
+++ b/third_party/libosmium/include/osmium/storage/item_stash.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -115,8 +115,13 @@ namespace osmium {
 
     private:
 
-        static constexpr const std::size_t initial_buffer_size = 1024 * 1024;
-        static constexpr const std::size_t removed_item_offset = std::numeric_limits<std::size_t>::max();
+        enum {
+            initial_buffer_size = 1024UL * 1024UL
+        };
+
+        enum {
+            removed_item_offset = std::numeric_limits<std::size_t>::max()
+        };
 
         osmium::memory::Buffer m_buffer;
         std::vector<std::size_t> m_index;
@@ -176,16 +181,16 @@ namespace osmium {
         // buffer grow (*3). The checks (*1) and (*2) make sure there is
         // minimum and maximum for the number of removed objects.
         bool should_gc() const noexcept {
-            if (m_count_removed < 10 * 1000) { // *1
+            if (m_count_removed < 10UL * 1000UL) { // *1
                 return false;
             }
-            if (m_count_removed >  5 * 1000 * 1000) { // *2
+            if (m_count_removed > 5UL * 1000UL * 1000UL) { // *2
                 return true;
             }
-            if (m_count_removed * 5 < m_count_items) { // *3
+            if (m_count_removed * 5UL < m_count_items) { // *3
                 return false;
             }
-            return m_buffer.capacity() - m_buffer.committed() < 10 * 1024; // *4
+            return m_buffer.capacity() - m_buffer.committed() < 10UL * 1024UL; // *4
         }
 
     public:
diff --git a/third_party/libosmium/include/osmium/tags/filter.hpp b/third_party/libosmium/include/osmium/tags/filter.hpp
index 4516edf78..fd6a821f0 100644
--- a/third_party/libosmium/include/osmium/tags/filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/filter.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,8 +36,6 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/memory/collection.hpp>
 #include <osmium/osm/tag.hpp>
 
-#include <boost/iterator/filter_iterator.hpp>
-
 #include <cstddef>
 #include <cstring>
 #include <string>
@@ -126,7 +124,7 @@ namespace osmium {
             using filter_type   = Filter<TKey, TValue, TKeyComp, TValueComp>;
             using argument_type = const osmium::Tag&;
             using result_type   = bool;
-            using iterator      = boost::filter_iterator<filter_type, osmium::TagList::const_iterator>;
+            using iterator      = osmium::memory::CollectionFilterIterator<filter_type, const osmium::Tag>;
 
             explicit Filter(bool default_result = false) :
                 m_default_result(default_result) {
diff --git a/third_party/libosmium/include/osmium/tags/matcher.hpp b/third_party/libosmium/include/osmium/tags/matcher.hpp
index bceac3b5b..78a32acf0 100644
--- a/third_party/libosmium/include/osmium/tags/matcher.hpp
+++ b/third_party/libosmium/include/osmium/tags/matcher.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,6 +36,7 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/tag.hpp>
 #include <osmium/util/string_matcher.hpp>
 
+#include <algorithm>
 #include <type_traits>
 #include <utility>
 
@@ -48,6 +49,7 @@ namespace osmium {
 
         osmium::StringMatcher m_key_matcher;
         osmium::StringMatcher m_value_matcher;
+        bool m_has_value_matcher = false;
         bool m_result = true;
 
     public:
@@ -60,15 +62,19 @@ namespace osmium {
             m_value_matcher(osmium::StringMatcher::always_false{}) {
         }
 
+        bool has_value_matcher() const noexcept {
+            return m_has_value_matcher;
+        }
+
         /**
          * Create a TagMatcher matching the key against the specified
          * StringMatcher.
          *
          * @param key_matcher StringMatcher for matching the key.
          */
-        template <typename TKey, typename std::enable_if<
-            std::is_convertible<TKey, osmium::StringMatcher>::value, int>::type = 0>
-        explicit TagMatcher(TKey&& key_matcher) : // NOLINT(misc-forwarding-reference-overload) (false positive due to enable_if)
+        template <typename TKey, typename X = typename std::enable_if<
+            std::is_convertible<TKey, osmium::StringMatcher>::value, void>::type>
+        explicit TagMatcher(TKey&& key_matcher) :
             m_key_matcher(std::forward<TKey>(key_matcher)),
             m_value_matcher(osmium::StringMatcher::always_true{}) {
         }
@@ -87,6 +93,7 @@ namespace osmium {
         TagMatcher(TKey&& key_matcher, TValue&& value_matcher, bool invert = false) :
             m_key_matcher(std::forward<TKey>(key_matcher)),
             m_value_matcher(std::forward<TValue>(value_matcher)),
+            m_has_value_matcher(true),
             m_result(!invert) {
         }
 
@@ -115,12 +122,9 @@ namespace osmium {
          * @returns true if any of the tags in the TagList matches.
          */
         bool operator()(const osmium::TagList& tags) const noexcept {
-            for (const auto& tag : tags) {
-                if (operator()(tag)) {
-                    return true;
-                }
-            }
-            return false;
+            return std::any_of(tags.begin(), tags.end(), [this](const osmium::Tag& tag){
+                return operator()(tag);
+            });
         }
 
     }; // class TagMatcher
diff --git a/third_party/libosmium/include/osmium/tags/regex_filter.hpp b/third_party/libosmium/include/osmium/tags/regex_filter.hpp
index 3b895a06e..d0c25ce57 100644
--- a/third_party/libosmium/include/osmium/tags/regex_filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/regex_filter.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/tags/taglist.hpp b/third_party/libosmium/include/osmium/tags/taglist.hpp
index 2c2be14e2..cda1b4324 100644
--- a/third_party/libosmium/include/osmium/tags/taglist.hpp
+++ b/third_party/libosmium/include/osmium/tags/taglist.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/tags/tags_filter.hpp b/third_party/libosmium/include/osmium/tags/tags_filter.hpp
index 85a7971b8..e48b1a636 100644
--- a/third_party/libosmium/include/osmium/tags/tags_filter.hpp
+++ b/third_party/libosmium/include/osmium/tags/tags_filter.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -36,16 +36,19 @@ DEALINGS IN THE SOFTWARE.
 #include <osmium/osm/tag.hpp>
 #include <osmium/tags/matcher.hpp>
 
-#include <boost/iterator/filter_iterator.hpp>
-
 #include <utility>
 #include <vector>
 
 namespace osmium {
 
     /**
-     * A TagsFilter is a list of rules (defined using TagMatchers) to check
-     * tags against. The first rule that matches sets the result.
+     * A TagsFilterBase is a list of rules (defined using TagMatchers) to
+     * check tags against. The first rule that matches sets the result.
+     *
+     * Usually you want to use the TagsFilter class, which is simply a
+     * specialization with TResult=bool. But TResult can be any class that
+     * has a default constructor and a conversion to bool. The class should
+     * be small, because it is copied around in some places.
      *
      * Here is an example matching any "highway" tag except "highway=motorway":
      * @code
@@ -59,14 +62,15 @@ namespace osmium {
      *
      * Use this instead of the old osmium::tags::Filter.
      */
-    class TagsFilter {
+    template <typename TResult>
+    class TagsFilterBase {
 
-        std::vector<std::pair<bool, TagMatcher>> m_rules;
-        bool m_default_result;
+        std::vector<std::pair<TResult, TagMatcher>> m_rules;
+        TResult m_default_result;
 
     public:
 
-        using iterator = boost::filter_iterator<TagsFilter, osmium::TagList::const_iterator>;
+        using iterator = osmium::memory::CollectionFilterIterator<TagsFilterBase, const osmium::Tag>;
 
         /**
          * Constructor.
@@ -74,7 +78,7 @@ namespace osmium {
          * @param default_result The result the matching function will return
          *                       if none of the rules matched.
          */
-        explicit TagsFilter(bool default_result = false) :
+        explicit TagsFilterBase(const TResult default_result = TResult{}) :
             m_default_result(default_result) {
         }
 
@@ -82,7 +86,7 @@ namespace osmium {
          * Set the default result, the result the matching function will
          * return if none of the rules matched.
          */
-        void set_default_result(bool default_result) noexcept {
+        void set_default_result(const TResult default_result) noexcept {
             m_default_result = default_result;
         }
 
@@ -93,7 +97,7 @@ namespace osmium {
          * @param matcher The TagMatcher for checking tags.
          * @returns A reference to this filter for chaining.
          */
-        TagsFilter& add_rule(bool result, const TagMatcher& matcher) {
+        TagsFilterBase& add_rule(const TResult result, const TagMatcher& matcher) {
             m_rules.emplace_back(result, matcher);
             return *this;
         }
@@ -107,7 +111,7 @@ namespace osmium {
          * @returns A reference to this filter for chaining.
          */
         template <typename... TArgs>
-        TagsFilter& add_rule(bool result, TArgs&&... args) {
+        TagsFilterBase& add_rule(const TResult result, TArgs&&... args) {
             m_rules.emplace_back(result, osmium::TagMatcher{std::forward<TArgs>(args)...});
             return *this;
         }
@@ -119,7 +123,7 @@ namespace osmium {
          * @returns The result of the matching rule, or, if none of the rules
          *          matched, the default result.
          */
-        bool operator()(const osmium::Tag& tag) const noexcept {
+        TResult operator()(const osmium::Tag& tag) const noexcept {
             for (const auto& rule : m_rules) {
                 if (rule.second(tag)) {
                     return rule.first;
@@ -133,7 +137,7 @@ namespace osmium {
          *
          * Complexity: Constant.
          */
-        size_t count() const noexcept {
+        std::size_t count() const noexcept {
             return m_rules.size();
         }
 
@@ -146,7 +150,9 @@ namespace osmium {
             return m_rules.empty();
         }
 
-    }; // class TagsFilter
+    }; // class TagsFilterBase
+
+    using TagsFilter = TagsFilterBase<bool>;
 
 } // namespace osmium
 
diff --git a/third_party/libosmium/include/osmium/thread/function_wrapper.hpp b/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
index 7e1abdb67..d03f3b6ae 100644
--- a/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
+++ b/third_party/libosmium/include/osmium/thread/function_wrapper.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -73,7 +73,7 @@ namespace osmium {
                 F m_functor;
 
                 explicit impl_type(F&& functor) :
-                    m_functor(std::forward<F>(functor)) {
+                    m_functor(std::move(functor)) {
                 }
 
                 bool call() override {
@@ -87,9 +87,10 @@ namespace osmium {
 
             // Constructor must not be "explicit" for wrapper
             // to work seemlessly.
-            template <typename TFunction>
+            template <typename TFunction, typename X = typename std::enable_if<
+                !std::is_same<TFunction, function_wrapper>::value, void>::type>
             // cppcheck-suppress noExplicitConstructor
-            function_wrapper(TFunction&& f) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions, misc-forwarding-reference-overload)
+            function_wrapper(TFunction&& f) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
                 impl(new impl_type<TFunction>(std::forward<TFunction>(f))) {
             }
 
diff --git a/third_party/libosmium/include/osmium/thread/pool.hpp b/third_party/libosmium/include/osmium/thread/pool.hpp
index 03c6c94c4..8183e15b9 100644
--- a/third_party/libosmium/include/osmium/thread/pool.hpp
+++ b/third_party/libosmium/include/osmium/thread/pool.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -56,7 +56,9 @@ namespace osmium {
 
             // Maximum number of allowed pool threads (just to keep the user
             // from setting something silly).
-            constexpr const int max_pool_threads = 32;
+            enum {
+                max_pool_threads = 32
+            };
 
             inline int get_pool_size(int num_threads, int user_setting, unsigned hardware_concurrency) {
                 if (num_threads == 0) {
@@ -77,8 +79,7 @@ namespace osmium {
             }
 
             inline std::size_t get_work_queue_size() noexcept {
-                const std::size_t n = osmium::config::get_max_queue_size("WORK", 10);
-                return n > 2 ? n : 2;
+                return osmium::config::get_max_queue_size("WORK", 10);
             }
 
         } // namespace detail
@@ -138,8 +139,13 @@ namespace osmium {
 
         public:
 
-            static constexpr int default_num_threads = 0;
-            static constexpr int default_queue_size = 0;
+            enum {
+                default_num_threads = 0
+            };
+
+            enum {
+                default_queue_size = 0U
+            };
 
             /**
              * Create thread pool with the given number of threads. If
@@ -171,6 +177,12 @@ namespace osmium {
                 }
             }
 
+            /**
+             * Return a statically created "default pool". This is initialized
+             * the first time you use it.
+             *
+             * Do not use this if your program will fork.
+             */
             static Pool& default_instance() {
                 static Pool pool{};
                 return pool;
@@ -205,12 +217,21 @@ namespace osmium {
                 return m_work_queue.empty();
             }
 
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+            // std::result_of is deprecated in C++17 and removed in C++20,
+            // so we use std::invoke_result_t.
             template <typename TFunction>
-            std::future<typename std::result_of<TFunction()>::type> submit(TFunction&& func) {
-                using result_type = typename std::result_of<TFunction()>::type;
+            using submit_func_result_type = std::invoke_result_t<TFunction>;
+#else
+            // For C++11 and C++14
+            template <typename TFunction>
+            using submit_func_result_type = typename std::result_of<TFunction()>::type;
+#endif
 
-                std::packaged_task<result_type()> task{std::forward<TFunction>(func)};
-                std::future<result_type> future_result{task.get_future()};
+            template <typename TFunction>
+            std::future<submit_func_result_type<TFunction>> submit(TFunction&& func) {
+                std::packaged_task<submit_func_result_type<TFunction>()> task{std::forward<TFunction>(func)};
+                std::future<submit_func_result_type<TFunction>> future_result{task.get_future()};
                 m_work_queue.push(std::move(task));
 
                 return future_result;
diff --git a/third_party/libosmium/include/osmium/thread/queue.hpp b/third_party/libosmium/include/osmium/thread/queue.hpp
index d34bfaa06..bcb849b9e 100644
--- a/third_party/libosmium/include/osmium/thread/queue.hpp
+++ b/third_party/libosmium/include/osmium/thread/queue.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,6 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
+#include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <cstddef>
@@ -42,7 +43,6 @@ DEALINGS IN THE SOFTWARE.
 #include <utility> // IWYU pragma: keep
 
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
-# include <atomic>
 # include <iostream>
 #endif
 
@@ -73,6 +73,8 @@ namespace osmium {
             /// Used to signal producers when queue is not full.
             std::condition_variable m_space_available;
 
+            std::atomic<bool> m_in_use{true};
+
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
             /// The largest size the queue has been so far.
             std::size_t m_largest_size;
@@ -145,6 +147,9 @@ namespace osmium {
              * this call will block if the queue is full.
              */
             void push(T value) {
+                if (!m_in_use) {
+                    return;
+                }
                 constexpr const std::chrono::milliseconds max_wait{10};
 #ifdef OSMIUM_DEBUG_QUEUE_SIZE
                 ++m_push_counter;
@@ -181,7 +186,7 @@ namespace osmium {
                 }
 #endif
                 m_data_available.wait(lock, [this] {
-                    return !m_queue.empty();
+                    return !m_in_use || !m_queue.empty();
                 });
                 if (!m_queue.empty()) {
                     value = std::move(m_queue.front());
@@ -224,6 +229,19 @@ namespace osmium {
                 return m_queue.size();
             }
 
+            bool in_use() const noexcept {
+                return m_in_use;
+            }
+
+            void shutdown() {
+                m_in_use = false;
+                std::lock_guard<std::mutex> lock{m_mutex};
+                while (!m_queue.empty()) {
+                    m_queue.pop();
+                }
+                m_data_available.notify_all();
+            }
+
         }; // class Queue
 
     } // namespace thread
diff --git a/third_party/libosmium/include/osmium/thread/util.hpp b/third_party/libosmium/include/osmium/thread/util.hpp
index 418f9fe9a..ba0bc99ed 100644
--- a/third_party/libosmium/include/osmium/thread/util.hpp
+++ b/third_party/libosmium/include/osmium/thread/util.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/cast.hpp b/third_party/libosmium/include/osmium/util/cast.hpp
deleted file mode 100644
index fd03e41f3..000000000
--- a/third_party/libosmium/include/osmium/util/cast.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-#ifndef OSMIUM_UTIL_CAST_HPP
-#define OSMIUM_UTIL_CAST_HPP
-
-/*
-
-This file is part of Osmium (http://osmcode.org/libosmium).
-
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
-*/
-
-#ifndef assert
-# include <cassert>
-#endif
-
-#include <cstdint>
-#include <limits>
-#include <type_traits>
-
-namespace osmium {
-
-    // These functions are wrappers around static_cast<>() that call assert()
-    // to check that there is no integer overflow happening before doing the
-    // cast. There are several versions of this templated function here
-    // depending on the types of the input and output. In any case, both input
-    // and output have to be integral types. If the cast can't overflow, no
-    // check is done.
-
-    template <typename A, typename B>
-    struct are_real_integers :
-        std::integral_constant<bool,
-            std::is_integral<A>::value &&
-            std::is_integral<B>::value &&
-            !std::is_same<A, bool>::value &&
-            !std::is_same<B, bool>::value> {
-    };
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && std::is_same<T, F>::value, int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        return value;
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && (sizeof(T) > sizeof(F)), int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        return static_cast<T>(value);
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && std::is_signed<T>::value == std::is_signed<F>::value && (sizeof(T) == sizeof(F)), int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        return static_cast<T>(value);
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && (sizeof(T) < sizeof(F)) && std::is_signed<T>::value && std::is_signed<F>::value, int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        assert(value >= std::numeric_limits<T>::min() && value <= std::numeric_limits<T>::max());
-        return static_cast<T>(value);
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && (sizeof(T) <= sizeof(F)) && std::is_unsigned<T>::value && std::is_signed<F>::value, int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        assert(value >= 0 && static_cast<typename std::make_unsigned<F>::type>(value) <= std::numeric_limits<T>::max());
-        return static_cast<T>(value);
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && (sizeof(T) < sizeof(F)) && std::is_unsigned<T>::value && std::is_unsigned<F>::value, int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        assert(value <= std::numeric_limits<T>::max());
-        return static_cast<T>(value);
-    }
-
-    template <typename T, typename F, typename std::enable_if<are_real_integers<T, F>::value && !std::is_same<T, F>::value && (sizeof(T) <= sizeof(F)) && std::is_signed<T>::value && std::is_unsigned<F>::value, int>::type = 0>
-    inline T static_cast_with_assert(const F value) {
-        assert(static_cast<int64_t>(value) <= static_cast<int64_t>(std::numeric_limits<T>::max()));
-        return static_cast<T>(value);
-    }
-
-} // namespace osmium
-
-#endif // OSMIUM_UTIL_CAST_HPP
diff --git a/third_party/libosmium/include/osmium/util/compatibility.hpp b/third_party/libosmium/include/osmium/util/compatibility.hpp
index 3686a359d..7618392e1 100644
--- a/third_party/libosmium/include/osmium/util/compatibility.hpp
+++ b/third_party/libosmium/include/osmium/util/compatibility.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,14 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-// Workarounds for MSVC which doesn't support
-// * [[noreturn]]
-#ifdef _MSC_VER
-# define OSMIUM_NORETURN __declspec(noreturn)
-#else
-# define OSMIUM_NORETURN [[noreturn]]
-#endif
-
 // [[deprecated]] is only available in C++14, use this for the time being
 #ifdef __GNUC__
 # define OSMIUM_DEPRECATED __attribute__((deprecated))
@@ -50,4 +42,16 @@ DEALINGS IN THE SOFTWARE.
 # define OSMIUM_DEPRECATED
 #endif
 
+// Set OSMIUM_DEFINE_EXPORT before including any osmium headers to add
+// the special attributes to all exception classes.
+#ifdef OSMIUM_DEFINE_EXPORT
+# ifdef _MSC_VER
+#  define OSMIUM_EXPORT __declspec(dllexport)
+# else
+#  define OSMIUM_EXPORT __attribute__ ((visibility("default")))
+# endif
+#else
+#  define OSMIUM_EXPORT
+#endif
+
 #endif // OSMIUM_UTIL_COMPATIBILITY_HPP
diff --git a/third_party/libosmium/include/osmium/util/config.hpp b/third_party/libosmium/include/osmium/util/config.hpp
index 76e125243..e225c1fbe 100644
--- a/third_party/libosmium/include/osmium/util/config.hpp
+++ b/third_party/libosmium/include/osmium/util/config.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -60,7 +60,7 @@ namespace osmium {
     namespace config {
 
         inline int get_pool_threads() noexcept {
-            auto env = osmium::detail::getenv_wrapper("OSMIUM_POOL_THREADS");
+            const char* env = osmium::detail::getenv_wrapper("OSMIUM_POOL_THREADS");
             if (env) {
                 return osmium::detail::str_to_int<int>(env);
             }
@@ -68,7 +68,7 @@ namespace osmium {
         }
 
         inline bool use_pool_threads_for_pbf_parsing() noexcept {
-            auto env = osmium::detail::getenv_wrapper("OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
+            const char* env = osmium::detail::getenv_wrapper("OSMIUM_USE_POOL_THREADS_FOR_PBF_PARSING");
             if (env) {
                 if (!strcasecmp(env, "off") ||
                     !strcasecmp(env, "false") ||
@@ -80,17 +80,40 @@ namespace osmium {
             return true;
         }
 
-        inline std::size_t get_max_queue_size(const char* queue_name, std::size_t default_value) noexcept {
+        inline std::size_t get_max_queue_size(const char* queue_name, const std::size_t default_value) noexcept {
             assert(queue_name);
             std::string name{"OSMIUM_MAX_"};
             name += queue_name;
             name += "_QUEUE_SIZE";
-            auto env = osmium::detail::getenv_wrapper(name.c_str());
+            const char* env = osmium::detail::getenv_wrapper(name.c_str());
+
+            std::size_t value = default_value;
+
             if (env) {
-                const auto value = osmium::detail::str_to_int<std::size_t>(env);
-                return value == 0 ? default_value : value;
+                const auto new_value = osmium::detail::str_to_int<std::size_t>(env);
+                if (new_value != 0) {
+                    value = new_value;
+                }
             }
-            return default_value;
+
+            if (value < 2) {
+                value = 2;
+            }
+
+            return value;
+        }
+
+        inline int8_t clean_page_cache_after_read() noexcept {
+            const char* env = osmium::detail::getenv_wrapper("OSMIUM_CLEAN_PAGE_CACHE_AFTER_READ");
+            if (env) {
+                if (!strcasecmp(env, "yes")) {
+                    return 1;
+                }
+                if (!strcasecmp(env, "no")) {
+                    return -1;
+                }
+            }
+            return 0;
         }
 
     } // namespace config
diff --git a/third_party/libosmium/include/osmium/util/delta.hpp b/third_party/libosmium/include/osmium/util/delta.hpp
index 59e4c8091..56103f856 100644
--- a/third_party/libosmium/include/osmium/util/delta.hpp
+++ b/third_party/libosmium/include/osmium/util/delta.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/util/cast.hpp>
-
+#include <cassert>
 #include <cstdint>
 #include <type_traits>
 #include <utility>
@@ -55,6 +54,11 @@ namespace osmium {
             static_assert(std::is_integral<TDelta>::value && std::is_signed<TDelta>::value,
                           "DeltaEncode delta type must be some signed integer");
 
+            // Not a perfect check, because of signed vs. unsigned, but
+            // might find some problems.
+            static_assert(sizeof(TDelta) >= sizeof(TValue),
+                          "Delta type size should be larger or equal to value type size");
+
             TValue m_value;
 
         public:
@@ -77,8 +81,11 @@ namespace osmium {
             TDelta update(TValue new_value) noexcept {
                 using std::swap;
                 swap(m_value, new_value);
-                return static_cast_with_assert<TDelta>(m_value) -
-                       static_cast_with_assert<TDelta>(new_value);
+                // Checking the static_cast here doesn't help much, because
+                // the substraction can still lead to an overflow. This is
+                // dependend on the input data being "reasonable". XXX
+                return static_cast<TDelta>(m_value) -
+                       static_cast<TDelta>(new_value);
             }
 
         }; // class DeltaEncode
@@ -120,6 +127,10 @@ namespace osmium {
                 return m_value;
             }
 
+            TValue value() const noexcept {
+                return m_value;
+            }
+
         }; // class DeltaDecode
 
     } // namespace util
diff --git a/third_party/libosmium/include/osmium/util/double.hpp b/third_party/libosmium/include/osmium/util/double.hpp
index 7b9c1e5c1..bfdba8ac6 100644
--- a/third_party/libosmium/include/osmium/util/double.hpp
+++ b/third_party/libosmium/include/osmium/util/double.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -43,8 +43,6 @@ namespace osmium {
 
     inline namespace util {
 
-        constexpr const int max_double_length = 20; // should fit any double
-
         /**
          * Write double to iterator, removing superfluous '0' characters at
          * the end. The decimal dot will also be removed if necessary.
@@ -58,6 +56,10 @@ namespace osmium {
         inline T double2string(T iterator, double value, int precision) {
             assert(precision <= 17);
 
+            enum {
+                max_double_length = 20 // should fit decimal representation of any double
+            };
+
             char buffer[max_double_length];
 
 #ifndef _MSC_VER
diff --git a/third_party/libosmium/include/osmium/util/endian.hpp b/third_party/libosmium/include/osmium/util/endian.hpp
index 2db874629..10cdb2488 100644
--- a/third_party/libosmium/include/osmium/util/endian.hpp
+++ b/third_party/libosmium/include/osmium/util/endian.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/file.hpp b/third_party/libosmium/include/osmium/util/file.hpp
index 34c26031b..bc7041aa5 100644
--- a/third_party/libosmium/include/osmium/util/file.hpp
+++ b/third_party/libosmium/include/osmium/util/file.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,11 +33,11 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/util/cast.hpp>
-
+#include <cassert>
 #include <cerrno>
 #include <cstddef>
 #include <cstdio>
+#include <limits>
 #include <string>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -138,6 +138,7 @@ namespace osmium {
         inline std::size_t file_size(const char* name) {
 #ifdef _MSC_VER
             // Windows implementation
+            osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/14h5k7ff.aspx
             struct _stat64 s{};
             if (::_stati64(name, &s) != 0) {
@@ -176,10 +177,11 @@ namespace osmium {
         inline void resize_file(int fd, std::size_t new_size) {
 #ifdef _MSC_VER
             osmium::detail::disable_invalid_parameter_handler diph;
+            assert(new_size <= static_cast<std::size_t>(std::numeric_limits<__int64>::max()));
             // https://msdn.microsoft.com/en-us/library/whx354w1.aspx
-            if (::_chsize_s(fd, static_cast_with_assert<__int64>(new_size)) != 0) {
+            if (::_chsize_s(fd, static_cast<__int64>(new_size)) != 0) {
 #else
-            if (::ftruncate(fd, static_cast_with_assert<off_t>(new_size)) != 0) {
+            if (::ftruncate(fd, static_cast<off_t>(new_size)) != 0) {
 #endif
                 throw std::system_error{errno, std::system_category(), "Could not resize file"};
             }
@@ -188,7 +190,7 @@ namespace osmium {
         /**
          * Get the page size for this system.
          */
-        inline std::size_t get_pagesize() {
+        inline std::size_t get_pagesize() noexcept {
 #ifdef _WIN32
             // Windows implementation
             SYSTEM_INFO si;
@@ -206,7 +208,7 @@ namespace osmium {
          * @param fd Open file descriptor.
          * @returns File offset or 0 if it is not available.
          */
-        inline std::size_t file_offset(int fd) {
+        inline std::size_t file_offset(int fd) noexcept {
 #ifdef _MSC_VER
             osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/1yee101t.aspx
@@ -222,8 +224,10 @@ namespace osmium {
 
         /**
          * Check whether the file descriptor refers to a TTY.
+         *
+         * @param fd Open file descriptor.
          */
-        inline bool isatty(int fd) {
+        inline bool isatty(int fd) noexcept {
 #ifdef _MSC_VER
             osmium::detail::disable_invalid_parameter_handler diph;
             // https://msdn.microsoft.com/en-us/library/f4s0ddew.aspx
diff --git a/third_party/libosmium/include/osmium/util/iterator.hpp b/third_party/libosmium/include/osmium/util/iterator.hpp
index 02bf28370..9ccfd86b1 100644
--- a/third_party/libosmium/include/osmium/util/iterator.hpp
+++ b/third_party/libosmium/include/osmium/util/iterator.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -44,7 +44,7 @@ namespace osmium {
         using iterator = It;
 
         explicit iterator_range(P&& p) noexcept :
-            P(std::forward<P>(p)) {
+            P(std::move(p)) {
         }
 
         It begin() const noexcept {
diff --git a/third_party/libosmium/include/osmium/util/memory.hpp b/third_party/libosmium/include/osmium/util/memory.hpp
index e1f112290..44c70d58d 100644
--- a/third_party/libosmium/include/osmium/util/memory.hpp
+++ b/third_party/libosmium/include/osmium/util/memory.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -47,7 +47,7 @@ namespace osmium {
         int64_t m_peak    = 0;
 
 #ifdef __linux__
-        static int parse_number(const std::string& line) {
+        static int64_t parse_number(const std::string& line) {
             const auto f = line.find_first_of("0123456789");
             const auto l = line.find_last_of("0123456789");
             return osmium::detail::str_to_int<int64_t>(line.substr(f, l - f + 1).c_str());
diff --git a/third_party/libosmium/include/osmium/util/memory_mapping.hpp b/third_party/libosmium/include/osmium/util/memory_mapping.hpp
index 57c326248..b24417b1e 100644
--- a/third_party/libosmium/include/osmium/util/memory_mapping.hpp
+++ b/third_party/libosmium/include/osmium/util/memory_mapping.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,7 +33,6 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <osmium/util/compatibility.hpp>
 #include <osmium/util/file.hpp>
 
 #include <cassert>
@@ -44,6 +43,7 @@ DEALINGS IN THE SOFTWARE.
 
 #ifndef _WIN32
 # include <sys/mman.h>
+# include <sys/statvfs.h>
 #else
 # include <fcntl.h>
 # include <io.h>
@@ -60,7 +60,7 @@ namespace osmium {
          *
          * Usage for anonymous mapping:
          * @code
-         * MemoryMapping mapping(1024);          // create anonymous mapping with size
+         * MemoryMapping mapping{1024};          // create anonymous mapping with size
          * auto ptr = mapping.get_addr<char*>(); // get pointer to memory
          * mapping.unmap();                      // release mapping by calling unmap() (or at end of scope)
          * @endcode
@@ -69,7 +69,7 @@ namespace osmium {
          * @code
          * int fd = ::open(...);
          * {
-         *     MemoryMapping mapping(1024, MemoryMapping::mapping_mode::write_shared, fd, offset);
+         *     MemoryMapping mapping{1024, MemoryMapping::mapping_mode::write_shared, fd, offset};
          *     // use mapping
          * }
          * ::close(fd);
@@ -150,14 +150,35 @@ namespace osmium {
             void* map_view_of_file() const noexcept;
 #endif
 
-            int resize_fd(int fd) {
+            // Get the available space on the file system where the file
+            // behind fd is on. Return 0 if it can't be determined.
+            static std::size_t available_space(int fd) {
+#ifdef _WIN32
+                return 0;
+#else
+                struct statvfs stat{};
+                const int result = ::fstatvfs(fd, &stat);
+                if (result != 0) {
+                    return 0;
+                }
+                return stat.f_bsize * stat.f_bavail;
+#endif
+            }
+
+            int resize_fd(int fd) const {
                 // Anonymous mapping doesn't need resizing.
                 if (fd == -1) {
                     return -1;
                 }
 
                 // Make sure the file backing this mapping is large enough.
-                if (osmium::file_size(fd) < m_size + m_offset) {
+                auto const current_file_size = osmium::file_size(fd);
+                if (current_file_size < m_size + m_offset) {
+                    const auto available = available_space(fd);
+                    if (available > 0 && current_file_size + available <= m_size) {
+                        throw std::system_error{ENOSPC, std::system_category(), "Could not resize file: Not enough space on filesystem"};
+                    }
+
                     osmium::resize_file(fd, m_size + m_offset);
                 }
                 return fd;
@@ -183,15 +204,6 @@ namespace osmium {
              */
             MemoryMapping(std::size_t size, mapping_mode mode, int fd = -1, off_t offset = 0);
 
-            /**
-             * @deprecated
-             * For backwards compatibility only. Use the constructor taking
-             * a mapping_mode as second argument instead.
-             */
-            OSMIUM_DEPRECATED MemoryMapping(std::size_t size, bool writable = true, int fd = -1, off_t offset = 0) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
-                MemoryMapping(size, writable ? mapping_mode::write_shared : mapping_mode::readonly, fd, offset)  {
-            }
-
             /// You can not copy construct a MemoryMapping.
             MemoryMapping(const MemoryMapping&) = delete;
 
@@ -278,14 +290,11 @@ namespace osmium {
             /**
              * Get the address of the mapping as any pointer type you like.
              *
-             * @throws std::runtime_error if the mapping is invalid
+             * @pre is_valid()
              */
             template <typename T = void>
-            T* get_addr() const {
-                if (is_valid()) {
-                    return reinterpret_cast<T*>(m_addr);
-                }
-                throw std::runtime_error{"invalid memory mapping"};
+            T* get_addr() const noexcept {
+                return reinterpret_cast<T*>(m_addr);
             }
 
         }; // class MemoryMapping
@@ -295,7 +304,7 @@ namespace osmium {
          *
          * Usage for anonymous mapping:
          * @code
-         * AnonymousMemoryMapping mapping(1024); // create anonymous mapping with size
+         * AnonymousMemoryMapping mapping{1024}; // create anonymous mapping with size
          * auto ptr = mapping.get_addr<char*>(); // get pointer to memory
          * mapping.unmap();                      // release mapping by calling unmap() (or at end of scope)
          * @endcode
@@ -358,18 +367,6 @@ namespace osmium {
                 m_mapping(sizeof(T) * size, mode, fd, sizeof(T) * offset) {
             }
 
-            /**
-             * @deprecated
-             * For backwards compatibility only. Use the constructor taking
-             * a mapping_mode as second argument instead.
-             */
-            OSMIUM_DEPRECATED TypedMemoryMapping(std::size_t size, bool writable, int fd, off_t offset = 0) :
-                m_mapping(sizeof(T) * size,
-                          writable ? MemoryMapping::mapping_mode::write_shared : MemoryMapping::mapping_mode::readonly,
-                          fd,
-                          sizeof(T) * offset) {
-            }
-
             /// You can not copy construct a TypedMemoryMapping.
             TypedMemoryMapping(const TypedMemoryMapping&) = delete;
 
@@ -454,34 +451,54 @@ namespace osmium {
             /**
              * Get the address of the beginning of the mapping.
              *
-             * @throws std::runtime_error if the mapping is invalid
+             * @pre is_valid()
              */
-            T* begin() {
+            T* begin() noexcept {
                 return m_mapping.get_addr<T>();
             }
 
             /**
              * Get the address one past the end of the mapping.
              *
-             * @throws std::runtime_error if the mapping is invalid
+             * @pre is_valid()
              */
-            T* end() {
+            T* end() noexcept {
                 return m_mapping.get_addr<T>() + size();
             }
 
-            const T* cbegin() const {
+            /**
+             * Get the address of the beginning of the mapping.
+             *
+             * @pre is_valid()
+             */
+            const T* cbegin() const noexcept {
                 return m_mapping.get_addr<T>();
             }
 
-            const T* cend() const {
+            /**
+             * Get the address one past the end of the mapping.
+             *
+             * @pre is_valid()
+             */
+            const T* cend() const noexcept {
                 return m_mapping.get_addr<T>() + size();
             }
 
-            const T* begin() const {
+            /**
+             * Get the address of the beginning of the mapping.
+             *
+             * @pre is_valid()
+             */
+            const T* begin() const noexcept {
                 return m_mapping.get_addr<T>();
             }
 
-            const T* end() const {
+            /**
+             * Get the address one past the end of the mapping.
+             *
+             * @pre is_valid()
+             */
+            const T* end() const noexcept {
                 return m_mapping.get_addr<T>() + size();
             }
 
@@ -518,12 +535,12 @@ namespace osmium {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 
-inline bool osmium::MemoryMapping::is_valid() const noexcept {
-    return m_addr != MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
+inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
+    return m_addr != MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast,performance-no-int-to-ptr)
 }
 
-inline void osmium::MemoryMapping::make_invalid() noexcept {
-    m_addr = MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast)
+inline void osmium::util::MemoryMapping::make_invalid() noexcept {
+    m_addr = MAP_FAILED; // NOLINT(cppcoreguidelines-pro-type-cstyle-cast,performance-no-int-to-ptr)
 }
 
 #pragma GCC diagnostic pop
@@ -533,14 +550,14 @@ inline void osmium::MemoryMapping::make_invalid() noexcept {
 # define MAP_ANONYMOUS MAP_ANON
 #endif
 
-inline int osmium::MemoryMapping::get_protection() const noexcept {
+inline int osmium::util::MemoryMapping::get_protection() const noexcept {
     if (m_mapping_mode == mapping_mode::readonly) {
         return PROT_READ;
     }
     return PROT_READ | PROT_WRITE; // NOLINT(hicpp-signed-bitwise)
 }
 
-inline int osmium::MemoryMapping::get_flags() const noexcept {
+inline int osmium::util::MemoryMapping::get_flags() const noexcept {
     if (m_fd == -1) {
         return MAP_PRIVATE | MAP_ANONYMOUS; // NOLINT(hicpp-signed-bitwise)
     }
@@ -550,7 +567,7 @@ inline int osmium::MemoryMapping::get_flags() const noexcept {
     return MAP_PRIVATE;
 }
 
-inline osmium::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode mode, int fd, off_t offset) :
+inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode mode, int fd, off_t offset) :
     m_size(check_size(size)),
     m_offset(offset),
     m_fd(resize_fd(fd)),
@@ -562,7 +579,7 @@ inline osmium::MemoryMapping::MemoryMapping(std::size_t size, mapping_mode mode,
     }
 }
 
-inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
+inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     m_size(other.m_size),
     m_offset(other.m_offset),
     m_fd(other.m_fd),
@@ -571,8 +588,13 @@ inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     other.make_invalid();
 }
 
-inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMapping&& other) noexcept {
-    unmap();
+inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) noexcept {
+    try {
+        unmap();
+    } catch (const std::system_error&) {
+        // Ignore unmap error. It should never happen anyway and we can't do
+        // anything about it here.
+    }
     m_size         = other.m_size;
     m_offset       = other.m_offset;
     m_fd           = other.m_fd;
@@ -582,7 +604,7 @@ inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMap
     return *this;
 }
 
-inline void osmium::MemoryMapping::unmap() {
+inline void osmium::util::MemoryMapping::unmap() {
     if (is_valid()) {
         if (::munmap(m_addr, m_size) != 0) {
             throw std::system_error{errno, std::system_category(), "munmap failed"};
@@ -591,7 +613,7 @@ inline void osmium::MemoryMapping::unmap() {
     }
 }
 
-inline void osmium::MemoryMapping::resize(std::size_t new_size) {
+inline void osmium::util::MemoryMapping::resize(std::size_t new_size) {
     assert(new_size > 0 && "can not resize to zero size");
     if (m_fd == -1) { // anonymous mapping
 #ifdef __linux__
@@ -641,7 +663,7 @@ namespace osmium {
 
 } // namespace osmium
 
-inline DWORD osmium::MemoryMapping::get_protection() const noexcept {
+inline DWORD osmium::util::MemoryMapping::get_protection() const noexcept {
     switch (m_mapping_mode) {
         case mapping_mode::readonly:
             return PAGE_READONLY;
@@ -653,7 +675,7 @@ inline DWORD osmium::MemoryMapping::get_protection() const noexcept {
     return PAGE_READWRITE;
 }
 
-inline DWORD osmium::MemoryMapping::get_flags() const noexcept {
+inline DWORD osmium::util::MemoryMapping::get_flags() const noexcept {
     switch (m_mapping_mode) {
         case mapping_mode::readonly:
             return FILE_MAP_READ;
@@ -665,14 +687,14 @@ inline DWORD osmium::MemoryMapping::get_flags() const noexcept {
     return FILE_MAP_WRITE;
 }
 
-inline HANDLE osmium::MemoryMapping::get_handle() const noexcept {
+inline HANDLE osmium::util::MemoryMapping::get_handle() const noexcept {
     if (m_fd == -1) {
         return INVALID_HANDLE_VALUE;
     }
     return reinterpret_cast<HANDLE>(_get_osfhandle(m_fd));
 }
 
-inline HANDLE osmium::MemoryMapping::create_file_mapping() const noexcept {
+inline HANDLE osmium::util::MemoryMapping::create_file_mapping() const noexcept {
     if (m_fd != -1) {
         _setmode(m_fd, _O_BINARY);
     }
@@ -684,7 +706,7 @@ inline HANDLE osmium::MemoryMapping::create_file_mapping() const noexcept {
                              nullptr);
 }
 
-inline void* osmium::MemoryMapping::map_view_of_file() const noexcept {
+inline void* osmium::util::MemoryMapping::map_view_of_file() const noexcept {
     return MapViewOfFile(m_handle,
                          get_flags(),
                          osmium::dword_hi(m_offset),
@@ -692,11 +714,11 @@ inline void* osmium::MemoryMapping::map_view_of_file() const noexcept {
                          m_size);
 }
 
-inline bool osmium::MemoryMapping::is_valid() const noexcept {
+inline bool osmium::util::MemoryMapping::is_valid() const noexcept {
     return m_addr != nullptr;
 }
 
-inline void osmium::MemoryMapping::make_invalid() noexcept {
+inline void osmium::util::MemoryMapping::make_invalid() noexcept {
     m_addr = nullptr;
 }
 
@@ -707,7 +729,7 @@ inline int last_error() noexcept {
     return static_cast<int>(GetLastError());
 }
 
-inline osmium::MemoryMapping::MemoryMapping(std::size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset) :
+inline osmium::util::MemoryMapping::MemoryMapping(std::size_t size, MemoryMapping::mapping_mode mode, int fd, off_t offset) :
     m_size(check_size(size)),
     m_offset(offset),
     m_fd(resize_fd(fd)),
@@ -725,7 +747,7 @@ inline osmium::MemoryMapping::MemoryMapping(std::size_t size, MemoryMapping::map
     }
 }
 
-inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
+inline osmium::util::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     m_size(other.m_size),
     m_offset(other.m_offset),
     m_fd(other.m_fd),
@@ -736,8 +758,13 @@ inline osmium::MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept :
     other.m_handle = nullptr;
 }
 
-inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMapping&& other) noexcept {
-    unmap();
+inline osmium::util::MemoryMapping& osmium::util::MemoryMapping::operator=(osmium::util::MemoryMapping&& other) noexcept {
+    try {
+        unmap();
+    } catch (const std::system_error&) {
+        // Ignore unmap error. It should never happen anyway and we can't do
+        // anything about it here.
+    }
     m_size         = other.m_size;
     m_offset       = other.m_offset;
     m_fd           = other.m_fd;
@@ -749,7 +776,7 @@ inline osmium::MemoryMapping& osmium::MemoryMapping::operator=(osmium::MemoryMap
     return *this;
 }
 
-inline void osmium::MemoryMapping::unmap() {
+inline void osmium::util::MemoryMapping::unmap() {
     if (is_valid()) {
         if (!UnmapViewOfFile(m_addr)) {
             throw std::system_error{last_error(), std::system_category(), "UnmapViewOfFile failed"};
@@ -765,7 +792,7 @@ inline void osmium::MemoryMapping::unmap() {
     }
 }
 
-inline void osmium::MemoryMapping::resize(std::size_t new_size) {
+inline void osmium::util::MemoryMapping::resize(std::size_t new_size) {
     unmap();
 
     m_size = new_size;
diff --git a/third_party/libosmium/include/osmium/util/minmax.hpp b/third_party/libosmium/include/osmium/util/minmax.hpp
index 22c2ea44e..d150486e9 100644
--- a/third_party/libosmium/include/osmium/util/minmax.hpp
+++ b/third_party/libosmium/include/osmium/util/minmax.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/misc.hpp b/third_party/libosmium/include/osmium/util/misc.hpp
index d0bdce894..b737d2087 100644
--- a/third_party/libosmium/include/osmium/util/misc.hpp
+++ b/third_party/libosmium/include/osmium/util/misc.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/options.hpp b/third_party/libosmium/include/osmium/util/options.hpp
index 0e99be21b..df65c9265 100644
--- a/third_party/libosmium/include/osmium/util/options.hpp
+++ b/third_party/libosmium/include/osmium/util/options.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -138,6 +138,15 @@ namespace osmium {
                 return (value == "true" || value == "yes");
             }
 
+            /**
+             * Is this option set to a false value ("false" or "no")?
+             * Will return false if the value is unset.
+             */
+            bool is_false(const std::string& key) const noexcept {
+                const std::string value{get(key)};
+                return (value == "false" || value == "no");
+            }
+
             /**
              * Is this option not set to a false value ("false" or "no")?
              * Will return true if the value is unset.
@@ -147,6 +156,13 @@ namespace osmium {
                 return !(value == "false" || value == "no");
             }
 
+            /**
+             * Is the set of options empty?
+             */
+            bool empty() const noexcept {
+                return m_options.empty();
+            }
+
             /**
              * The number of options set.
              */
diff --git a/third_party/libosmium/include/osmium/util/progress_bar.hpp b/third_party/libosmium/include/osmium/util/progress_bar.hpp
index 1c246f40d..0b115172b 100644
--- a/third_party/libosmium/include/osmium/util/progress_bar.hpp
+++ b/third_party/libosmium/include/osmium/util/progress_bar.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -45,18 +45,20 @@ namespace osmium {
      */
     class ProgressBar {
 
-        static constexpr const std::size_t full_length = 70;
+        enum {
+            full_length = 70
+        };
 
         static const char* bar(std::size_t len = full_length) noexcept {
+            static const char* s = "======================================================================";
             assert(len <= full_length);
-            return "======================================================================"
-                   + full_length - len;
+            return s + full_length - len;
         }
 
         static const char* spc(std::size_t len = full_length) noexcept {
+            static const char* s = "                                                                     ";
             assert(len >= 1 && len <= full_length);
-            return "                                                                     "
-                   + full_length - len;
+            return s + full_length - len;
         }
 
         // The max size is the file size if there is a single file and the
@@ -89,7 +91,7 @@ namespace osmium {
             }
             m_prev_percent = percent;
 
-            const auto num = static_cast<std::size_t>(percent * (full_length / 100.0));
+            const auto num = static_cast<std::size_t>(percent * (static_cast<double>(full_length) / 100.0));
             std::cerr << '[';
             if (num >= full_length) {
                 std::cerr << bar();
diff --git a/third_party/libosmium/include/osmium/util/string.hpp b/third_party/libosmium/include/osmium/util/string.hpp
index 9513166c4..201a00ea9 100644
--- a/third_party/libosmium/include/osmium/util/string.hpp
+++ b/third_party/libosmium/include/osmium/util/string.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
diff --git a/third_party/libosmium/include/osmium/util/string_matcher.hpp b/third_party/libosmium/include/osmium/util/string_matcher.hpp
index 2bb318b7d..f15f2a5ef 100644
--- a/third_party/libosmium/include/osmium/util/string_matcher.hpp
+++ b/third_party/libosmium/include/osmium/util/string_matcher.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -33,8 +33,7 @@ DEALINGS IN THE SOFTWARE.
 
 */
 
-#include <boost/variant.hpp>
-
+#include <algorithm>
 #include <cstring>
 #include <iosfwd>
 #include <regex>
@@ -42,6 +41,20 @@ DEALINGS IN THE SOFTWARE.
 #include <utility>
 #include <vector>
 
+#ifdef __has_include
+# if __has_include(<variant>)
+#  include <variant>
+#  ifdef __cpp_lib_variant
+#   define OSMIUM_USE_STD_VARIANT
+#  endif
+# endif
+#endif
+
+#ifndef OSMIUM_USE_STD_VARIANT
+# include <boost/variant.hpp>
+#endif
+
+
 // std::regex isn't implemented properly in glibc++ (before the version
 // delivered with GCC 4.9) and libc++ before the version 3.6, so the use is
 // disabled by these checks. Checks for GLIBC were based on
@@ -85,7 +98,7 @@ namespace osmium {
 
         public:
 
-            bool match(const char* /*test_string*/) const noexcept {
+            static bool match(const char* /*test_string*/) noexcept {
                 return false;
             }
 
@@ -103,7 +116,7 @@ namespace osmium {
 
         public:
 
-            bool match(const char* /*test_string*/) const noexcept {
+            static bool match(const char* /*test_string*/) noexcept {
                 return true;
             }
 
@@ -250,13 +263,10 @@ namespace osmium {
             }
 
             bool match(const char* test_string) const noexcept {
-                for (const auto& s : m_strings) {
-                    if (!std::strcmp(s.c_str(), test_string)) {
-                        return true;
-                    }
-                }
-                return false;
-
+                return std::any_of(m_strings.cbegin(), m_strings.cend(),
+                                   [&test_string](const std::string& s){
+                    return s == test_string;
+                });
             }
 
             template <typename TChar, typename TTraits>
@@ -272,19 +282,29 @@ namespace osmium {
 
     private:
 
-        using matcher_type = boost::variant<always_false,
-                                            always_true,
-                                            equal,
-                                            prefix,
-                                            substring,
-#ifdef OSMIUM_WITH_REGEX
-                                            regex,
+        using matcher_type =
+#ifdef OSMIUM_USE_STD_VARIANT
+            std::variant
+#else
+            boost::variant
 #endif
-                                            list>;
+                <always_false,
+                 always_true,
+                 equal,
+                 prefix,
+                 substring,
+#ifdef OSMIUM_WITH_REGEX
+                 regex,
+#endif
+                 list>;
 
         matcher_type m_matcher;
 
-        class match_visitor : public boost::static_visitor<bool> {
+        class match_visitor
+#ifndef OSMIUM_USE_STD_VARIANT
+        : public boost::static_visitor<bool>
+#endif
+        {
 
             const char* m_str;
 
@@ -302,7 +322,11 @@ namespace osmium {
         }; // class match_visitor
 
         template <typename TChar, typename TTraits>
-        class print_visitor : public boost::static_visitor<void> {
+        class print_visitor
+#ifndef OSMIUM_USE_STD_VARIANT
+        : public boost::static_visitor<void>
+#endif
+        {
 
             std::basic_ostream<TChar, TTraits>* m_out;
 
@@ -336,6 +360,7 @@ namespace osmium {
          * or
          * @code StringMatcher{StringMatcher::always_false}; @endcode
          */
+        // cppcheck-suppress noExplicitConstructor
         StringMatcher(bool result) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(always_false{}) {
             if (result) {
@@ -348,6 +373,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::equal{str}}; @endcode
          */
+        // cppcheck-suppress noExplicitConstructor
         StringMatcher(const char* str) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(equal{str}) {
         }
@@ -357,6 +383,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::equal{str}}; @endcode
          */
+        // cppcheck-suppress noExplicitConstructor
         StringMatcher(const std::string& str) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(equal{str}) {
         }
@@ -367,6 +394,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::regex{aregex}}; @endcode
          */
+        // cppcheck-suppress noExplicitConstructor
         StringMatcher(const std::regex& aregex) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(regex{aregex}) {
         }
@@ -378,6 +406,7 @@ namespace osmium {
          * Shortcut for
          * @code StringMatcher{StringMatcher::list{strings}}; @endcode
          */
+        // cppcheck-suppress noExplicitConstructor
         StringMatcher(const std::vector<std::string>& strings) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(list{strings}) {
         }
@@ -389,9 +418,10 @@ namespace osmium {
          *                  osmium::StringMatcher::always_false, always_true,
          *                  equal, prefix, substring, regex or list.
          */
-        template <typename TMatcher, typename std::enable_if<
-            std::is_base_of<matcher, TMatcher>::value, int>::type = 0>
-        StringMatcher(TMatcher&& matcher) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions, misc-forwarding-reference-overload)
+        // cppcheck-suppress noExplicitConstructor
+        template <typename TMatcher, typename X = typename std::enable_if<
+            std::is_base_of<matcher, TMatcher>::value, void>::type>
+        StringMatcher(TMatcher&& matcher) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(std::forward<TMatcher>(matcher)) {
         }
 
@@ -399,7 +429,11 @@ namespace osmium {
          * Match the specified string.
          */
         bool operator()(const char* str) const noexcept {
+#ifdef OSMIUM_USE_STD_VARIANT
+            return std::visit(match_visitor{str}, m_matcher);
+#else
             return boost::apply_visitor(match_visitor{str}, m_matcher);
+#endif
         }
 
         /**
@@ -411,7 +445,11 @@ namespace osmium {
 
         template <typename TChar, typename TTraits>
         void print(std::basic_ostream<TChar, TTraits>& out) const {
+#ifdef OSMIUM_USE_STD_VARIANT
+            std::visit(print_visitor<TChar, TTraits>{out}, m_matcher);
+#else
             boost::apply_visitor(print_visitor<TChar, TTraits>{out}, m_matcher);
+#endif
         }
 
     }; // class StringMatcher
@@ -424,4 +462,6 @@ namespace osmium {
 
 } // namespace osmium
 
+#undef OSMIUM_USE_STD_VARIANT
+
 #endif // OSMIUM_UTIL_STRING_MATCHER_HPP
diff --git a/third_party/libosmium/include/osmium/util/timer.hpp b/third_party/libosmium/include/osmium/util/timer.hpp
index 01661727b..27f3a57b7 100644
--- a/third_party/libosmium/include/osmium/util/timer.hpp
+++ b/third_party/libosmium/include/osmium/util/timer.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -79,13 +79,13 @@ namespace osmium {
 
         Timer() = default;
 
-        void start() {
+        void start() const noexcept { // NOLINT(readability-convert-member-functions-to-static)
         }
 
-        void stop() {
+        void stop() const noexcept { // NOLINT(readability-convert-member-functions-to-static)
         }
 
-        int64_t elapsed_microseconds() const {
+        int64_t elapsed_microseconds() const noexcept { // NOLINT(readability-convert-member-functions-to-static)
             return 0;
         }
 
diff --git a/third_party/libosmium/include/osmium/util/verbose_output.hpp b/third_party/libosmium/include/osmium/util/verbose_output.hpp
index 066f1158f..ba5f96563 100644
--- a/third_party/libosmium/include/osmium/util/verbose_output.hpp
+++ b/third_party/libosmium/include/osmium/util/verbose_output.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -61,13 +61,13 @@ namespace osmium {
         class VerboseOutput {
 
             /// all time output will be relative to this start time
-            time_t m_start;
+            std::time_t m_start;
 
             /// is verbose mode enabled?
             bool m_verbose;
 
             /// a newline was written, start next output with runtime
-            bool m_newline;
+            bool m_newline = true;
 
             /**
              * If we remember that a newline was written as the last thing
@@ -75,7 +75,7 @@ namespace osmium {
              */
             void start_line() {
                 if (m_newline) {
-                    const time_t elapsed = runtime();
+                    const std::time_t elapsed = runtime();
 
                     const char old_fill = std::cerr.fill();
                     std::cerr << '[' << std::setw(2) << (elapsed / 60) << ':' << std::setw(2) << std::setfill('0') << (elapsed % 60) << "] ";
@@ -88,13 +88,12 @@ namespace osmium {
         public:
 
             explicit VerboseOutput(bool verbose = false) noexcept :
-                m_start(time(nullptr)),
-                m_verbose(verbose),
-                m_newline(true) {
+                m_start(std::time(nullptr)),
+                m_verbose(verbose) {
             }
 
-            time_t runtime() const noexcept {
-                return time(nullptr) - m_start;
+            std::time_t runtime() const noexcept {
+                return std::time(nullptr) - m_start;
             }
 
             /// Get "verbose" setting.
diff --git a/third_party/libosmium/include/osmium/version.hpp b/third_party/libosmium/include/osmium/version.hpp
index 877b66e61..136a1e601 100644
--- a/third_party/libosmium/include/osmium/version.hpp
+++ b/third_party/libosmium/include/osmium/version.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,9 +34,9 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #define LIBOSMIUM_VERSION_MAJOR 2
-#define LIBOSMIUM_VERSION_MINOR 14
+#define LIBOSMIUM_VERSION_MINOR 18
 #define LIBOSMIUM_VERSION_PATCH 0
 
-#define LIBOSMIUM_VERSION_STRING "2.14.0"
+#define LIBOSMIUM_VERSION_STRING "2.18.0"
 
 #endif // OSMIUM_VERSION_HPP
diff --git a/third_party/libosmium/include/osmium/visitor.hpp b/third_party/libosmium/include/osmium/visitor.hpp
index 6ea2c2565..ce29af307 100644
--- a/third_party/libosmium/include/osmium/visitor.hpp
+++ b/third_party/libosmium/include/osmium/visitor.hpp
@@ -3,9 +3,9 @@
 
 /*
 
-This file is part of Osmium (http://osmcode.org/libosmium).
+This file is part of Osmium (https://osmcode.org/libosmium).
 
-Copyright 2013-2018 Jochen Topf <jochen@topf.org> and others (see README).
+Copyright 2013-2022 Jochen Topf <jochen@topf.org> and others (see README).
 
 Boost Software License - Version 1.0 - August 17th, 2003
 
@@ -34,6 +34,7 @@ DEALINGS IN THE SOFTWARE.
 */
 
 #include <osmium/fwd.hpp>
+#include <osmium/handler.hpp>
 #include <osmium/io/reader_iterator.hpp> // IWYU pragma: keep
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm.hpp>
@@ -56,42 +57,42 @@ namespace osmium {
                 case osmium::item_type::undefined:
                     break;
                 case osmium::item_type::node:
-                    std::forward<THandler>(handler).osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
-                    std::forward<THandler>(handler).node(static_cast<ConstIfConst<TItem, osmium::Node>&>(item));
+                    handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
+                    handler.node(static_cast<ConstIfConst<TItem, osmium::Node>&>(item));
                     break;
                 case osmium::item_type::way:
-                    std::forward<THandler>(handler).osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
-                    std::forward<THandler>(handler).way(static_cast<ConstIfConst<TItem, osmium::Way>&>(item));
+                    handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
+                    handler.way(static_cast<ConstIfConst<TItem, osmium::Way>&>(item));
                     break;
                 case osmium::item_type::relation:
-                    std::forward<THandler>(handler).osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
-                    std::forward<THandler>(handler).relation(static_cast<ConstIfConst<TItem, osmium::Relation>&>(item));
+                    handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
+                    handler.relation(static_cast<ConstIfConst<TItem, osmium::Relation>&>(item));
                     break;
                 case osmium::item_type::area:
-                    std::forward<THandler>(handler).osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
-                    std::forward<THandler>(handler).area(static_cast<ConstIfConst<TItem, osmium::Area>&>(item));
+                    handler.osm_object(static_cast<ConstIfConst<TItem, osmium::OSMObject>&>(item));
+                    handler.area(static_cast<ConstIfConst<TItem, osmium::Area>&>(item));
                     break;
                 case osmium::item_type::changeset:
-                    std::forward<THandler>(handler).changeset(static_cast<ConstIfConst<TItem, osmium::Changeset>&>(item));
+                    handler.changeset(static_cast<ConstIfConst<TItem, osmium::Changeset>&>(item));
                     break;
                 case osmium::item_type::tag_list:
-                    std::forward<THandler>(handler).tag_list(static_cast<ConstIfConst<TItem, osmium::TagList>&>(item));
+                    handler.tag_list(static_cast<ConstIfConst<TItem, osmium::TagList>&>(item));
                     break;
                 case osmium::item_type::way_node_list:
-                    std::forward<THandler>(handler).way_node_list(static_cast<ConstIfConst<TItem, osmium::WayNodeList>&>(item));
+                    handler.way_node_list(static_cast<ConstIfConst<TItem, osmium::WayNodeList>&>(item));
                     break;
                 case osmium::item_type::relation_member_list:
                 case osmium::item_type::relation_member_list_with_full_members:
-                    std::forward<THandler>(handler).relation_member_list(static_cast<ConstIfConst<TItem, osmium::RelationMemberList>&>(item));
+                    handler.relation_member_list(static_cast<ConstIfConst<TItem, osmium::RelationMemberList>&>(item));
                     break;
                 case osmium::item_type::outer_ring:
-                    std::forward<THandler>(handler).outer_ring(static_cast<ConstIfConst<TItem, osmium::OuterRing>&>(item));
+                    handler.outer_ring(static_cast<ConstIfConst<TItem, osmium::OuterRing>&>(item));
                     break;
                 case osmium::item_type::inner_ring:
-                    std::forward<THandler>(handler).inner_ring(static_cast<ConstIfConst<TItem, osmium::InnerRing>&>(item));
+                    handler.inner_ring(static_cast<ConstIfConst<TItem, osmium::InnerRing>&>(item));
                     break;
                 case osmium::item_type::changeset_discussion:
-                    std::forward<THandler>(handler).changeset_discussion(static_cast<ConstIfConst<TItem, osmium::ChangesetDiscussion>&>(item));
+                    handler.changeset_discussion(static_cast<ConstIfConst<TItem, osmium::ChangesetDiscussion>&>(item));
                     break;
             }
         }
@@ -100,23 +101,23 @@ namespace osmium {
         inline void apply_item_impl(const osmium::OSMEntity& item, THandler&& handler) {
             switch (item.type()) {
                 case osmium::item_type::node:
-                    std::forward<THandler>(handler).osm_object(static_cast<const osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).node(static_cast<const osmium::Node&>(item));
+                    handler.osm_object(static_cast<const osmium::OSMObject&>(item));
+                    handler.node(static_cast<const osmium::Node&>(item));
                     break;
                 case osmium::item_type::way:
-                    std::forward<THandler>(handler).osm_object(static_cast<const osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).way(static_cast<const osmium::Way&>(item));
+                    handler.osm_object(static_cast<const osmium::OSMObject&>(item));
+                    handler.way(static_cast<const osmium::Way&>(item));
                     break;
                 case osmium::item_type::relation:
-                    std::forward<THandler>(handler).osm_object(static_cast<const osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).relation(static_cast<const osmium::Relation&>(item));
+                    handler.osm_object(static_cast<const osmium::OSMObject&>(item));
+                    handler.relation(static_cast<const osmium::Relation&>(item));
                     break;
                 case osmium::item_type::area:
-                    std::forward<THandler>(handler).osm_object(static_cast<const osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).area(static_cast<const osmium::Area&>(item));
+                    handler.osm_object(static_cast<const osmium::OSMObject&>(item));
+                    handler.area(static_cast<const osmium::Area&>(item));
                     break;
                 case osmium::item_type::changeset:
-                    std::forward<THandler>(handler).changeset(static_cast<const osmium::Changeset&>(item));
+                    handler.changeset(static_cast<const osmium::Changeset&>(item));
                     break;
                 default:
                     throw osmium::unknown_type{};
@@ -127,23 +128,23 @@ namespace osmium {
         inline void apply_item_impl(osmium::OSMEntity& item, THandler&& handler) {
             switch (item.type()) {
                 case osmium::item_type::node:
-                    std::forward<THandler>(handler).osm_object(static_cast<osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).node(static_cast<osmium::Node&>(item));
+                    handler.osm_object(static_cast<osmium::OSMObject&>(item));
+                    handler.node(static_cast<osmium::Node&>(item));
                     break;
                 case osmium::item_type::way:
-                    std::forward<THandler>(handler).osm_object(static_cast<osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).way(static_cast<osmium::Way&>(item));
+                    handler.osm_object(static_cast<osmium::OSMObject&>(item));
+                    handler.way(static_cast<osmium::Way&>(item));
                     break;
                 case osmium::item_type::relation:
-                    std::forward<THandler>(handler).osm_object(static_cast<osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).relation(static_cast<osmium::Relation&>(item));
+                    handler.osm_object(static_cast<osmium::OSMObject&>(item));
+                    handler.relation(static_cast<osmium::Relation&>(item));
                     break;
                 case osmium::item_type::area:
-                    std::forward<THandler>(handler).osm_object(static_cast<osmium::OSMObject&>(item));
-                    std::forward<THandler>(handler).area(static_cast<osmium::Area&>(item));
+                    handler.osm_object(static_cast<osmium::OSMObject&>(item));
+                    handler.area(static_cast<osmium::Area&>(item));
                     break;
                 case osmium::item_type::changeset:
-                    std::forward<THandler>(handler).changeset(static_cast<osmium::Changeset&>(item));
+                    handler.changeset(static_cast<osmium::Changeset&>(item));
                     break;
                 default:
                     throw osmium::unknown_type{};
@@ -154,20 +155,20 @@ namespace osmium {
         inline void apply_item_impl(const osmium::OSMObject& item, THandler&& handler) {
             switch (item.type()) {
                 case osmium::item_type::node:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).node(static_cast<const osmium::Node&>(item));
+                    handler.osm_object(item);
+                    handler.node(static_cast<const osmium::Node&>(item));
                     break;
                 case osmium::item_type::way:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).way(static_cast<const osmium::Way&>(item));
+                    handler.osm_object(item);
+                    handler.way(static_cast<const osmium::Way&>(item));
                     break;
                 case osmium::item_type::relation:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).relation(static_cast<const osmium::Relation&>(item));
+                    handler.osm_object(item);
+                    handler.relation(static_cast<const osmium::Relation&>(item));
                     break;
                 case osmium::item_type::area:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).area(static_cast<const osmium::Area&>(item));
+                    handler.osm_object(item);
+                    handler.area(static_cast<const osmium::Area&>(item));
                     break;
                 default:
                     throw osmium::unknown_type{};
@@ -178,48 +179,152 @@ namespace osmium {
         inline void apply_item_impl(osmium::OSMObject& item, THandler&& handler) {
             switch (item.type()) {
                 case osmium::item_type::node:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).node(static_cast<osmium::Node&>(item));
+                    handler.osm_object(item);
+                    handler.node(static_cast<osmium::Node&>(item));
                     break;
                 case osmium::item_type::way:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).way(static_cast<osmium::Way&>(item));
+                    handler.osm_object(item);
+                    handler.way(static_cast<osmium::Way&>(item));
                     break;
                 case osmium::item_type::relation:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).relation(static_cast<osmium::Relation&>(item));
+                    handler.osm_object(item);
+                    handler.relation(static_cast<osmium::Relation&>(item));
                     break;
                 case osmium::item_type::area:
-                    std::forward<THandler>(handler).osm_object(item);
-                    std::forward<THandler>(handler).area(static_cast<osmium::Area&>(item));
+                    handler.osm_object(item);
+                    handler.area(static_cast<osmium::Area&>(item));
                     break;
                 default:
                     throw osmium::unknown_type{};
             }
         }
 
+        template <typename TFunc>
+        struct wrapper_handler : TFunc {
+
+            template <typename T>
+            explicit wrapper_handler(T&& func) : TFunc(std::forward<T>(func)) { // NOLINT(bugprone-forwarding-reference-overload)
+            }
+
+            // Fallback that always matches.
+            void operator()(const osmium::memory::Item& /*item*/) const noexcept {
+            }
+
+            // The function we are wrapping.
+            using TFunc::operator();
+
+            void osm_object(const osmium::OSMObject& /*osm_object*/) const noexcept {
+            }
+
+            void node(const osmium::Node& node) const {
+                operator()(node);
+            }
+
+            // cppcheck-suppress constParameter
+            void node(osmium::Node& node) const {
+                operator()(node);
+            }
+
+            void way(const osmium::Way& way) const {
+                operator()(way);
+            }
+
+            // cppcheck-suppress constParameter
+            void way(osmium::Way& way) const {
+                operator()(way);
+            }
+
+            void relation(const osmium::Relation& relation) const {
+                operator()(relation);
+            }
+
+            // cppcheck-suppress constParameter
+            void relation(osmium::Relation& relation) const {
+                operator()(relation);
+            }
+
+            void area(const osmium::Area& area) const {
+                operator()(area);
+            }
+
+            // cppcheck-suppress constParameter
+            void area(osmium::Area& area) const {
+                operator()(area);
+            }
+
+            void changeset(const osmium::Changeset& changeset) const {
+                operator()(changeset);
+            }
+
+            // cppcheck-suppress constParameter
+            void changeset(osmium::Changeset& changeset) const {
+                operator()(changeset);
+            }
+
+            void tag_list(const osmium::TagList& /*tag_list*/) const noexcept {
+            }
+
+            void way_node_list(const osmium::WayNodeList& /*way_node_list*/) const noexcept {
+            }
+
+            void relation_member_list(const osmium::RelationMemberList& /*relation_member_list*/) const noexcept {
+            }
+
+            void outer_ring(const osmium::OuterRing& /*outer_ring*/) const noexcept {
+            }
+
+            void inner_ring(const osmium::InnerRing& /*inner_ring*/) const noexcept {
+            }
+
+            void changeset_discussion(const osmium::ChangesetDiscussion& /*changeset_discussion*/) const noexcept {
+            }
+
+            void flush() const noexcept {
+            }
+
+        }; // struct wrapper_handler
+
+        // Is the class T derived from osmium::handler::Handler?
+        template <typename T>
+        using is_handler = std::is_base_of<osmium::handler::Handler, typename std::remove_reference<T>::type>;
+
+        // This is already a handler, use it as it is.
+        template <typename T, typename = typename std::enable_if<is_handler<T>::value>::type>
+        T make_handler(T&& func) {
+            return std::forward<T>(func);
+        }
+
+        // This is not a handler, but a functor. Wrap a handler around it.
+        template <typename T, typename = typename std::enable_if<!is_handler<T>::value>::type>
+        wrapper_handler<typename std::decay<T>::type> make_handler(T&& func) {
+            return wrapper_handler<typename std::decay<T>::type>(std::forward<T>(func));
+        }
+
     } // namespace detail
 
     template <typename TItem, typename... THandlers>
     inline void apply_item(TItem& item, THandlers&&... handlers) {
         (void)std::initializer_list<int>{
-            (detail::apply_item_impl(item, std::forward<THandlers>(handlers)), 0)...
-        };
+            (detail::apply_item_impl(item, std::forward<THandlers>(handlers)), 0)...};
     }
 
     template <typename... THandlers>
     inline void apply_flush(THandlers&&... handlers) {
         (void)std::initializer_list<int>{
-            (std::forward<THandlers>(handlers).flush(), 0)...
-        };
+            (std::forward<THandlers>(handlers).flush(), 0)...};
+    }
+
+    template <typename TIterator, typename... THandlers>
+    inline void apply_impl(TIterator it, TIterator end, THandlers&&... handlers) {
+        for (; it != end; ++it) {
+            apply_item(*it, handlers...);
+        }
+        apply_flush(std::forward<THandlers>(handlers)...);
     }
 
     template <typename TIterator, typename... THandlers>
     inline void apply(TIterator it, TIterator end, THandlers&&... handlers) {
-        for (; it != end; ++it) {
-            apply_item(*it, std::forward<THandlers>(handlers)...);
-        }
-        apply_flush(std::forward<THandlers>(handlers)...);
+        apply_impl(it, end, detail::make_handler<THandlers>(std::forward<THandlers>(handlers))...);
     }
 
     template <typename TContainer, typename... THandlers>
diff --git a/third_party/libosmium/include/utf8/checked.h b/third_party/libosmium/include/utf8/checked.h
deleted file mode 100644
index 133115513..000000000
--- a/third_party/libosmium/include/utf8/checked.h
+++ /dev/null
@@ -1,327 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-#include <stdexcept>
-
-namespace utf8
-{
-    // Base for the exceptions that may be thrown from the library
-    class exception : public ::std::exception {
-    };
-
-    // Exceptions that may be thrown from the library functions.
-    class invalid_code_point : public exception {
-        uint32_t cp;
-    public:
-        invalid_code_point(uint32_t cp) : cp(cp) {}
-        virtual const char* what() const throw() { return "Invalid code point"; }
-        uint32_t code_point() const {return cp;}
-    };
-
-    class invalid_utf8 : public exception {
-        uint8_t u8;
-    public:
-        invalid_utf8 (uint8_t u) : u8(u) {}
-        virtual const char* what() const throw() { return "Invalid UTF-8"; }
-        uint8_t utf8_octet() const {return u8;}
-    };
-
-    class invalid_utf16 : public exception {
-        uint16_t u16;
-    public:
-        invalid_utf16 (uint16_t u) : u16(u) {}
-        virtual const char* what() const throw() { return "Invalid UTF-16"; }
-        uint16_t utf16_word() const {return u16;}
-    };
-
-    class not_enough_room : public exception {
-    public:
-        virtual const char* what() const throw() { return "Not enough space"; }
-    };
-
-    /// The library API - functions intended to be called by the users
-
-    template <typename octet_iterator>
-    octet_iterator append(uint32_t cp, octet_iterator result)
-    {
-        if (!utf8::internal::is_code_point_valid(cp))
-            throw invalid_code_point(cp);
-
-        if (cp < 0x80)                        // one octet
-            *(result++) = static_cast<uint8_t>(cp);
-        else if (cp < 0x800) {                // two octets
-            *(result++) = static_cast<uint8_t>((cp >> 6)            | 0xc0);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        else if (cp < 0x10000) {              // three octets
-            *(result++) = static_cast<uint8_t>((cp >> 12)           | 0xe0);
-            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        else {                                // four octets
-            *(result++) = static_cast<uint8_t>((cp >> 18)           | 0xf0);
-            *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)  | 0x80);
-            *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f)   | 0x80);
-            *(result++) = static_cast<uint8_t>((cp & 0x3f)          | 0x80);
-        }
-        return result;
-    }
-
-    template <typename octet_iterator, typename output_iterator>
-    output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out, uint32_t replacement)
-    {
-        while (start != end) {
-            octet_iterator sequence_start = start;
-            internal::utf_error err_code = utf8::internal::validate_next(start, end);
-            switch (err_code) {
-                case internal::UTF8_OK :
-                    for (octet_iterator it = sequence_start; it != start; ++it)
-                        *out++ = *it;
-                    break;
-                case internal::NOT_ENOUGH_ROOM:
-                    throw not_enough_room();
-                case internal::INVALID_LEAD:
-                    out = utf8::append (replacement, out);
-                    ++start;
-                    break;
-                case internal::INCOMPLETE_SEQUENCE:
-                case internal::OVERLONG_SEQUENCE:
-                case internal::INVALID_CODE_POINT:
-                    out = utf8::append (replacement, out);
-                    ++start;
-                    // just one replacement mark for the sequence
-                    while (start != end && utf8::internal::is_trail(*start))
-                        ++start;
-                    break;
-            }
-        }
-        return out;
-    }
-
-    template <typename octet_iterator, typename output_iterator>
-    inline output_iterator replace_invalid(octet_iterator start, octet_iterator end, output_iterator out)
-    {
-        static const uint32_t replacement_marker = utf8::internal::mask16(0xfffd);
-        return utf8::replace_invalid(start, end, out, replacement_marker);
-    }
-
-    template <typename octet_iterator>
-    uint32_t next(octet_iterator& it, octet_iterator end)
-    {
-        uint32_t cp = 0;
-        internal::utf_error err_code = utf8::internal::validate_next(it, end, cp);
-        switch (err_code) {
-            case internal::UTF8_OK :
-                break;
-            case internal::NOT_ENOUGH_ROOM :
-                throw not_enough_room();
-            case internal::INVALID_LEAD :
-            case internal::INCOMPLETE_SEQUENCE :
-            case internal::OVERLONG_SEQUENCE :
-                throw invalid_utf8(*it);
-            case internal::INVALID_CODE_POINT :
-                throw invalid_code_point(cp);
-        }
-        return cp;
-    }
-
-    template <typename octet_iterator>
-    uint32_t peek_next(octet_iterator it, octet_iterator end)
-    {
-        return utf8::next(it, end);
-    }
-
-    template <typename octet_iterator>
-    uint32_t prior(octet_iterator& it, octet_iterator start)
-    {
-        // can't do much if it == start
-        if (it == start)
-            throw not_enough_room();
-
-        octet_iterator end = it;
-        // Go back until we hit either a lead octet or start
-        while (utf8::internal::is_trail(*(--it)))
-            if (it == start)
-                throw invalid_utf8(*it); // error - no lead byte in the sequence
-        return utf8::peek_next(it, end);
-    }
-
-    /// Deprecated in versions that include "prior"
-    template <typename octet_iterator>
-    uint32_t previous(octet_iterator& it, octet_iterator pass_start)
-    {
-        octet_iterator end = it;
-        while (utf8::internal::is_trail(*(--it)))
-            if (it == pass_start)
-                throw invalid_utf8(*it); // error - no lead byte in the sequence
-        octet_iterator temp = it;
-        return utf8::next(temp, end);
-    }
-
-    template <typename octet_iterator, typename distance_type>
-    void advance (octet_iterator& it, distance_type n, octet_iterator end)
-    {
-        for (distance_type i = 0; i < n; ++i)
-            utf8::next(it, end);
-    }
-
-    template <typename octet_iterator>
-    typename std::iterator_traits<octet_iterator>::difference_type
-    distance (octet_iterator first, octet_iterator last)
-    {
-        typename std::iterator_traits<octet_iterator>::difference_type dist;
-        for (dist = 0; first < last; ++dist)
-            utf8::next(first, last);
-        return dist;
-    }
-
-    template <typename u16bit_iterator, typename octet_iterator>
-    octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-    {
-        while (start != end) {
-            uint32_t cp = utf8::internal::mask16(*start++);
-            // Take care of surrogate pairs first
-            if (utf8::internal::is_lead_surrogate(cp)) {
-                if (start != end) {
-                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-                    if (utf8::internal::is_trail_surrogate(trail_surrogate))
-                        cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-                    else
-                        throw invalid_utf16(static_cast<uint16_t>(trail_surrogate));
-                }
-                else
-                    throw invalid_utf16(static_cast<uint16_t>(cp));
-
-            }
-            // Lone trail surrogate
-            else if (utf8::internal::is_trail_surrogate(cp))
-                throw invalid_utf16(static_cast<uint16_t>(cp));
-
-            result = utf8::append(cp, result);
-        }
-        return result;
-    }
-
-    template <typename u16bit_iterator, typename octet_iterator>
-    u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
-    {
-        while (start != end) {
-            uint32_t cp = utf8::next(start, end);
-            if (cp > 0xffff) { //make a surrogate pair
-                *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-                *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-            }
-            else
-                *result++ = static_cast<uint16_t>(cp);
-        }
-        return result;
-    }
-
-    template <typename octet_iterator, typename u32bit_iterator>
-    octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-    {
-        while (start != end)
-            result = utf8::append(*(start++), result);
-
-        return result;
-    }
-
-    template <typename octet_iterator, typename u32bit_iterator>
-    u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
-    {
-        while (start != end)
-            (*result++) = utf8::next(start, end);
-
-        return result;
-    }
-
-    // The iterator class
-    template <typename octet_iterator>
-    class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> {
-      octet_iterator it;
-      octet_iterator range_start;
-      octet_iterator range_end;
-      public:
-      iterator () {}
-      explicit iterator (const octet_iterator& octet_it,
-                         const octet_iterator& range_start,
-                         const octet_iterator& range_end) :
-               it(octet_it), range_start(range_start), range_end(range_end)
-      {
-          if (it < range_start || it > range_end)
-              throw std::out_of_range("Invalid utf-8 iterator position");
-      }
-      // the default "big three" are OK
-      octet_iterator base () const { return it; }
-      uint32_t operator * () const
-      {
-          octet_iterator temp = it;
-          return utf8::next(temp, range_end);
-      }
-      bool operator == (const iterator& rhs) const
-      {
-          if (range_start != rhs.range_start || range_end != rhs.range_end)
-              throw std::logic_error("Comparing utf-8 iterators defined with different ranges");
-          return (it == rhs.it);
-      }
-      bool operator != (const iterator& rhs) const
-      {
-          return !(operator == (rhs));
-      }
-      iterator& operator ++ ()
-      {
-          utf8::next(it, range_end);
-          return *this;
-      }
-      iterator operator ++ (int)
-      {
-          iterator temp = *this;
-          utf8::next(it, range_end);
-          return temp;
-      }
-      iterator& operator -- ()
-      {
-          utf8::prior(it, range_start);
-          return *this;
-      }
-      iterator operator -- (int)
-      {
-          iterator temp = *this;
-          utf8::prior(it, range_start);
-          return temp;
-      }
-    }; // class iterator
-
-} // namespace utf8
-
-#endif //header guard
-
-
diff --git a/third_party/libosmium/include/utf8/core.h b/third_party/libosmium/include/utf8/core.h
deleted file mode 100644
index 693d388c0..000000000
--- a/third_party/libosmium/include/utf8/core.h
+++ /dev/null
@@ -1,329 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_CORE_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include <iterator>
-
-namespace utf8
-{
-    // The typedefs for 8-bit, 16-bit and 32-bit unsigned integers
-    // You may need to change them to match your system.
-    // These typedefs have the same names as ones from cstdint, or boost/cstdint
-    typedef unsigned char   uint8_t;
-    typedef unsigned short  uint16_t;
-    typedef unsigned int    uint32_t;
-
-// Helper code - not intended to be directly called by the library users. May be changed at any time
-namespace internal
-{
-    // Unicode constants
-    // Leading (high) surrogates: 0xd800 - 0xdbff
-    // Trailing (low) surrogates: 0xdc00 - 0xdfff
-    const uint16_t LEAD_SURROGATE_MIN  = 0xd800u;
-    const uint16_t LEAD_SURROGATE_MAX  = 0xdbffu;
-    const uint16_t TRAIL_SURROGATE_MIN = 0xdc00u;
-    const uint16_t TRAIL_SURROGATE_MAX = 0xdfffu;
-    const uint16_t LEAD_OFFSET         = LEAD_SURROGATE_MIN - (0x10000 >> 10);
-    const uint32_t SURROGATE_OFFSET    = 0x10000u - (LEAD_SURROGATE_MIN << 10) - TRAIL_SURROGATE_MIN;
-
-    // Maximum valid value for a Unicode code point
-    const uint32_t CODE_POINT_MAX      = 0x0010ffffu;
-
-    template<typename octet_type>
-    inline uint8_t mask8(octet_type oc)
-    {
-        return static_cast<uint8_t>(0xff & oc);
-    }
-    template<typename u16_type>
-    inline uint16_t mask16(u16_type oc)
-    {
-        return static_cast<uint16_t>(0xffff & oc);
-    }
-    template<typename octet_type>
-    inline bool is_trail(octet_type oc)
-    {
-        return ((utf8::internal::mask8(oc) >> 6) == 0x2);
-    }
-
-    template <typename u16>
-    inline bool is_lead_surrogate(u16 cp)
-    {
-        return (cp >= LEAD_SURROGATE_MIN && cp <= LEAD_SURROGATE_MAX);
-    }
-
-    template <typename u16>
-    inline bool is_trail_surrogate(u16 cp)
-    {
-        return (cp >= TRAIL_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-    }
-
-    template <typename u16>
-    inline bool is_surrogate(u16 cp)
-    {
-        return (cp >= LEAD_SURROGATE_MIN && cp <= TRAIL_SURROGATE_MAX);
-    }
-
-    template <typename u32>
-    inline bool is_code_point_valid(u32 cp)
-    {
-        return (cp <= CODE_POINT_MAX && !utf8::internal::is_surrogate(cp));
-    }
-
-    template <typename octet_iterator>
-    inline typename std::iterator_traits<octet_iterator>::difference_type
-    sequence_length(octet_iterator lead_it)
-    {
-        uint8_t lead = utf8::internal::mask8(*lead_it);
-        if (lead < 0x80)
-            return 1;
-        else if ((lead >> 5) == 0x6)
-            return 2;
-        else if ((lead >> 4) == 0xe)
-            return 3;
-        else if ((lead >> 3) == 0x1e)
-            return 4;
-        else
-            return 0;
-    }
-
-    template <typename octet_difference_type>
-    inline bool is_overlong_sequence(uint32_t cp, octet_difference_type length)
-    {
-        if (cp < 0x80) {
-            if (length != 1) 
-                return true;
-        }
-        else if (cp < 0x800) {
-            if (length != 2) 
-                return true;
-        }
-        else if (cp < 0x10000) {
-            if (length != 3) 
-                return true;
-        }
-
-        return false;
-    }
-
-    enum utf_error {UTF8_OK, NOT_ENOUGH_ROOM, INVALID_LEAD, INCOMPLETE_SEQUENCE, OVERLONG_SEQUENCE, INVALID_CODE_POINT};
-
-    /// Helper for get_sequence_x
-    template <typename octet_iterator>
-    utf_error increase_safely(octet_iterator& it, octet_iterator end)
-    {
-        if (++it == end)
-            return NOT_ENOUGH_ROOM;
-
-        if (!utf8::internal::is_trail(*it))
-            return INCOMPLETE_SEQUENCE;
-        
-        return UTF8_OK;
-    }
-
-    #define UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(IT, END) {utf_error ret = increase_safely(IT, END); if (ret != UTF8_OK) return ret;}    
-
-    /// get_sequence_x functions decode utf-8 sequences of the length x
-    template <typename octet_iterator>
-    utf_error get_sequence_1(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-            return NOT_ENOUGH_ROOM;
-
-        code_point = utf8::internal::mask8(*it);
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_2(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end) 
-            return NOT_ENOUGH_ROOM;
-        
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 6) & 0x7ff) + ((*it) & 0x3f);
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_3(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-            return NOT_ENOUGH_ROOM;
-            
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (*it) & 0x3f;
-
-        return UTF8_OK;
-    }
-
-    template <typename octet_iterator>
-    utf_error get_sequence_4(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        if (it == end)
-           return NOT_ENOUGH_ROOM;
-
-        code_point = utf8::internal::mask8(*it);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point = ((code_point << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (utf8::internal::mask8(*it) << 6) & 0xfff;
-
-        UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR(it, end)
-
-        code_point += (*it) & 0x3f;
-
-        return UTF8_OK;
-    }
-
-    #undef UTF8_CPP_INCREASE_AND_RETURN_ON_ERROR
-
-    template <typename octet_iterator>
-    utf_error validate_next(octet_iterator& it, octet_iterator end, uint32_t& code_point)
-    {
-        // Save the original value of it so we can go back in case of failure
-        // Of course, it does not make much sense with i.e. stream iterators
-        octet_iterator original_it = it;
-
-        uint32_t cp = 0;
-        // Determine the sequence length based on the lead octet
-        typedef typename std::iterator_traits<octet_iterator>::difference_type octet_difference_type;
-        const octet_difference_type length = utf8::internal::sequence_length(it);
-
-        // Get trail octets and calculate the code point
-        utf_error err = UTF8_OK;
-        switch (length) {
-            case 0: 
-                return INVALID_LEAD;
-            case 1:
-                err = utf8::internal::get_sequence_1(it, end, cp);
-                break;
-            case 2:
-                err = utf8::internal::get_sequence_2(it, end, cp);
-            break;
-            case 3:
-                err = utf8::internal::get_sequence_3(it, end, cp);
-            break;
-            case 4:
-                err = utf8::internal::get_sequence_4(it, end, cp);
-            break;
-        }
-
-        if (err == UTF8_OK) {
-            // Decoding succeeded. Now, security checks...
-            if (utf8::internal::is_code_point_valid(cp)) {
-                if (!utf8::internal::is_overlong_sequence(cp, length)){
-                    // Passed! Return here.
-                    code_point = cp;
-                    ++it;
-                    return UTF8_OK;
-                }
-                else
-                    err = OVERLONG_SEQUENCE;
-            }
-            else 
-                err = INVALID_CODE_POINT;
-        }
-
-        // Failure branch - restore the original value of the iterator
-        it = original_it;
-        return err;
-    }
-
-    template <typename octet_iterator>
-    inline utf_error validate_next(octet_iterator& it, octet_iterator end) {
-        uint32_t ignored;
-        return utf8::internal::validate_next(it, end, ignored);
-    }
-
-} // namespace internal
-
-    /// The library API - functions intended to be called by the users
-
-    // Byte order mark
-    const uint8_t bom[] = {0xef, 0xbb, 0xbf};
-
-    template <typename octet_iterator>
-    octet_iterator find_invalid(octet_iterator start, octet_iterator end)
-    {
-        octet_iterator result = start;
-        while (result != end) {
-            utf8::internal::utf_error err_code = utf8::internal::validate_next(result, end);
-            if (err_code != internal::UTF8_OK)
-                return result;
-        }
-        return result;
-    }
-
-    template <typename octet_iterator>
-    inline bool is_valid(octet_iterator start, octet_iterator end)
-    {
-        return (utf8::find_invalid(start, end) == end);
-    }
-
-    template <typename octet_iterator>
-    inline bool starts_with_bom (octet_iterator it, octet_iterator end)
-    {
-        return (
-            ((it != end) && (utf8::internal::mask8(*it++)) == bom[0]) &&
-            ((it != end) && (utf8::internal::mask8(*it++)) == bom[1]) &&
-            ((it != end) && (utf8::internal::mask8(*it))   == bom[2])
-           );
-    }
-	
-    //Deprecated in release 2.3 
-    template <typename octet_iterator>
-    inline bool is_bom (octet_iterator it)
-    {
-        return (
-            (utf8::internal::mask8(*it++)) == bom[0] &&
-            (utf8::internal::mask8(*it++)) == bom[1] &&
-            (utf8::internal::mask8(*it))   == bom[2]
-           );
-    }
-} // namespace utf8
-
-#endif // header guard
-
-
diff --git a/third_party/libosmium/include/utf8/unchecked.h b/third_party/libosmium/include/utf8/unchecked.h
deleted file mode 100644
index cb2427166..000000000
--- a/third_party/libosmium/include/utf8/unchecked.h
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright 2006 Nemanja Trifunovic
-
-/*
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-*/
-
-
-#ifndef UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-#define UTF8_FOR_CPP_UNCHECKED_H_2675DCD0_9480_4c0c_B92A_CC14C027B731
-
-#include "core.h"
-
-namespace utf8
-{
-    namespace unchecked 
-    {
-        template <typename octet_iterator>
-        octet_iterator append(uint32_t cp, octet_iterator result)
-        {
-            if (cp < 0x80)                        // one octet
-                *(result++) = static_cast<uint8_t>(cp);  
-            else if (cp < 0x800) {                // two octets
-                *(result++) = static_cast<uint8_t>((cp >> 6)          | 0xc0);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            else if (cp < 0x10000) {              // three octets
-                *(result++) = static_cast<uint8_t>((cp >> 12)         | 0xe0);
-                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            else {                                // four octets
-                *(result++) = static_cast<uint8_t>((cp >> 18)         | 0xf0);
-                *(result++) = static_cast<uint8_t>(((cp >> 12) & 0x3f)| 0x80);
-                *(result++) = static_cast<uint8_t>(((cp >> 6) & 0x3f) | 0x80);
-                *(result++) = static_cast<uint8_t>((cp & 0x3f)        | 0x80);
-            }
-            return result;
-        }
-
-        template <typename octet_iterator>
-        uint32_t next(octet_iterator& it)
-        {
-            uint32_t cp = utf8::internal::mask8(*it);
-            typename std::iterator_traits<octet_iterator>::difference_type length = utf8::internal::sequence_length(it);
-            switch (length) {
-                case 1:
-                    break;
-                case 2:
-                    it++;
-                    cp = ((cp << 6) & 0x7ff) + ((*it) & 0x3f);
-                    break;
-                case 3:
-                    ++it; 
-                    cp = ((cp << 12) & 0xffff) + ((utf8::internal::mask8(*it) << 6) & 0xfff);
-                    ++it;
-                    cp += (*it) & 0x3f;
-                    break;
-                case 4:
-                    ++it;
-                    cp = ((cp << 18) & 0x1fffff) + ((utf8::internal::mask8(*it) << 12) & 0x3ffff);                
-                    ++it;
-                    cp += (utf8::internal::mask8(*it) << 6) & 0xfff;
-                    ++it;
-                    cp += (*it) & 0x3f; 
-                    break;
-            }
-            ++it;
-            return cp;        
-        }
-
-        template <typename octet_iterator>
-        uint32_t peek_next(octet_iterator it)
-        {
-            return utf8::unchecked::next(it);    
-        }
-
-        template <typename octet_iterator>
-        uint32_t prior(octet_iterator& it)
-        {
-            while (utf8::internal::is_trail(*(--it))) ;
-            octet_iterator temp = it;
-            return utf8::unchecked::next(temp);
-        }
-
-        // Deprecated in versions that include prior, but only for the sake of consistency (see utf8::previous)
-        template <typename octet_iterator>
-        inline uint32_t previous(octet_iterator& it)
-        {
-            return utf8::unchecked::prior(it);
-        }
-
-        template <typename octet_iterator, typename distance_type>
-        void advance (octet_iterator& it, distance_type n)
-        {
-            for (distance_type i = 0; i < n; ++i)
-                utf8::unchecked::next(it);
-        }
-
-        template <typename octet_iterator>
-        typename std::iterator_traits<octet_iterator>::difference_type
-        distance (octet_iterator first, octet_iterator last)
-        {
-            typename std::iterator_traits<octet_iterator>::difference_type dist;
-            for (dist = 0; first < last; ++dist) 
-                utf8::unchecked::next(first);
-            return dist;
-        }
-
-        template <typename u16bit_iterator, typename octet_iterator>
-        octet_iterator utf16to8 (u16bit_iterator start, u16bit_iterator end, octet_iterator result)
-        {       
-            while (start != end) {
-                uint32_t cp = utf8::internal::mask16(*start++);
-            // Take care of surrogate pairs first
-                if (utf8::internal::is_lead_surrogate(cp)) {
-                    uint32_t trail_surrogate = utf8::internal::mask16(*start++);
-                    cp = (cp << 10) + trail_surrogate + internal::SURROGATE_OFFSET;
-                }
-                result = utf8::unchecked::append(cp, result);
-            }
-            return result;         
-        }
-
-        template <typename u16bit_iterator, typename octet_iterator>
-        u16bit_iterator utf8to16 (octet_iterator start, octet_iterator end, u16bit_iterator result)
-        {
-            while (start < end) {
-                uint32_t cp = utf8::unchecked::next(start);
-                if (cp > 0xffff) { //make a surrogate pair
-                    *result++ = static_cast<uint16_t>((cp >> 10)   + internal::LEAD_OFFSET);
-                    *result++ = static_cast<uint16_t>((cp & 0x3ff) + internal::TRAIL_SURROGATE_MIN);
-                }
-                else
-                    *result++ = static_cast<uint16_t>(cp);
-            }
-            return result;
-        }
-
-        template <typename octet_iterator, typename u32bit_iterator>
-        octet_iterator utf32to8 (u32bit_iterator start, u32bit_iterator end, octet_iterator result)
-        {
-            while (start != end)
-                result = utf8::unchecked::append(*(start++), result);
-
-            return result;
-        }
-
-        template <typename octet_iterator, typename u32bit_iterator>
-        u32bit_iterator utf8to32 (octet_iterator start, octet_iterator end, u32bit_iterator result)
-        {
-            while (start < end)
-                (*result++) = utf8::unchecked::next(start);
-
-            return result;
-        }
-
-        // The iterator class
-        template <typename octet_iterator>
-          class iterator : public std::iterator <std::bidirectional_iterator_tag, uint32_t> { 
-            octet_iterator it;
-            public:
-            iterator () {}
-            explicit iterator (const octet_iterator& octet_it): it(octet_it) {}
-            // the default "big three" are OK
-            octet_iterator base () const { return it; }
-            uint32_t operator * () const
-            {
-                octet_iterator temp = it;
-                return utf8::unchecked::next(temp);
-            }
-            bool operator == (const iterator& rhs) const 
-            { 
-                return (it == rhs.it);
-            }
-            bool operator != (const iterator& rhs) const
-            {
-                return !(operator == (rhs));
-            }
-            iterator& operator ++ () 
-            {
-                ::std::advance(it, utf8::internal::sequence_length(it));
-                return *this;
-            }
-            iterator operator ++ (int)
-            {
-                iterator temp = *this;
-                ::std::advance(it, utf8::internal::sequence_length(it));
-                return temp;
-            }  
-            iterator& operator -- ()
-            {
-                utf8::unchecked::prior(it);
-                return *this;
-            }
-            iterator operator -- (int)
-            {
-                iterator temp = *this;
-                utf8::unchecked::prior(it);
-                return temp;
-            }
-          }; // class iterator
-
-    } // namespace utf8::unchecked
-} // namespace utf8 
-
-
-#endif // header guard
-
diff --git a/third_party/libosmium/test/CMakeLists.txt b/third_party/libosmium/test/CMakeLists.txt
index bd75a8bfe..f5c696d2e 100644
--- a/third_party/libosmium/test/CMakeLists.txt
+++ b/third_party/libosmium/test/CMakeLists.txt
@@ -87,7 +87,7 @@ function(add_unit_test _tgroup _tname)
             ENVIRONMENT "OSMIUM_TEST_DATA_DIR=${CMAKE_CURRENT_SOURCE_DIR}"
         )
     else()
-        message("Skipped test ${_tpath} because a dependency was not found")
+        message("Skipped test ${_tpath} because a dependency was disabled/not found")
         set(OSMIUM_SKIPPED_TESTS
             "${OSMIUM_SKIPPED_TESTS} ${_tpath}"
             CACHE STRING "Tests that were skipped because of missing dependecies")
@@ -131,20 +131,20 @@ add_unit_test(area test_area_id)
 add_unit_test(area test_assembler)
 add_unit_test(area test_node_ref_segment)
 
-add_unit_test(osm test_area)
-add_unit_test(osm test_box)
-add_unit_test(osm test_changeset)
-add_unit_test(osm test_crc)
+add_unit_test(osm test_area ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
+add_unit_test(osm test_box ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
+add_unit_test(osm test_changeset ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
+add_unit_test(osm test_crc ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
 add_unit_test(osm test_entity_bits)
 add_unit_test(osm test_location)
 add_unit_test(osm test_metadata)
-add_unit_test(osm test_node)
+add_unit_test(osm test_node ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
 add_unit_test(osm test_node_ref)
 add_unit_test(osm test_object_comparisons)
-add_unit_test(osm test_relation)
+add_unit_test(osm test_relation ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
 add_unit_test(osm test_timestamp)
 add_unit_test(osm test_types_from_string)
-add_unit_test(osm test_way)
+add_unit_test(osm test_way ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
 
 add_unit_test(memory test_buffer_basics)
 add_unit_test(memory test_buffer_node)
@@ -170,27 +170,34 @@ add_unit_test(geom test_tile)
 add_unit_test(geom test_wkb)
 add_unit_test(geom test_wkt)
 
+add_unit_test(handler test_apply LIBS "${OSMIUM_XML_LIBRARIES}")
 add_unit_test(handler test_check_order_handler)
 add_unit_test(handler test_dynamic_handler)
 
+add_unit_test(index test_dump_and_load_index)
+add_unit_test(index test_dump_sparse_as_array)
+add_unit_test(index test_file_based_index)
 add_unit_test(index test_id_set)
 add_unit_test(index test_id_to_location ENABLE_IF ${SPARSEHASH_FOUND})
-add_unit_test(index test_file_based_index)
+add_unit_test(index test_nwr_array)
 add_unit_test(index test_object_pointer_collection)
 add_unit_test(index test_relations_map)
 
 add_unit_test(io test_compression_factory)
-add_unit_test(io test_bzip2 ENABLE_IF ${BZIP2_FOUND} LIBS ${BZIP2_LIBRARIES})
 add_unit_test(io test_file_formats)
+add_unit_test(io test_nocompression)
+add_unit_test(io test_output_utils)
+add_unit_test(io test_string_table)
+
+add_unit_test(io test_bzip2 ENABLE_IF ${BZIP2_FOUND} LIBS ${BZIP2_LIBRARIES})
+add_unit_test(io test_gzip ENABLE_IF ${ZLIB_FOUND} LIBS ${ZLIB_LIBRARIES})
+add_unit_test(io test_opl_parser ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
+add_unit_test(io test_output_iterator ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 add_unit_test(io test_pbf ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_PBF_LIBRARIES})
 add_unit_test(io test_reader LIBS "${OSMIUM_XML_LIBRARIES};${OSMIUM_PBF_LIBRARIES}")
 add_unit_test(io test_reader_fileformat ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 add_unit_test(io test_reader_with_mock_decompression ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_XML_LIBRARIES})
 add_unit_test(io test_reader_with_mock_parser ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
-add_unit_test(io test_opl_parser ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
-add_unit_test(io test_output_utils)
-add_unit_test(io test_output_iterator ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
-add_unit_test(io test_string_table)
 add_unit_test(io test_writer ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_XML_LIBRARIES})
 add_unit_test(io test_writer_with_mock_compression ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_XML_LIBRARIES})
 add_unit_test(io test_writer_with_mock_encoder ENABLE_IF ${Threads_FOUND} LIBS ${OSMIUM_XML_LIBRARIES})
@@ -212,7 +219,6 @@ add_unit_test(thread test_pool ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LI
 add_unit_test(thread test_queue ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 add_unit_test(thread test_util ENABLE_IF ${Threads_FOUND} LIBS ${CMAKE_THREAD_LIBS_INIT})
 
-add_unit_test(util test_cast_with_assert)
 add_unit_test(util test_config)
 add_unit_test(util test_delta)
 add_unit_test(util test_double)
diff --git a/third_party/libosmium/test/catch/catch.hpp b/third_party/libosmium/test/catch/catch.hpp
index f619f237e..db1fed3b9 100644
--- a/third_party/libosmium/test/catch/catch.hpp
+++ b/third_party/libosmium/test/catch/catch.hpp
@@ -1,17 +1,21 @@
 /*
- *  Catch v1.12.1
- *  Generated: 2018-03-02 21:17:41.036711
+ *  Catch v2.13.8
+ *  Generated: 2022-01-03 21:20:09.589503
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2012 Two Blue Cubes Ltd. All rights reserved.
+ *  Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved.
  *
  *  Distributed under the Boost Software License, Version 1.0. (See accompanying
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  */
 #ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
 #define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+// start catch.hpp
 
-#define TWOBLUECUBES_CATCH_HPP_INCLUDED
+
+#define CATCH_VERSION_MAJOR 2
+#define CATCH_VERSION_MINOR 13
+#define CATCH_VERSION_PATCH 8
 
 #ifdef __clang__
 #    pragma clang system_header
@@ -19,36 +23,69 @@
 #    pragma GCC system_header
 #endif
 
-// #included from: internal/catch_suppress_warnings.h
+// start catch_suppress_warnings.h
 
 #ifdef __clang__
 #   ifdef __ICC // icpc defines the __clang__ macro
 #       pragma warning(push)
 #       pragma warning(disable: 161 1682)
 #   else // __ICC
-#       pragma clang diagnostic ignored "-Wglobal-constructors"
-#       pragma clang diagnostic ignored "-Wvariadic-macros"
-#       pragma clang diagnostic ignored "-Wc99-extensions"
-#       pragma clang diagnostic ignored "-Wunused-variable"
 #       pragma clang diagnostic push
 #       pragma clang diagnostic ignored "-Wpadded"
-#       pragma clang diagnostic ignored "-Wc++98-compat"
-#       pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
 #       pragma clang diagnostic ignored "-Wswitch-enum"
 #       pragma clang diagnostic ignored "-Wcovered-switch-default"
 #    endif
 #elif defined __GNUC__
-#    pragma GCC diagnostic ignored "-Wvariadic-macros"
-#    pragma GCC diagnostic ignored "-Wunused-variable"
-#    pragma GCC diagnostic ignored "-Wparentheses"
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
 
 #    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wunused-variable"
 #    pragma GCC diagnostic ignored "-Wpadded"
 #endif
+// end catch_suppress_warnings.h
 #if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)
 #  define CATCH_IMPL
+#  define CATCH_CONFIG_ALL_PARTS
 #endif
 
+// In the impl file, we want to have access to all parts of the headers
+// Can also be used to sanely support PCHs
+#if defined(CATCH_CONFIG_ALL_PARTS)
+#  define CATCH_CONFIG_EXTERNAL_INTERFACES
+#  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#    undef CATCH_CONFIG_DISABLE_MATCHERS
+#  endif
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
+#endif
+
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+// start catch_platform.h
+
+// See e.g.:
+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
+#ifdef __APPLE__
+#  include <TargetConditionals.h>
+#  if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
+      (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
+#    define CATCH_PLATFORM_MAC
+#  elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
+#    define CATCH_PLATFORM_IPHONE
+#  endif
+
+#elif defined(linux) || defined(__linux) || defined(__linux__)
+#  define CATCH_PLATFORM_LINUX
+
+#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+#  define CATCH_PLATFORM_WINDOWS
+#endif
+
+// end catch_platform.h
+
 #ifdef CATCH_IMPL
 #  ifndef CLARA_CONFIG_MAIN
 #    define CLARA_CONFIG_MAIN_NOT_DEFINED
@@ -56,93 +93,106 @@
 #  endif
 #endif
 
-// #included from: internal/catch_notimplemented_exception.h
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_H_INCLUDED
+// start catch_user_interfaces.h
 
-// #included from: catch_common.h
-#define TWOBLUECUBES_CATCH_COMMON_H_INCLUDED
+namespace Catch {
+    unsigned int rngSeed();
+}
 
-// #included from: catch_compiler_capabilities.h
-#define TWOBLUECUBES_CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+// end catch_user_interfaces.h
+// start catch_tag_alias_autoregistrar.h
 
-// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
+// start catch_common.h
+
+// start catch_compiler_capabilities.h
+
+// Detect a number of compiler features - by compiler
 // The following features are defined:
 //
-// CATCH_CONFIG_CPP11_NULLPTR : is nullptr supported?
-// CATCH_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
-// CATCH_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
-// CATCH_CONFIG_CPP11_IS_ENUM : std::is_enum is supported?
-// CATCH_CONFIG_CPP11_TUPLE : std::tuple is supported
-// CATCH_CONFIG_CPP11_LONG_LONG : is long long supported?
-// CATCH_CONFIG_CPP11_OVERRIDE : is override supported?
-// CATCH_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
-// CATCH_CONFIG_CPP11_SHUFFLE : is std::shuffle supported?
-// CATCH_CONFIG_CPP11_TYPE_TRAITS : are type_traits and enable_if supported?
-
-// CATCH_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
-
-// CATCH_CONFIG_VARIADIC_MACROS : are variadic macros supported?
 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
 // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
 // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
 // ****************
 // Note to maintainers: if new toggles are added please document them
 // in configuration.md, too
 // ****************
 
 // In general each macro has a _NO_<feature name> form
-// (e.g. CATCH_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
+// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
 // Many features, at point of detection, define an _INTERNAL_ macro, so they
 // can be combined, en-mass, with the _NO_ forms later.
 
-// All the C++11 features can be disabled with CATCH_CONFIG_NO_CPP11
-
 #ifdef __cplusplus
 
-#  if __cplusplus >= 201103L
-#    define CATCH_CPP11_OR_GREATER
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
+#    define CATCH_CPP14_OR_GREATER
 #  endif
 
-#  if __cplusplus >= 201402L
-#    define CATCH_CPP14_OR_GREATER
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+#    define CATCH_CPP17_OR_GREATER
 #  endif
 
 #endif
 
-#ifdef __clang__
+// Only GCC compiler should be used in this block, so other compilers trying to
+// mask themselves as GCC should be ignored.
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
 
-#  if __has_feature(cxx_nullptr)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
+#endif
+
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+// which results in calls to destructors being emitted for each temporary,
+// without a matching initialization. In practice, this can result in something
+// like `std::string::~string` being called on an uninitialized value.
+//
+// For example, this code will likely segfault under IBM XL:
+// ```
+// REQUIRE(std::string("12") + "34" == "1234")
+// ```
+//
+// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+#  if !defined(__ibmxl__) && !defined(__CUDACC__)
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
 #  endif
 
-#  if __has_feature(cxx_noexcept)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#  endif
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
 
-#   if defined(CATCH_CPP11_OR_GREATER)
-#       define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
 
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
-#   endif
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 
 #endif // __clang__
 
+////////////////////////////////////////////////////////////////////////////////
+// Assume that non-Windows platforms support posix signals by default
+#if !defined(CATCH_PLATFORM_WINDOWS)
+    #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // We know some environments not to support full POSIX signals
-#if defined(__CYGWIN__) || defined(__QNX__)
-
-#   if !defined(CATCH_CONFIG_POSIX_SIGNALS)
-#       define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
-#   endif
-
+#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)
+    #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
 #endif
 
 #ifdef __OS400__
@@ -150,6 +200,25 @@
 #       define CATCH_CONFIG_COLOUR_NONE
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// Android somehow still does not support std::to_string
+#if defined(__ANDROID__)
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Not all Windows environments support SEH properly
+#if defined(__MINGW32__)
+#    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // Cygwin
 #ifdef __CYGWIN__
@@ -157,219 +226,245 @@
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
 
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+
+# endif
 #endif // __CYGWIN__
 
-////////////////////////////////////////////////////////////////////////////////
-// Borland
-#ifdef __BORLANDC__
-
-#endif // __BORLANDC__
-
-////////////////////////////////////////////////////////////////////////////////
-// EDG
-#ifdef __EDG_VERSION__
-
-#endif // __EDG_VERSION__
-
-////////////////////////////////////////////////////////////////////////////////
-// Digital Mars
-#ifdef __DMC__
-
-#endif // __DMC__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-#   if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
-#       define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#   endif
-
-// - otherwise more recent versions define __cplusplus >= 201103L
-// and will get picked up below
-
-#endif // __GNUC__
-
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
-#ifdef _MSC_VER
+#if defined(_MSC_VER)
 
-#define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+// Universal Windows platform does not support SEH
+// Or console colours (or console at all...)
+#  if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)
+#    define CATCH_CONFIG_COLOUR_NONE
+#  else
+#    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+#  endif
 
-#if (_MSC_VER >= 1600)
-#   define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#   define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
 
-#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
-#define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
-#define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
-#endif
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+
+// Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop`
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
+#  endif // __clang__
 
 #endif // _MSC_VER
 
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+#endif // _MSC_VER
+
 ////////////////////////////////////////////////////////////////////////////////
-
-// Use variadic macros if the compiler supports them
-#if ( defined _MSC_VER && _MSC_VER > 1400 && !defined __EDGE__) || \
-    ( defined __WAVE__ && __WAVE_HAS_VARIADICS ) || \
-    ( defined __GNUC__ && __GNUC__ >= 3 ) || \
-    ( !defined __cplusplus && __STDC_VERSION__ >= 199901L || __cplusplus >= 201103L )
-
-#define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
 #endif
 
-// Use __COUNTER__ if the compiler supports it
-#if ( defined _MSC_VER && _MSC_VER >= 1300 ) || \
-    ( defined __GNUC__  && ( __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 )) ) || \
-    ( defined __clang__ && __clang_major__ >= 3 )
+////////////////////////////////////////////////////////////////////////////////
+// DJGPP
+#ifdef __DJGPP__
+#  define CATCH_INTERNAL_CONFIG_NO_WCHAR
+#endif // __DJGPP__
 
-// Use of __COUNTER__ is suppressed during code analysis in CLion/AppCode 2017.2.x and former,
-// because __COUNTER__ is not properly handled by it.
-// This does not affect compilation
-#if ( !defined __JETBRAINS_IDE__ || __JETBRAINS_IDE__ >= 20170300L )
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Use of __COUNTER__ is suppressed during code analysis in
+// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly
+// handled by it.
+// Otherwise all supported compilers support COUNTER macro,
+// but user still might want to turn it off
+#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
     #define CATCH_INTERNAL_CONFIG_COUNTER
 #endif
 
-#endif
-
 ////////////////////////////////////////////////////////////////////////////////
-// C++ language feature support
 
-// catch all support for C++11
-#if defined(CATCH_CPP11_OR_GREATER)
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR)
-#    define CATCH_INTERNAL_CONFIG_CPP11_NULLPTR
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#    define CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#    define CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
-#    define CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_CPP11_TUPLE
-#    define CATCH_INTERNAL_CONFIG_CPP11_TUPLE
-#  endif
-
-#  ifndef CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-#    define CATCH_INTERNAL_CONFIG_VARIADIC_MACROS
-#  endif
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG)
-#    define CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG
-#  endif
-
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE)
-#    define CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE
-#  endif
-#  if !defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
-#    define CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#  endif
-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE)
-#   define CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE
-#  endif
-# if !defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS)
-#  define CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS
-# endif
-
-#endif // __cplusplus >= 201103L
-
-// Now set the actual defines based on the above + anything the user has configured
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NO_NULLPTR) && !defined(CATCH_CONFIG_CPP11_NULLPTR) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_NULLPTR
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
 #endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_NOEXCEPT
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CATCH_CONFIG_CPP11_GENERATED_METHODS) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_GENERATED_METHODS
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_NO_IS_ENUM) && !defined(CATCH_CONFIG_CPP11_IS_ENUM) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_IS_ENUM
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_CPP11_NO_TUPLE) && !defined(CATCH_CONFIG_CPP11_TUPLE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_TUPLE
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_VARIADIC_MACROS) && !defined(CATCH_CONFIG_NO_VARIADIC_MACROS) && !defined(CATCH_CONFIG_VARIADIC_MACROS)
-#   define CATCH_CONFIG_VARIADIC_MACROS
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_NO_LONG_LONG) && !defined(CATCH_CONFIG_CPP11_LONG_LONG) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_LONG_LONG
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_NO_OVERRIDE) && !defined(CATCH_CONFIG_CPP11_OVERRIDE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_OVERRIDE
-#endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_NO_UNIQUE_PTR) && !defined(CATCH_CONFIG_CPP11_UNIQUE_PTR) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_UNIQUE_PTR
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
 #endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    include <cstddef>
+  #    if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
+  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #    endif
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
-#if defined(CATCH_INTERNAL_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_NO_SHUFFLE) && !defined(CATCH_CONFIG_CPP11_SHUFFLE) && !defined(CATCH_CONFIG_NO_CPP11)
-#   define CATCH_CONFIG_CPP11_SHUFFLE
-#endif
-# if defined(CATCH_INTERNAL_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_NO_TYPE_TRAITS) && !defined(CATCH_CONFIG_CPP11_TYPE_TRAITS) && !defined(CATCH_CONFIG_NO_CPP11)
-#  define CATCH_CONFIG_CPP11_TYPE_TRAITS
-# endif
-#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH)
+#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
 #   define CATCH_CONFIG_WINDOWS_SEH
 #endif
 // This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
-#if !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
 #   define CATCH_CONFIG_POSIX_SIGNALS
 #endif
+// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.
+#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)
+#   define CATCH_CONFIG_WCHAR
+#endif
 
+#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+#    define CATCH_CONFIG_CPP11_TO_STRING
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
-#if !defined(CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS)
-#   define CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
 #endif
 
-// noexcept support:
-#if defined(CATCH_CONFIG_CPP11_NOEXCEPT) && !defined(CATCH_NOEXCEPT)
-#  define CATCH_NOEXCEPT noexcept
-#  define CATCH_NOEXCEPT_IS(x) noexcept(x)
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
 #else
-#  define CATCH_NOEXCEPT throw()
-#  define CATCH_NOEXCEPT_IS(x)
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
 #endif
 
-// nullptr support
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-#   define CATCH_NULL nullptr
-#else
-#   define CATCH_NULL NULL
-#endif
-
-// override support
-#ifdef CATCH_CONFIG_CPP11_OVERRIDE
-#   define CATCH_OVERRIDE override
-#else
-#   define CATCH_OVERRIDE
-#endif
-
-// unique_ptr support
-#ifdef CATCH_CONFIG_CPP11_UNIQUE_PTR
-#   define CATCH_AUTO_PTR( T ) std::unique_ptr<T>
-#else
-#   define CATCH_AUTO_PTR( T ) std::auto_ptr<T>
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #endif
 
+// end catch_compiler_capabilities.h
 #define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
 #define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
 #ifdef CATCH_CONFIG_COUNTER
@@ -378,95 +473,48 @@
 #  define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
 #endif
 
-#define INTERNAL_CATCH_STRINGIFY2( expr ) #expr
-#define INTERNAL_CATCH_STRINGIFY( expr ) INTERNAL_CATCH_STRINGIFY2( expr )
+#include <iosfwd>
+#include <string>
+#include <cstdint>
 
-#include <sstream>
-#include <algorithm>
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
 
 namespace Catch {
 
-    struct IConfig;
-
     struct CaseSensitive { enum Choice {
         Yes,
         No
     }; };
 
     class NonCopyable {
-#ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
         NonCopyable( NonCopyable const& )              = delete;
         NonCopyable( NonCopyable && )                  = delete;
         NonCopyable& operator = ( NonCopyable const& ) = delete;
         NonCopyable& operator = ( NonCopyable && )     = delete;
-#else
-        NonCopyable( NonCopyable const& info );
-        NonCopyable& operator = ( NonCopyable const& );
-#endif
 
     protected:
-        NonCopyable() {}
+        NonCopyable();
         virtual ~NonCopyable();
     };
 
-    class SafeBool {
-    public:
-        typedef void (SafeBool::*type)() const;
-
-        static type makeSafe( bool value ) {
-            return value ? &SafeBool::trueValue : 0;
-        }
-    private:
-        void trueValue() const {}
-    };
-
-    template<typename ContainerT>
-    void deleteAll( ContainerT& container ) {
-        typename ContainerT::const_iterator it = container.begin();
-        typename ContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete *it;
-    }
-    template<typename AssociativeContainerT>
-    void deleteAllValues( AssociativeContainerT& container ) {
-        typename AssociativeContainerT::const_iterator it = container.begin();
-        typename AssociativeContainerT::const_iterator itEnd = container.end();
-        for(; it != itEnd; ++it )
-            delete it->second;
-    }
-
-    bool startsWith( std::string const& s, std::string const& prefix );
-    bool startsWith( std::string const& s, char prefix );
-    bool endsWith( std::string const& s, std::string const& suffix );
-    bool endsWith( std::string const& s, char suffix );
-    bool contains( std::string const& s, std::string const& infix );
-    void toLowerInPlace( std::string& s );
-    std::string toLower( std::string const& s );
-    std::string trim( std::string const& str );
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
-
-    struct pluralise {
-        pluralise( std::size_t count, std::string const& label );
-
-        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
-
-        std::size_t m_count;
-        std::string m_label;
-    };
-
     struct SourceLineInfo {
 
-        SourceLineInfo();
-        SourceLineInfo( char const* _file, std::size_t _line );
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        SourceLineInfo(SourceLineInfo const& other)          = default;
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
-#  endif
-        bool empty() const;
-        bool operator == ( SourceLineInfo const& other ) const;
-        bool operator < ( SourceLineInfo const& other ) const;
+        SourceLineInfo() = delete;
+        SourceLineInfo( char const* _file, std::size_t _line ) noexcept
+        :   file( _file ),
+            line( _line )
+        {}
+
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
+
+        bool empty() const noexcept { return file[0] == '\0'; }
+        bool operator == ( SourceLineInfo const& other ) const noexcept;
+        bool operator < ( SourceLineInfo const& other ) const noexcept;
 
         char const* file;
         std::size_t line;
@@ -474,24 +522,17 @@ namespace Catch {
 
     std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
 
-    // This is just here to avoid compiler warnings with macro constants and boolean literals
-    inline bool isTrue( bool value ){ return value; }
-    inline bool alwaysTrue() { return true; }
-    inline bool alwaysFalse() { return false; }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo );
-
-    void seedRng( IConfig const& config );
-    unsigned int rngSeed();
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
 
     // Use this in variadic streaming macros to allow
     //    >> +StreamEndStop
     // as well as
     //    >> stuff +StreamEndStop
     struct StreamEndStop {
-        std::string operator+() {
-            return std::string();
-        }
+        std::string operator+() const;
     };
     template<typename T>
     T const& operator + ( T const& value, StreamEndStop ) {
@@ -499,180 +540,28 @@ namespace Catch {
     }
 }
 
-#define CATCH_INTERNAL_LINEINFO ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-#define CATCH_INTERNAL_ERROR( msg ) ::Catch::throwLogicError( msg, CATCH_INTERNAL_LINEINFO );
+#define CATCH_INTERNAL_LINEINFO \
+    ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
 
+// end catch_common.h
 namespace Catch {
 
-    class NotImplementedException : public std::exception
-    {
-    public:
-        NotImplementedException( SourceLineInfo const& lineInfo );
-
-        virtual ~NotImplementedException() CATCH_NOEXCEPT {}
-
-        virtual const char* what() const CATCH_NOEXCEPT;
-
-    private:
-        std::string m_what;
-        SourceLineInfo m_lineInfo;
+    struct RegistrarForTagAliases {
+        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
     };
 
 } // end namespace Catch
 
-///////////////////////////////////////////////////////////////////////////////
-#define CATCH_NOT_IMPLEMENTED throw Catch::NotImplementedException( CATCH_INTERNAL_LINEINFO )
+#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-// #included from: internal/catch_context.h
-#define TWOBLUECUBES_CATCH_CONTEXT_H_INCLUDED
+// end catch_tag_alias_autoregistrar.h
+// start catch_test_registry.h
 
-// #included from: catch_interfaces_generators.h
-#define TWOBLUECUBES_CATCH_INTERFACES_GENERATORS_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    struct IGeneratorInfo {
-        virtual ~IGeneratorInfo();
-        virtual bool moveNext() = 0;
-        virtual std::size_t getCurrentIndex() const = 0;
-    };
-
-    struct IGeneratorsForTest {
-        virtual ~IGeneratorsForTest();
-
-        virtual IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) = 0;
-        virtual bool moveNext() = 0;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest();
-
-} // end namespace Catch
-
-// #included from: catch_ptr.hpp
-#define TWOBLUECUBES_CATCH_PTR_HPP_INCLUDED
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
-
-namespace Catch {
-
-    // An intrusive reference counting smart pointer.
-    // T must implement addRef() and release() methods
-    // typically implementing the IShared interface
-    template<typename T>
-    class Ptr {
-    public:
-        Ptr() : m_p( CATCH_NULL ){}
-        Ptr( T* p ) : m_p( p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        Ptr( Ptr const& other ) : m_p( other.m_p ){
-            if( m_p )
-                m_p->addRef();
-        }
-        ~Ptr(){
-            if( m_p )
-                m_p->release();
-        }
-        void reset() {
-            if( m_p )
-                m_p->release();
-            m_p = CATCH_NULL;
-        }
-        Ptr& operator = ( T* p ){
-            Ptr temp( p );
-            swap( temp );
-            return *this;
-        }
-        Ptr& operator = ( Ptr const& other ){
-            Ptr temp( other );
-            swap( temp );
-            return *this;
-        }
-        void swap( Ptr& other ) { std::swap( m_p, other.m_p ); }
-        T* get() const{ return m_p; }
-        T& operator*() const { return *m_p; }
-        T* operator->() const { return m_p; }
-        bool operator !() const { return m_p == CATCH_NULL; }
-        operator SafeBool::type() const { return SafeBool::makeSafe( m_p != CATCH_NULL ); }
-
-    private:
-        T* m_p;
-    };
-
-    struct IShared : NonCopyable {
-        virtual ~IShared();
-        virtual void addRef() const = 0;
-        virtual void release() const = 0;
-    };
-
-    template<typename T = IShared>
-    struct SharedImpl : T {
-
-        SharedImpl() : m_rc( 0 ){}
-
-        virtual void addRef() const {
-            ++m_rc;
-        }
-        virtual void release() const {
-            if( --m_rc == 0 )
-                delete this;
-        }
-
-        mutable unsigned int m_rc;
-    };
-
-} // end namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-
-namespace Catch {
-
-    class TestCase;
-    class Stream;
-    struct IResultCapture;
-    struct IRunner;
-    struct IGeneratorsForTest;
-    struct IConfig;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) = 0;
-        virtual bool advanceGeneratorsForCurrentTest() = 0;
-        virtual Ptr<IConfig const> getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( Ptr<IConfig const> const& config ) = 0;
-    };
-
-    IContext& getCurrentContext();
-    IMutableContext& getCurrentMutableContext();
-    void cleanUpContext();
-    Stream createStream( std::string const& streamName );
-
-}
-
-// #included from: internal/catch_test_registry.hpp
-#define TWOBLUECUBES_CATCH_TEST_REGISTRY_HPP_INCLUDED
-
-// #included from: catch_interfaces_testcase.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TESTCASE_H_INCLUDED
+// start catch_interfaces_testcase.h
 
 #include <vector>
 
@@ -680,10 +569,9 @@ namespace Catch {
 
     class TestSpec;
 
-    struct ITestCase : IShared {
+    struct ITestInvoker {
         virtual void invoke () const = 0;
-    protected:
-        virtual ~ITestCase();
+        virtual ~ITestInvoker();
     };
 
     class TestCase;
@@ -695,167 +583,769 @@ namespace Catch {
         virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
     };
 
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
     bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
 
 }
 
+// end catch_interfaces_testcase.h
+// start catch_stringref.h
+
+#include <cstddef>
+#include <string>
+#include <iosfwd>
+#include <cassert>
+
+namespace Catch {
+
+    /// A non-owning string class (similar to the forthcoming std::string_view)
+    /// Note that, because a StringRef may be a substring of another string,
+    /// it may not be null terminated.
+    class StringRef {
+    public:
+        using size_type = std::size_t;
+        using const_iterator = const char*;
+
+    private:
+        static constexpr char const* const s_empty = "";
+
+        char const* m_start = s_empty;
+        size_type m_size = 0;
+
+    public: // construction
+        constexpr StringRef() noexcept = default;
+
+        StringRef( char const* rawChars ) noexcept;
+
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
+        :   m_start( rawChars ),
+            m_size( size )
+        {}
+
+        StringRef( std::string const& stdString ) noexcept
+        :   m_start( stdString.c_str() ),
+            m_size( stdString.size() )
+        {}
+
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
+        }
+
+    public: // operators
+        auto operator == ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
+
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
+
+    public: // named queries
+        constexpr auto empty() const noexcept -> bool {
+            return m_size == 0;
+        }
+        constexpr auto size() const noexcept -> size_type {
+            return m_size;
+        }
+
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
+        auto c_str() const -> char const*;
+
+    public: // substrings and searches
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
+
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
+
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
+
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
+
+    auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
+    auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
+
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+        return StringRef( rawChars, size );
+    }
+} // namespace Catch
+
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
+// end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here.
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+#else
+    // Keep ::type here because we still support C++11
+    template <typename Func, typename... U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U...)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
 namespace Catch {
 
 template<typename C>
-class MethodTestCase : public SharedImpl<ITestCase> {
-
+class TestInvokerAsMethod : public ITestInvoker {
+    void (C::*m_testAsMethod)();
 public:
-    MethodTestCase( void (C::*method)() ) : m_method( method ) {}
+    TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
 
-    virtual void invoke() const {
+    void invoke() const override {
         C obj;
-        (obj.*m_method)();
+        (obj.*m_testAsMethod)();
     }
-
-private:
-    virtual ~MethodTestCase() {}
-
-    void (C::*m_method)();
 };
 
-typedef void(*TestFunction)();
+auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker*;
 
-struct NameAndDesc {
-    NameAndDesc( const char* _name = "", const char* _description= "" )
-    : name( _name ), description( _description )
-    {}
+template<typename C>
+auto makeTestInvoker( void (C::*testAsMethod)() ) noexcept -> ITestInvoker* {
+    return new(std::nothrow) TestInvokerAsMethod<C>( testAsMethod );
+}
 
-    const char* name;
-    const char* description;
+struct NameAndTags {
+    NameAndTags( StringRef const& name_ = StringRef(), StringRef const& tags_ = StringRef() ) noexcept;
+    StringRef name;
+    StringRef tags;
 };
 
-void registerTestCase
-    (   ITestCase* testCase,
-        char const* className,
-        NameAndDesc const& nameAndDesc,
-        SourceLineInfo const& lineInfo );
-
-struct AutoReg {
-
-    AutoReg
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc );
-
-    template<typename C>
-    AutoReg
-        (   void (C::*method)(),
-            char const* className,
-            NameAndDesc const& nameAndDesc,
-            SourceLineInfo const& lineInfo ) {
-
-        registerTestCase
-            (   new MethodTestCase<C>( method ),
-                className,
-                nameAndDesc,
-                lineInfo );
-    }
-
+struct AutoReg : NonCopyable {
+    AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept;
     ~AutoReg();
-
-private:
-    AutoReg( AutoReg const& );
-    void operator= ( AutoReg const& );
 };
 
-void registerTestCaseFunction
-    (   TestFunction function,
-        SourceLineInfo const& lineInfo,
-        NameAndDesc const& nameAndDesc );
-
 } // end namespace Catch
 
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+        static void TestName()
+    #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+        namespace{                        \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+                void test();              \
+            };                            \
+        }                                 \
+        void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+#endif
+
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
         static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         static void TestName()
     #define INTERNAL_CATCH_TESTCASE( ... ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
+        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), __VA_ARGS__ )
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         namespace{ \
-            struct TestName : ClassName{ \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                 void test(); \
             }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestName::test, #ClassName, Catch::NameAndDesc( __VA_ARGS__ ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
+            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
         } \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         void TestName::test()
     #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
+        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), ClassName, __VA_ARGS__ )
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( __VA_ARGS__ ) ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ )
 #else
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TESTCASE2( TestName, Name, Desc ) \
-        static void TestName(); \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &TestName, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        static void TestName()
-    #define INTERNAL_CATCH_TESTCASE( Name, Desc ) \
-        INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), Name, Desc )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, Name, Desc ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( &QualifiedMethod, "&" #QualifiedMethod, Catch::NameAndDesc( Name, Desc ), CATCH_INTERNAL_LINEINFO ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestCaseName, ClassName, TestName, Desc )\
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        namespace{ \
-            struct TestCaseName : ClassName{ \
-                void test(); \
-            }; \
-            Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( &TestCaseName::test, #ClassName, Catch::NameAndDesc( TestName, Desc ), CATCH_INTERNAL_LINEINFO ); /* NOLINT */ \
-        } \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS \
-        void TestCaseName::test()
-    #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, TestName, Desc )\
-        INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, TestName, Desc )
-
-    ///////////////////////////////////////////////////////////////////////////////
-    #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, Name, Desc ) \
-        CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS \
-        Catch::AutoReg( Function, CATCH_INTERNAL_LINEINFO, Catch::NameAndDesc( Name, Desc ) ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
-
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
 #endif
 
-// #included from: internal/catch_capture.hpp
-#define TWOBLUECUBES_CATCH_CAPTURE_HPP_INCLUDED
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
 
-// #included from: catch_result_builder.h
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_H_INCLUDED
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
 
-// #included from: catch_result_type.h
-#define TWOBLUECUBES_CATCH_RESULT_TYPE_H_INCLUDED
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_C_L_A_S_S_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_ ), INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_M_P_L_A_T_E_T_E_S_T_F_U_N_C_ ), ClassName, Name, Tags, TmplList )
+
+// end catch_test_registry.h
+// start catch_capture.hpp
+
+// start catch_assertionhandler.h
+
+// start catch_assertioninfo.h
+
+// start catch_result_type.h
 
 namespace Catch {
 
@@ -880,12 +1370,8 @@ namespace Catch {
 
     }; };
 
-    inline bool isOk( ResultWas::OfType resultType ) {
-        return ( resultType & ResultWas::FailureBit ) == 0;
-    }
-    inline bool isJustInfo( int flags ) {
-        return flags == ResultWas::Info;
-    }
+    bool isOk( ResultWas::OfType resultType );
+    bool isJustInfo( int flags );
 
     // ResultDisposition::Flags enum
     struct ResultDisposition { enum Flags {
@@ -896,620 +1382,123 @@ namespace Catch {
         SuppressFail = 0x08         // Failures are reported but do not fail the test
     }; };
 
-    inline ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
-        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
-    }
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
 
-    inline bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
-    inline bool isFalseTest( int flags )                { return ( flags & ResultDisposition::FalseTest ) != 0; }
-    inline bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+    bool shouldContinueOnFailure( int flags );
+    inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+    bool shouldSuppressFailure( int flags );
 
 } // end namespace Catch
 
-// #included from: catch_assertionresult.h
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_H_INCLUDED
-
-#include <string>
-
+// end catch_result_type.h
 namespace Catch {
 
-    struct STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison;
-
-    struct DecomposedExpression
-    {
-        virtual ~DecomposedExpression() {}
-        virtual bool isBinaryExpression() const {
-            return false;
-        }
-        virtual void reconstructExpression( std::string& dest ) const = 0;
-
-        // Only simple binary comparisons can be decomposed.
-        // If more complex check is required then wrap sub-expressions in parentheses.
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator + ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator - ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator * ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator / ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator % ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator && ( T const& );
-        template<typename T> STATIC_ASSERT_Expression_Too_Complex_Please_Rewrite_As_Binary_Comparison& operator || ( T const& );
-
-    private:
-        DecomposedExpression& operator = (DecomposedExpression const&);
-    };
-
     struct AssertionInfo
     {
-        AssertionInfo();
-        AssertionInfo(  char const * _macroName,
-                        SourceLineInfo const& _lineInfo,
-                        char const * _capturedExpression,
-                        ResultDisposition::Flags _resultDisposition,
-                        char const * _secondArg = "");
-
-        char const * macroName;
+        StringRef macroName;
         SourceLineInfo lineInfo;
-        char const * capturedExpression;
+        StringRef capturedExpression;
         ResultDisposition::Flags resultDisposition;
-        char const * secondArg;
-    };
 
-    struct AssertionResultData
-    {
-        AssertionResultData() : decomposedExpression( CATCH_NULL )
-                              , resultType( ResultWas::Unknown )
-                              , negated( false )
-                              , parenthesized( false ) {}
-
-        void negate( bool parenthesize ) {
-            negated = !negated;
-            parenthesized = parenthesize;
-            if( resultType == ResultWas::Ok )
-                resultType = ResultWas::ExpressionFailed;
-            else if( resultType == ResultWas::ExpressionFailed )
-                resultType = ResultWas::Ok;
-        }
-
-        std::string const& reconstructExpression() const {
-            if( decomposedExpression != CATCH_NULL ) {
-                decomposedExpression->reconstructExpression( reconstructedExpression );
-                if( parenthesized ) {
-                    reconstructedExpression.insert( 0, 1, '(' );
-                    reconstructedExpression.append( 1, ')' );
-                }
-                if( negated ) {
-                    reconstructedExpression.insert( 0, 1, '!' );
-                }
-                decomposedExpression = CATCH_NULL;
-            }
-            return reconstructedExpression;
-        }
-
-        mutable DecomposedExpression const* decomposedExpression;
-        mutable std::string reconstructedExpression;
-        std::string message;
-        ResultWas::OfType resultType;
-        bool negated;
-        bool parenthesized;
-    };
-
-    class AssertionResult {
-    public:
-        AssertionResult();
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
-        ~AssertionResult();
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-         AssertionResult( AssertionResult const& )              = default;
-         AssertionResult( AssertionResult && )                  = default;
-         AssertionResult& operator = ( AssertionResult const& ) = default;
-         AssertionResult& operator = ( AssertionResult && )     = default;
-#  endif
-
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        std::string getTestMacroName() const;
-        void discardDecomposedExpression() const;
-        void expandDecomposedExpression() const;
-
-    protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
+        // We want to delete this constructor but a compiler bug in 4.8 means
+        // the struct is then treated as non-aggregate
+        //AssertionInfo() = delete;
     };
 
 } // end namespace Catch
 
-// #included from: catch_matchers.hpp
-#define TWOBLUECUBES_CATCH_MATCHERS_HPP_INCLUDED
+// end catch_assertioninfo.h
+// start catch_decomposer.h
 
-namespace Catch {
-namespace Matchers {
-    namespace Impl {
+// start catch_tostring.h
 
-        template<typename ArgT> struct MatchAllOf;
-        template<typename ArgT> struct MatchAnyOf;
-        template<typename ArgT> struct MatchNotOf;
-
-        class MatcherUntypedBase {
-        public:
-            std::string toString() const {
-                if( m_cachedToString.empty() )
-                    m_cachedToString = describe();
-                return m_cachedToString;
-            }
-
-        protected:
-            virtual ~MatcherUntypedBase();
-            virtual std::string describe() const = 0;
-            mutable std::string m_cachedToString;
-        private:
-            MatcherUntypedBase& operator = ( MatcherUntypedBase const& );
-        };
-
-        template<typename ObjectT>
-        struct MatcherMethod {
-            virtual bool match( ObjectT const& arg ) const = 0;
-        };
-        template<typename PtrT>
-        struct MatcherMethod<PtrT*> {
-            virtual bool match( PtrT* arg ) const = 0;
-        };
-
-        template<typename ObjectT, typename ComparatorT = ObjectT>
-        struct MatcherBase : MatcherUntypedBase, MatcherMethod<ObjectT> {
-
-            MatchAllOf<ComparatorT> operator && ( MatcherBase const& other ) const;
-            MatchAnyOf<ComparatorT> operator || ( MatcherBase const& other ) const;
-            MatchNotOf<ComparatorT> operator ! () const;
-        };
-
-        template<typename ArgT>
-        struct MatchAllOf : MatcherBase<ArgT> {
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if (!m_matchers[i]->match(arg))
-                        return false;
-                }
-                return true;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        description += " and ";
-                    description += m_matchers[i]->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-        template<typename ArgT>
-        struct MatchAnyOf : MatcherBase<ArgT> {
-
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if (m_matchers[i]->match(arg))
-                        return true;
-                }
-                return false;
-            }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                std::string description;
-                description.reserve( 4 + m_matchers.size()*32 );
-                description += "( ";
-                for( std::size_t i = 0; i < m_matchers.size(); ++i ) {
-                    if( i != 0 )
-                        description += " or ";
-                    description += m_matchers[i]->toString();
-                }
-                description += " )";
-                return description;
-            }
-
-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
-            }
-
-            std::vector<MatcherBase<ArgT> const*> m_matchers;
-        };
-
-        template<typename ArgT>
-        struct MatchNotOf : MatcherBase<ArgT> {
-
-            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
-
-            virtual bool match( ArgT const& arg ) const CATCH_OVERRIDE {
-                return !m_underlyingMatcher.match( arg );
-            }
-
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "not " + m_underlyingMatcher.toString();
-            }
-            MatcherBase<ArgT> const& m_underlyingMatcher;
-        };
-
-        template<typename ObjectT, typename ComparatorT>
-        MatchAllOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator && ( MatcherBase const& other ) const {
-            return MatchAllOf<ComparatorT>() && *this && other;
-        }
-        template<typename ObjectT, typename ComparatorT>
-        MatchAnyOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator || ( MatcherBase const& other ) const {
-            return MatchAnyOf<ComparatorT>() || *this || other;
-        }
-        template<typename ObjectT, typename ComparatorT>
-        MatchNotOf<ComparatorT> MatcherBase<ObjectT, ComparatorT>::operator ! () const {
-            return MatchNotOf<ComparatorT>( *this );
-        }
-
-    } // namespace Impl
-
-    // The following functions create the actual matcher objects.
-    // This allows the types to be inferred
-    // - deprecated: prefer ||, && and !
-    template<typename T>
-    Impl::MatchNotOf<T> Not( Impl::MatcherBase<T> const& underlyingMatcher ) {
-        return Impl::MatchNotOf<T>( underlyingMatcher );
-    }
-    template<typename T>
-    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
-        return Impl::MatchAllOf<T>() && m1 && m2;
-    }
-    template<typename T>
-    Impl::MatchAllOf<T> AllOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
-        return Impl::MatchAllOf<T>() && m1 && m2 && m3;
-    }
-    template<typename T>
-    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2 ) {
-        return Impl::MatchAnyOf<T>() || m1 || m2;
-    }
-    template<typename T>
-    Impl::MatchAnyOf<T> AnyOf( Impl::MatcherBase<T> const& m1, Impl::MatcherBase<T> const& m2, Impl::MatcherBase<T> const& m3 ) {
-        return Impl::MatchAnyOf<T>() || m1 || m2 || m3;
-    }
-
-} // namespace Matchers
-
-using namespace Matchers;
-using Matchers::Impl::MatcherBase;
-
-} // namespace Catch
-
-namespace Catch {
-
-    struct TestFailureException{};
-
-    template<typename T> class ExpressionLhs;
-
-    struct CopyableStream {
-        CopyableStream() {}
-        CopyableStream( CopyableStream const& other ) {
-            oss << other.oss.str();
-        }
-        CopyableStream& operator=( CopyableStream const& other ) {
-            oss.str(std::string());
-            oss << other.oss.str();
-            return *this;
-        }
-        std::ostringstream oss;
-    };
-
-    class ResultBuilder : public DecomposedExpression {
-    public:
-        ResultBuilder(  char const* macroName,
-                        SourceLineInfo const& lineInfo,
-                        char const* capturedExpression,
-                        ResultDisposition::Flags resultDisposition,
-                        char const* secondArg = "" );
-        ~ResultBuilder();
-
-        template<typename T>
-        ExpressionLhs<T const&> operator <= ( T const& operand );
-        ExpressionLhs<bool> operator <= ( bool value );
-
-        template<typename T>
-        ResultBuilder& operator << ( T const& value ) {
-            stream().oss << value;
-            return *this;
-        }
-
-        ResultBuilder& setResultType( ResultWas::OfType result );
-        ResultBuilder& setResultType( bool result );
-
-        void endExpression( DecomposedExpression const& expr );
-
-        virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE;
-
-        AssertionResult build() const;
-        AssertionResult build( DecomposedExpression const& expr ) const;
-
-        void useActiveException( ResultDisposition::Flags resultDisposition = ResultDisposition::Normal );
-        void captureResult( ResultWas::OfType resultType );
-        void captureExpression();
-        void captureExpectedException( std::string const& expectedMessage );
-        void captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher );
-        void handleResult( AssertionResult const& result );
-        void react();
-        bool shouldDebugBreak() const;
-        bool allowThrows() const;
-
-        template<typename ArgT, typename MatcherT>
-        void captureMatch( ArgT const& arg, MatcherT const& matcher, char const* matcherString );
-
-        void setExceptionGuard();
-        void unsetExceptionGuard();
-
-    private:
-        AssertionInfo m_assertionInfo;
-        AssertionResultData m_data;
-
-        CopyableStream &stream()
-        {
-            if(!m_usedStream)
-            {
-                m_usedStream = true;
-                m_stream().oss.str("");
-            }
-            return m_stream();
-        }
-
-        static CopyableStream &m_stream()
-        {
-            static CopyableStream s;
-            return s;
-        }
-
-        bool m_shouldDebugBreak;
-        bool m_shouldThrow;
-        bool m_guardException;
-        bool m_usedStream;
-    };
-
-} // namespace Catch
-
-// Include after due to circular dependency:
-// #included from: catch_expression_lhs.hpp
-#define TWOBLUECUBES_CATCH_EXPRESSION_LHS_HPP_INCLUDED
-
-// #included from: catch_evaluate.hpp
-#define TWOBLUECUBES_CATCH_EVALUATE_HPP_INCLUDED
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
-#pragma warning(disable:4018) // more "signed/unsigned mismatch"
-#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
-#endif
-
-#include <cstddef>
-
-namespace Catch {
-namespace Internal {
-
-    enum Operator {
-        IsEqualTo,
-        IsNotEqualTo,
-        IsLessThan,
-        IsGreaterThan,
-        IsLessThanOrEqualTo,
-        IsGreaterThanOrEqualTo
-    };
-
-    template<Operator Op> struct OperatorTraits             { static const char* getName(){ return "*error*"; } };
-    template<> struct OperatorTraits<IsEqualTo>             { static const char* getName(){ return "=="; } };
-    template<> struct OperatorTraits<IsNotEqualTo>          { static const char* getName(){ return "!="; } };
-    template<> struct OperatorTraits<IsLessThan>            { static const char* getName(){ return "<"; } };
-    template<> struct OperatorTraits<IsGreaterThan>         { static const char* getName(){ return ">"; } };
-    template<> struct OperatorTraits<IsLessThanOrEqualTo>   { static const char* getName(){ return "<="; } };
-    template<> struct OperatorTraits<IsGreaterThanOrEqualTo>{ static const char* getName(){ return ">="; } };
-
-    template<typename T>
-    T& opCast(T const& t) { return const_cast<T&>(t); }
-
-// nullptr_t support based on pull request #154 from Konstantin Baumann
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    inline std::nullptr_t opCast(std::nullptr_t) { return nullptr; }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-    // So the compare overloads can be operator agnostic we convey the operator as a template
-    // enum, which is used to specialise an Evaluator for doing the comparison.
-    template<typename T1, typename T2, Operator Op>
-    struct Evaluator{};
-
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs) {
-            return bool( opCast( lhs ) ==  opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsNotEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) != opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) < opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThan> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) > opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsGreaterThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) >= opCast( rhs ) );
-        }
-    };
-    template<typename T1, typename T2>
-    struct Evaluator<T1, T2, IsLessThanOrEqualTo> {
-        static bool evaluate( T1 const& lhs, T2 const& rhs ) {
-            return bool( opCast( lhs ) <= opCast( rhs ) );
-        }
-    };
-
-    template<Operator Op, typename T1, typename T2>
-    bool applyEvaluator( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // This level of indirection allows us to specialise for integer types
-    // to avoid signed/ unsigned warnings
-
-    // "base" overload
-    template<Operator Op, typename T1, typename T2>
-    bool compare( T1 const& lhs, T2 const& rhs ) {
-        return Evaluator<T1, T2, Op>::evaluate( lhs, rhs );
-    }
-
-    // unsigned X to int
-    template<Operator Op> bool compare( unsigned int lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, int rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned int>( rhs ) );
-    }
-
-    // unsigned X to long
-    template<Operator Op> bool compare( unsigned int lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned long lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-    template<Operator Op> bool compare( unsigned char lhs, long rhs ) {
-        return applyEvaluator<Op>( lhs, static_cast<unsigned long>( rhs ) );
-    }
-
-    // int to unsigned X
-    template<Operator Op> bool compare( int lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( int lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned int>( lhs ), rhs );
-    }
-
-    // long to unsigned X
-    template<Operator Op> bool compare( long lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-
-    // pointer to long (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-    // pointer to int (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( int lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, int rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-    // long long to unsigned X
-    template<Operator Op> bool compare( long long lhs, unsigned int rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned long long rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( long long lhs, unsigned char rhs ) {
-        return applyEvaluator<Op>( static_cast<unsigned long>( lhs ), rhs );
-    }
-
-    // unsigned long long to X
-    template<Operator Op> bool compare( unsigned long long lhs, int rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, long rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, long long rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-    template<Operator Op> bool compare( unsigned long long lhs, char rhs ) {
-        return applyEvaluator<Op>( static_cast<long>( lhs ), rhs );
-    }
-
-    // pointer to long long (when comparing against NULL)
-    template<Operator Op, typename T> bool compare( long long lhs, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( reinterpret_cast<T*>( lhs ), rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, long long rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, reinterpret_cast<T*>( rhs ) );
-    }
-#endif // CATCH_CONFIG_CPP11_LONG_LONG
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-    // pointer to nullptr_t (when comparing against nullptr)
-    template<Operator Op, typename T> bool compare( std::nullptr_t, T* rhs ) {
-        return Evaluator<T*, T*, Op>::evaluate( nullptr, rhs );
-    }
-    template<Operator Op, typename T> bool compare( T* lhs, std::nullptr_t ) {
-        return Evaluator<T*, T*, Op>::evaluate( lhs, nullptr );
-    }
-#endif // CATCH_CONFIG_CPP11_NULLPTR
-
-} // end of namespace Internal
-} // end of namespace Catch
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// #included from: catch_tostring.h
-#define TWOBLUECUBES_CATCH_TOSTRING_H_INCLUDED
-
-#include <sstream>
-#include <iomanip>
-#include <limits>
 #include <vector>
 #include <cstddef>
+#include <type_traits>
+#include <string>
+// start catch_stream.h
+
+#include <iosfwd>
+#include <cstddef>
+#include <ostream>
+
+namespace Catch {
+
+    std::ostream& cout();
+    std::ostream& cerr();
+    std::ostream& clog();
+
+    class StringRef;
+
+    struct IStream {
+        virtual ~IStream();
+        virtual std::ostream& stream() const = 0;
+    };
+
+    auto makeStream( StringRef const &filename ) -> IStream const*;
+
+    class ReusableStringStream : NonCopyable {
+        std::size_t m_index;
+        std::ostream* m_oss;
+    public:
+        ReusableStringStream();
+        ~ReusableStringStream();
+
+        auto str() const -> std::string;
+
+        template<typename T>
+        auto operator << ( T const& value ) -> ReusableStringStream& {
+            *m_oss << value;
+            return *this;
+        }
+        auto get() -> std::ostream& { return *m_oss; }
+    };
+}
+
+// end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
 
 #ifdef __OBJC__
-// #included from: catch_objc_arc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_ARC_HPP_INCLUDED
+// start catch_objc_arc.hpp
 
 #import <Foundation/Foundation.h>
 
@@ -1551,481 +1540,1094 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 #define CATCH_ARC_STRONG __strong
 #endif
 
+// end catch_objc_arc.hpp
 #endif
 
-#ifdef CATCH_CONFIG_CPP11_TUPLE
-#include <tuple>
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_IS_ENUM
-#include <type_traits>
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
 #endif
 
 namespace Catch {
+    namespace Detail {
 
-// Why we're here.
-template<typename T>
-std::string toString( T const& value );
+        extern const std::string unprintableString;
 
-// Built in overloads
+        std::string rawMemoryToString( const void *object, std::size_t size );
 
-std::string toString( std::string const& value );
-std::string toString( std::wstring const& value );
-std::string toString( const char* const value );
-std::string toString( char* const value );
-std::string toString( const wchar_t* const value );
-std::string toString( wchar_t* const value );
-std::string toString( int value );
-std::string toString( unsigned long value );
-std::string toString( unsigned int value );
-std::string toString( const double value );
-std::string toString( const float value );
-std::string toString( bool value );
-std::string toString( char value );
-std::string toString( signed char value );
-std::string toString( unsigned char value );
+        template<typename T>
+        std::string rawMemoryToString( const T& object ) {
+          return rawMemoryToString( &object, sizeof(object) );
+        }
 
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-std::string toString( long long value );
-std::string toString( unsigned long long value );
+        template<typename T>
+        class IsStreamInsertable {
+            template<typename Stream, typename U>
+            static auto test(int)
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+
+            template<typename, typename>
+            static auto test(...)->std::false_type;
+
+        public:
+            static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+        };
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e );
+
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+        std::string>::type convertUnstreamable( T const& ) {
+            return Detail::unprintableString;
+        }
+        template<typename T>
+        typename std::enable_if<
+            !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+         std::string>::type convertUnstreamable(T const& ex) {
+            return ex.what();
+        }
+
+        template<typename T>
+        typename std::enable_if<
+            std::is_enum<T>::value
+        , std::string>::type convertUnstreamable( T const& value ) {
+            return convertUnknownEnumToString( value );
+        }
+
+#if defined(_MANAGED)
+        //! Convert a CLR string to a utf8 std::string
+        template<typename T>
+        std::string clrReferenceToString( T^ ref ) {
+            if (ref == nullptr)
+                return std::string("null");
+            auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+            cli::pin_ptr<System::Byte> p = &bytes[0];
+            return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+        }
 #endif
 
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t );
-#endif
+    } // namespace Detail
 
-#ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring );
-    std::string toString( NSString * CATCH_ARC_STRONG & nsstring );
-    std::string toString( NSObject* const& nsObject );
-#endif
+    // If we decide for C++14, change these to enable_if_ts
+    template <typename T, typename = void>
+    struct StringMaker {
+        template <typename Fake = T>
+        static
+        typename std::enable_if<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert(const Fake& value) {
+                ReusableStringStream rss;
+                // NB: call using the function-like syntax to avoid ambiguity with
+                // user-defined templated operator<< under clang.
+                rss.operator<<(value);
+                return rss.str();
+        }
 
-namespace Detail {
-
-    extern const std::string unprintableString;
-
- #if !defined(CATCH_CONFIG_CPP11_STREAM_INSERTABLE_CHECK)
-    struct BorgType {
-        template<typename T> BorgType( T const& );
-    };
-
-    struct TrueType { char sizer[1]; };
-    struct FalseType { char sizer[2]; };
-
-    TrueType& testStreamable( std::ostream& );
-    FalseType testStreamable( FalseType );
-
-    FalseType operator<<( std::ostream const&, BorgType const& );
-
-    template<typename T>
-    struct IsStreamInsertable {
-        static std::ostream &s;
-        static T  const&t;
-        enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
-    };
+        template <typename Fake = T>
+        static
+        typename std::enable_if<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>::type
+            convert( const Fake& value ) {
+#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+            return Detail::convertUnstreamable(value);
 #else
-    template<typename T>
-    class IsStreamInsertable {
-        template<typename SS, typename TT>
-        static auto test(int)
-        -> decltype( std::declval<SS&>() << std::declval<TT>(), std::true_type() );
-
-        template<typename, typename>
-        static auto test(...) -> std::false_type;
-
-    public:
-        static const bool value = decltype(test<std::ostream,const T&>(0))::value;
-    };
+            return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
 #endif
-
-#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
-    template<typename T,
-             bool IsEnum = std::is_enum<T>::value
-             >
-    struct EnumStringMaker
-    {
-        static std::string convert( T const& ) { return unprintableString; }
-    };
-
-    template<typename T>
-    struct EnumStringMaker<T,true>
-    {
-        static std::string convert( T const& v )
-        {
-            return ::Catch::toString(
-                static_cast<typename std::underlying_type<T>::type>(v)
-                );
         }
     };
-#endif
-    template<bool C>
-    struct StringMakerBase {
-#if defined(CATCH_CONFIG_CPP11_IS_ENUM)
-        template<typename T>
-        static std::string convert( T const& v )
-        {
-            return EnumStringMaker<T>::convert( v );
+
+    namespace Detail {
+
+        // This function dispatches all stringification requests inside of Catch.
+        // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+        template <typename T>
+        std::string stringify(const T& e) {
+            return ::Catch::StringMaker<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::convert(e);
+        }
+
+        template<typename E>
+        std::string convertUnknownEnumToString( E e ) {
+            return ::Catch::Detail::stringify(static_cast<typename std::underlying_type<E>::type>(e));
+        }
+
+#if defined(_MANAGED)
+        template <typename T>
+        std::string stringify( T^ e ) {
+            return ::Catch::StringMaker<T^>::convert(e);
         }
-#else
-        template<typename T>
-        static std::string convert( T const& ) { return unprintableString; }
 #endif
+
+    } // namespace Detail
+
+    // Some predefined specializations
+
+    template<>
+    struct StringMaker<std::string> {
+        static std::string convert(const std::string& str);
+    };
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
+    };
+#endif
+
+    template<>
+    struct StringMaker<char const *> {
+        static std::string convert(char const * str);
+    };
+    template<>
+    struct StringMaker<char *> {
+        static std::string convert(char * str);
+    };
+
+#ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
+    template<>
+    struct StringMaker<wchar_t const *> {
+        static std::string convert(wchar_t const * str);
+    };
+    template<>
+    struct StringMaker<wchar_t *> {
+        static std::string convert(wchar_t * str);
+    };
+#endif
+
+    // TBD: Should we use `strnlen` to ensure that we don't go out of the buffer,
+    //      while keeping string semantics?
+    template<int SZ>
+    struct StringMaker<char[SZ]> {
+        static std::string convert(char const* str) {
+            return ::Catch::Detail::stringify(std::string{ str });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<signed char[SZ]> {
+        static std::string convert(signed char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+    template<int SZ>
+    struct StringMaker<unsigned char[SZ]> {
+        static std::string convert(unsigned char const* str) {
+            return ::Catch::Detail::stringify(std::string{ reinterpret_cast<char const *>(str) });
+        }
+    };
+
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<int> {
+        static std::string convert(int value);
+    };
+    template<>
+    struct StringMaker<long> {
+        static std::string convert(long value);
+    };
+    template<>
+    struct StringMaker<long long> {
+        static std::string convert(long long value);
+    };
+    template<>
+    struct StringMaker<unsigned int> {
+        static std::string convert(unsigned int value);
+    };
+    template<>
+    struct StringMaker<unsigned long> {
+        static std::string convert(unsigned long value);
+    };
+    template<>
+    struct StringMaker<unsigned long long> {
+        static std::string convert(unsigned long long value);
     };
 
     template<>
-    struct StringMakerBase<true> {
-        template<typename T>
-        static std::string convert( T const& _value ) {
-            std::ostringstream oss;
-            oss << _value;
-            return oss.str();
+    struct StringMaker<bool> {
+        static std::string convert(bool b);
+    };
+
+    template<>
+    struct StringMaker<char> {
+        static std::string convert(char c);
+    };
+    template<>
+    struct StringMaker<signed char> {
+        static std::string convert(signed char c);
+    };
+    template<>
+    struct StringMaker<unsigned char> {
+        static std::string convert(unsigned char c);
+    };
+
+    template<>
+    struct StringMaker<std::nullptr_t> {
+        static std::string convert(std::nullptr_t);
+    };
+
+    template<>
+    struct StringMaker<float> {
+        static std::string convert(float value);
+        static int precision;
+    };
+
+    template<>
+    struct StringMaker<double> {
+        static std::string convert(double value);
+        static int precision;
+    };
+
+    template <typename T>
+    struct StringMaker<T*> {
+        template <typename U>
+        static std::string convert(U* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
         }
     };
 
-    std::string rawMemoryToString( const void *object, std::size_t size );
+    template <typename R, typename C>
+    struct StringMaker<R C::*> {
+        static std::string convert(R C::* p) {
+            if (p) {
+                return ::Catch::Detail::rawMemoryToString(p);
+            } else {
+                return "nullptr";
+            }
+        }
+    };
 
-    template<typename T>
-    std::string rawMemoryToString( const T& object ) {
-      return rawMemoryToString( &object, sizeof(object) );
-    }
-
-} // end namespace Detail
-
-template<typename T>
-struct StringMaker :
-    Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
-
-template<typename T>
-struct StringMaker<T*> {
-    template<typename U>
-    static std::string convert( U* p ) {
-        if( !p )
-            return "NULL";
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-template<typename R, typename C>
-struct StringMaker<R C::*> {
-    static std::string convert( R C::* p ) {
-        if( !p )
-            return "NULL";
-        else
-            return Detail::rawMemoryToString( p );
-    }
-};
-
-namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last );
-}
-
-//template<typename T, typename Allocator>
-//struct StringMaker<std::vector<T, Allocator> > {
-//    static std::string convert( std::vector<T,Allocator> const& v ) {
-//        return Detail::rangeToString( v.begin(), v.end() );
-//    }
-//};
-
-template<typename T, typename Allocator>
-std::string toString( std::vector<T,Allocator> const& v ) {
-    return Detail::rangeToString( v.begin(), v.end() );
-}
-
-#ifdef CATCH_CONFIG_CPP11_TUPLE
-
-// toString for tuples
-namespace TupleDetail {
-  template<
-      typename Tuple,
-      std::size_t N = 0,
-      bool = (N < std::tuple_size<Tuple>::value)
-      >
-  struct ElementPrinter {
-      static void print( const Tuple& tuple, std::ostream& os )
-      {
-          os << ( N ? ", " : " " )
-             << Catch::toString(std::get<N>(tuple));
-          ElementPrinter<Tuple,N+1>::print(tuple,os);
-      }
-  };
-
-  template<
-      typename Tuple,
-      std::size_t N
-      >
-  struct ElementPrinter<Tuple,N,false> {
-      static void print( const Tuple&, std::ostream& ) {}
-  };
-
-}
-
-template<typename ...Types>
-struct StringMaker<std::tuple<Types...>> {
-
-    static std::string convert( const std::tuple<Types...>& tuple )
-    {
-        std::ostringstream os;
-        os << '{';
-        TupleDetail::ElementPrinter<std::tuple<Types...>>::print( tuple, os );
-        os << " }";
-        return os.str();
-    }
-};
-#endif // CATCH_CONFIG_CPP11_TUPLE
-
-namespace Detail {
-    template<typename T>
-    std::string makeString( T const& value ) {
-        return StringMaker<T>::convert( value );
-    }
-} // end namespace Detail
-
-/// \brief converts any type to a string
-///
-/// The default template forwards on to ostringstream - except when an
-/// ostringstream overload does not exist - in which case it attempts to detect
-/// that and writes {?}.
-/// Overload (not specialise) this template for custom typs that you don't want
-/// to provide an ostream overload for.
-template<typename T>
-std::string toString( T const& value ) {
-    return StringMaker<T>::convert( value );
-}
+#if defined(_MANAGED)
+    template <typename T>
+    struct StringMaker<T^> {
+        static std::string convert( T^ ref ) {
+            return ::Catch::Detail::clrReferenceToString(ref);
+        }
+    };
+#endif
 
     namespace Detail {
-    template<typename InputIterator>
-    std::string rangeToString( InputIterator first, InputIterator last ) {
-        std::ostringstream oss;
-        oss << "{ ";
-        if( first != last ) {
-            oss << Catch::toString( *first );
-            for( ++first ; first != last ; ++first )
-                oss << ", " << Catch::toString( *first );
+        template<typename InputIterator, typename Sentinel = InputIterator>
+        std::string rangeToString(InputIterator first, Sentinel last) {
+            ReusableStringStream rss;
+            rss << "{ ";
+            if (first != last) {
+                rss << ::Catch::Detail::stringify(*first);
+                for (++first; first != last; ++first)
+                    rss << ", " << ::Catch::Detail::stringify(*first);
+            }
+            rss << " }";
+            return rss.str();
         }
-        oss << " }";
-        return oss.str();
-    }
-}
-
-} // end namespace Catch
-
-namespace Catch {
-
-template<typename LhsT, Internal::Operator Op, typename RhsT>
-class BinaryExpression;
-
-template<typename ArgT, typename MatcherT>
-class MatchExpression;
-
-// Wraps the LHS of an expression and overloads comparison operators
-// for also capturing those and RHS (if any)
-template<typename T>
-class ExpressionLhs : public DecomposedExpression {
-public:
-    ExpressionLhs( ResultBuilder& rb, T lhs ) : m_rb( rb ), m_lhs( lhs ), m_truthy(false) {}
-
-    ExpressionLhs& operator = ( const ExpressionLhs& );
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsEqualTo, RhsT const&>
-    operator == ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
     }
 
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsNotEqualTo, RhsT const&>
-    operator != ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
+#ifdef __OBJC__
+    template<>
+    struct StringMaker<NSString*> {
+        static std::string convert(NSString * nsstring) {
+            if (!nsstring)
+                return "nil";
+            return std::string("@") + [nsstring UTF8String];
+        }
+    };
+    template<>
+    struct StringMaker<NSObject*> {
+        static std::string convert(NSObject* nsObject) {
+            return ::Catch::Detail::stringify([nsObject description]);
+        }
 
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsLessThan, RhsT const&>
-    operator < ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThan>( rhs );
-    }
+    };
+    namespace Detail {
+        inline std::string stringify( NSString* nsstring ) {
+            return StringMaker<NSString*>::convert( nsstring );
+        }
 
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsGreaterThan, RhsT const&>
-    operator > ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThan>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsLessThanOrEqualTo, RhsT const&>
-    operator <= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsLessThanOrEqualTo>( rhs );
-    }
-
-    template<typename RhsT>
-    BinaryExpression<T, Internal::IsGreaterThanOrEqualTo, RhsT const&>
-    operator >= ( RhsT const& rhs ) {
-        return captureExpression<Internal::IsGreaterThanOrEqualTo>( rhs );
-    }
-
-    BinaryExpression<T, Internal::IsEqualTo, bool> operator == ( bool rhs ) {
-        return captureExpression<Internal::IsEqualTo>( rhs );
-    }
-
-    BinaryExpression<T, Internal::IsNotEqualTo, bool> operator != ( bool rhs ) {
-        return captureExpression<Internal::IsNotEqualTo>( rhs );
-    }
-
-    void endExpression() {
-        m_truthy = m_lhs ? true : false;
-        m_rb
-            .setResultType( m_truthy )
-            .endExpression( *this );
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        dest = Catch::toString( m_lhs );
-    }
-
-private:
-    template<Internal::Operator Op, typename RhsT>
-    BinaryExpression<T, Op, RhsT&> captureExpression( RhsT& rhs ) const {
-        return BinaryExpression<T, Op, RhsT&>( m_rb, m_lhs, rhs );
-    }
-
-    template<Internal::Operator Op>
-    BinaryExpression<T, Op, bool> captureExpression( bool rhs ) const {
-        return BinaryExpression<T, Op, bool>( m_rb, m_lhs, rhs );
-    }
-
-private:
-    ResultBuilder& m_rb;
-    T m_lhs;
-    bool m_truthy;
-};
-
-template<typename LhsT, Internal::Operator Op, typename RhsT>
-class BinaryExpression : public DecomposedExpression {
-public:
-    BinaryExpression( ResultBuilder& rb, LhsT lhs, RhsT rhs )
-        : m_rb( rb ), m_lhs( lhs ), m_rhs( rhs ) {}
-
-    BinaryExpression& operator = ( BinaryExpression& );
-
-    void endExpression() const {
-        m_rb
-            .setResultType( Internal::compare<Op>( m_lhs, m_rhs ) )
-            .endExpression( *this );
-    }
-
-    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
-        return true;
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        std::string lhs = Catch::toString( m_lhs );
-        std::string rhs = Catch::toString( m_rhs );
-        char delim = lhs.size() + rhs.size() < 40 &&
-                     lhs.find('\n') == std::string::npos &&
-                     rhs.find('\n') == std::string::npos ? ' ' : '\n';
-        dest.reserve( 7 + lhs.size() + rhs.size() );
-                   // 2 for spaces around operator
-                   // 2 for operator
-                   // 2 for parentheses (conditionally added later)
-                   // 1 for negation (conditionally added later)
-        dest = lhs;
-        dest += delim;
-        dest += Internal::OperatorTraits<Op>::getName();
-        dest += delim;
-        dest += rhs;
-    }
-
-private:
-    ResultBuilder& m_rb;
-    LhsT m_lhs;
-    RhsT m_rhs;
-};
-
-template<typename ArgT, typename MatcherT>
-class MatchExpression : public DecomposedExpression {
-public:
-    MatchExpression( ArgT arg, MatcherT matcher, char const* matcherString )
-        : m_arg( arg ), m_matcher( matcher ), m_matcherString( matcherString ) {}
-
-    virtual bool isBinaryExpression() const CATCH_OVERRIDE {
-        return true;
-    }
-
-    virtual void reconstructExpression( std::string& dest ) const CATCH_OVERRIDE {
-        std::string matcherAsString = m_matcher.toString();
-        dest = Catch::toString( m_arg );
-        dest += ' ';
-        if( matcherAsString == Detail::unprintableString )
-            dest += m_matcherString;
-        else
-            dest += matcherAsString;
-    }
-
-private:
-    ArgT m_arg;
-    MatcherT m_matcher;
-    char const* m_matcherString;
-};
-
-} // end namespace Catch
-
-
-namespace Catch {
-
-    template<typename T>
-    ExpressionLhs<T const&> ResultBuilder::operator <= ( T const& operand ) {
-        return ExpressionLhs<T const&>( *this, operand );
-    }
-
-    inline ExpressionLhs<bool> ResultBuilder::operator <= ( bool value ) {
-        return ExpressionLhs<bool>( *this, value );
-    }
-
-    template<typename ArgT, typename MatcherT>
-    void ResultBuilder::captureMatch( ArgT const& arg, MatcherT const& matcher,
-                                             char const* matcherString ) {
-        MatchExpression<ArgT const&, MatcherT const&> expr( arg, matcher, matcherString );
-        setResultType( matcher.match( arg ) );
-        endExpression( expr );
-    }
+    } // namespace Detail
+#endif // __OBJC__
 
 } // namespace Catch
 
-// #included from: catch_message.h
-#define TWOBLUECUBES_CATCH_MESSAGE_H_INCLUDED
+//////////////////////////////////////////////////////
+// Separate std-lib types stringification, so it can be selectively enabled
+// This means that we do not bring in
+
+#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+#  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+#endif
+
+// Separate std::pair specialization
+#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+#include <utility>
+namespace Catch {
+    template<typename T1, typename T2>
+    struct StringMaker<std::pair<T1, T2> > {
+        static std::string convert(const std::pair<T1, T2>& pair) {
+            ReusableStringStream rss;
+            rss << "{ "
+                << ::Catch::Detail::stringify(pair.first)
+                << ", "
+                << ::Catch::Detail::stringify(pair.second)
+                << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
+// Separate std::tuple specialization
+#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+#include <tuple>
+namespace Catch {
+    namespace Detail {
+        template<
+            typename Tuple,
+            std::size_t N = 0,
+            bool = (N < std::tuple_size<Tuple>::value)
+            >
+            struct TupleElementPrinter {
+            static void print(const Tuple& tuple, std::ostream& os) {
+                os << (N ? ", " : " ")
+                    << ::Catch::Detail::stringify(std::get<N>(tuple));
+                TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+            }
+        };
+
+        template<
+            typename Tuple,
+            std::size_t N
+        >
+            struct TupleElementPrinter<Tuple, N, false> {
+            static void print(const Tuple&, std::ostream&) {}
+        };
+
+    }
+
+    template<typename ...Types>
+    struct StringMaker<std::tuple<Types...>> {
+        static std::string convert(const std::tuple<Types...>& tuple) {
+            ReusableStringStream rss;
+            rss << '{';
+            Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+            rss << " }";
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
+namespace Catch {
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    // Import begin/ end from std here
+    using std::begin;
+    using std::end;
+
+    namespace detail {
+        template <typename...>
+        struct void_type {
+            using type = void;
+        };
+
+        template <typename T, typename = void>
+        struct is_range_impl : std::false_type {
+        };
+
+        template <typename T>
+        struct is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> : std::true_type {
+        };
+    } // namespace detail
+
+    template <typename T>
+    struct is_range : detail::is_range_impl<T> {
+    };
+
+#if defined(_MANAGED) // Managed types are never ranges
+    template <typename T>
+    struct is_range<T^> {
+        static const bool value = false;
+    };
+#endif
+
+    template<typename Range>
+    std::string rangeToString( Range const& range ) {
+        return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+    }
+
+    // Handle vector<bool> specially
+    template<typename Allocator>
+    std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+        ReusableStringStream rss;
+        rss << "{ ";
+        bool first = true;
+        for( bool b : v ) {
+            if( first )
+                first = false;
+            else
+                rss << ", ";
+            rss << ::Catch::Detail::stringify( b );
+        }
+        rss << " }";
+        return rss.str();
+    }
+
+    template<typename R>
+    struct StringMaker<R, typename std::enable_if<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>::type> {
+        static std::string convert( R const& range ) {
+            return rangeToString( range );
+        }
+    };
+
+    template <typename T, int SZ>
+    struct StringMaker<T[SZ]> {
+        static std::string convert(T const(&arr)[SZ]) {
+            return rangeToString(arr);
+        }
+    };
+
+} // namespace Catch
+
+// Separate std::chrono::duration specialization
+#if defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#include <ctime>
+#include <ratio>
+#include <chrono>
+
+namespace Catch {
+
+template <class Ratio>
+struct ratio_string {
+    static std::string symbol();
+};
+
+template <class Ratio>
+std::string ratio_string<Ratio>::symbol() {
+    Catch::ReusableStringStream rss;
+    rss << '[' << Ratio::num << '/'
+        << Ratio::den << ']';
+    return rss.str();
+}
+template <>
+struct ratio_string<std::atto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::femto> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::pico> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::nano> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::micro> {
+    static std::string symbol();
+};
+template <>
+struct ratio_string<std::milli> {
+    static std::string symbol();
+};
+
+    ////////////
+    // std::chrono::duration specializations
+    template<typename Value, typename Ratio>
+    struct StringMaker<std::chrono::duration<Value, Ratio>> {
+        static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " s";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " m";
+            return rss.str();
+        }
+    };
+    template<typename Value>
+    struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+        static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+            ReusableStringStream rss;
+            rss << duration.count() << " h";
+            return rss.str();
+        }
+    };
+
+    ////////////
+    // std::chrono::time_point specialization
+    // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+    template<typename Clock, typename Duration>
+    struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+        static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+            return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+        }
+    };
+    // std::chrono::time_point<system_clock> specialization
+    template<typename Duration>
+    struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+        static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+            auto converted = std::chrono::system_clock::to_time_t(time_point);
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &converted);
+#else
+            std::tm* timeInfo = std::gmtime(&converted);
+#endif
+
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp);
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_tostring.h
+#include <iosfwd>
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
+#endif
+
+namespace Catch {
+
+    struct ITransientExpression {
+        auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+        auto getResult() const -> bool { return m_result; }
+        virtual void streamReconstructedExpression( std::ostream &os ) const = 0;
+
+        ITransientExpression( bool isBinaryExpression, bool result )
+        :   m_isBinaryExpression( isBinaryExpression ),
+            m_result( result )
+        {}
+
+        // We don't actually need a virtual destructor, but many static analysers
+        // complain if it's not here :-(
+        virtual ~ITransientExpression();
+
+        bool m_isBinaryExpression;
+        bool m_result;
+
+    };
+
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+
+    template<typename LhsT, typename RhsT>
+    class BinaryExpr  : public ITransientExpression {
+        LhsT m_lhs;
+        StringRef m_op;
+        RhsT m_rhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            formatReconstructedExpression
+                    ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+        }
+
+    public:
+        BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+        :   ITransientExpression{ true, comparisonResult },
+            m_lhs( lhs ),
+            m_op( op ),
+            m_rhs( rhs )
+        {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+    };
+
+    template<typename LhsT>
+    class UnaryExpr : public ITransientExpression {
+        LhsT m_lhs;
+
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            os << Catch::Detail::stringify( m_lhs );
+        }
+
+    public:
+        explicit UnaryExpr( LhsT lhs )
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
+            m_lhs( lhs )
+        {}
+    };
+
+    // Specialised comparison functions to handle equality comparisons between ints and pointers (NULL deduces as an int)
+    template<typename LhsT, typename RhsT>
+    auto compareEqual( LhsT const& lhs, RhsT const& rhs ) -> bool { return static_cast<bool>(lhs == rhs); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, int rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( T* const& lhs, long rhs ) -> bool { return lhs == reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+    template<typename T>
+    auto compareEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) == rhs; }
+
+    template<typename LhsT, typename RhsT>
+    auto compareNotEqual( LhsT const& lhs, RhsT&& rhs ) -> bool { return static_cast<bool>(lhs != rhs); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, int rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( T* const& lhs, long rhs ) -> bool { return lhs != reinterpret_cast<void const*>( rhs ); }
+    template<typename T>
+    auto compareNotEqual( int lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+    template<typename T>
+    auto compareNotEqual( long lhs, T* const& rhs ) -> bool { return reinterpret_cast<void const*>( lhs ) != rhs; }
+
+    template<typename LhsT>
+    class ExprLhs {
+        LhsT m_lhs;
+    public:
+        explicit ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+
+        template<typename RhsT>
+        auto operator == ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareEqual( m_lhs, rhs ), m_lhs, "==", rhs };
+        }
+        auto operator == ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs == rhs, m_lhs, "==", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator != ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { compareNotEqual( m_lhs, rhs ), m_lhs, "!=", rhs };
+        }
+        auto operator != ( bool rhs ) -> BinaryExpr<LhsT, bool> const {
+            return { m_lhs != rhs, m_lhs, "!=", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator > ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs > rhs), m_lhs, ">", rhs };
+        }
+        template<typename RhsT>
+        auto operator < ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs < rhs), m_lhs, "<", rhs };
+        }
+        template<typename RhsT>
+        auto operator >= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs >= rhs), m_lhs, ">=", rhs };
+        }
+        template<typename RhsT>
+        auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
+        }
+        template <typename RhsT>
+        auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs | rhs), m_lhs, "|", rhs };
+        }
+        template <typename RhsT>
+        auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs & rhs), m_lhs, "&", rhs };
+        }
+        template <typename RhsT>
+        auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+            return UnaryExpr<LhsT>{ m_lhs };
+        }
+    };
+
+    void handleExpression( ITransientExpression const& expr );
+
+    template<typename T>
+    void handleExpression( ExprLhs<T> const& expr ) {
+        handleExpression( expr.makeUnaryExpr() );
+    }
+
+    struct Decomposer {
+        template<typename T>
+        auto operator <= ( T const& lhs ) -> ExprLhs<T const&> {
+            return ExprLhs<T const&>{ lhs };
+        }
+
+        auto operator <=( bool value ) -> ExprLhs<bool> {
+            return ExprLhs<bool>{ value };
+        }
+    };
+
+} // end namespace Catch
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+// end catch_decomposer.h
+// start catch_interfaces_capture.h
 
 #include <string>
+#include <chrono>
+
+namespace Catch {
+
+    class AssertionResult;
+    struct AssertionInfo;
+    struct SectionInfo;
+    struct SectionEndInfo;
+    struct MessageInfo;
+    struct MessageBuilder;
+    struct Counts;
+    struct AssertionReaction;
+    struct SourceLineInfo;
+
+    struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IResultCapture {
+
+        virtual ~IResultCapture();
+
+        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
+                                        Counts& assertions ) = 0;
+        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
+        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
+
+        virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
+        virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+        virtual void popScopedMessage( MessageInfo const& message ) = 0;
+
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
+        virtual void handleFatalErrorCondition( StringRef message ) = 0;
+
+        virtual void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) = 0;
+        virtual void handleIncomplete
+                (   AssertionInfo const& info ) = 0;
+        virtual void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) = 0;
+
+        virtual bool lastAssertionPassed() = 0;
+        virtual void assertionPassed() = 0;
+
+        // Deprecated, do not use:
+        virtual std::string getCurrentTestName() const = 0;
+        virtual const AssertionResult* getLastResult() const = 0;
+        virtual void exceptionEarlyReported() = 0;
+    };
+
+    IResultCapture& getResultCapture();
+}
+
+// end catch_interfaces_capture.h
+namespace Catch {
+
+    struct TestFailureException{};
+    struct AssertionResultData;
+    struct IResultCapture;
+    class RunContext;
+
+    class LazyExpression {
+        friend class AssertionHandler;
+        friend struct AssertionStats;
+        friend class RunContext;
+
+        ITransientExpression const* m_transientExpression = nullptr;
+        bool m_isNegated;
+    public:
+        LazyExpression( bool isNegated );
+        LazyExpression( LazyExpression const& other );
+        LazyExpression& operator = ( LazyExpression const& ) = delete;
+
+        explicit operator bool() const;
+
+        friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+    };
+
+    struct AssertionReaction {
+        bool shouldDebugBreak = false;
+        bool shouldThrow = false;
+    };
+
+    class AssertionHandler {
+        AssertionInfo m_assertionInfo;
+        AssertionReaction m_reaction;
+        bool m_completed = false;
+        IResultCapture& m_resultCapture;
+
+    public:
+        AssertionHandler
+            (   StringRef const& macroName,
+                SourceLineInfo const& lineInfo,
+                StringRef capturedExpression,
+                ResultDisposition::Flags resultDisposition );
+        ~AssertionHandler() {
+            if ( !m_completed ) {
+                m_resultCapture.handleIncomplete( m_assertionInfo );
+            }
+        }
+
+        template<typename T>
+        void handleExpr( ExprLhs<T> const& expr ) {
+            handleExpr( expr.makeUnaryExpr() );
+        }
+        void handleExpr( ITransientExpression const& expr );
+
+        void handleMessage(ResultWas::OfType resultType, StringRef const& message);
+
+        void handleExceptionThrownAsExpected();
+        void handleUnexpectedExceptionNotThrown();
+        void handleExceptionNotThrownAsExpected();
+        void handleThrowingCallSkipped();
+        void handleUnexpectedInflightException();
+
+        void complete();
+        void setCompleted();
+
+        // query
+        auto allowThrows() const -> bool;
+    };
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
+
+} // namespace Catch
+
+// end catch_assertionhandler.h
+// start catch_message.h
+
+#include <string>
+#include <vector>
 
 namespace Catch {
 
     struct MessageInfo {
-        MessageInfo(    std::string const& _macroName,
+        MessageInfo(    StringRef const& _macroName,
                         SourceLineInfo const& _lineInfo,
                         ResultWas::OfType _type );
 
-        std::string macroName;
+        StringRef macroName;
+        std::string message;
         SourceLineInfo lineInfo;
         ResultWas::OfType type;
-        std::string message;
         unsigned int sequence;
 
-        bool operator == ( MessageInfo const& other ) const {
-            return sequence == other.sequence;
-        }
-        bool operator < ( MessageInfo const& other ) const {
-            return sequence < other.sequence;
-        }
+        bool operator == ( MessageInfo const& other ) const;
+        bool operator < ( MessageInfo const& other ) const;
     private:
         static unsigned int globalCount;
     };
 
-    struct MessageBuilder {
-        MessageBuilder( std::string const& macroName,
+    struct MessageStream {
+
+        template<typename T>
+        MessageStream& operator << ( T const& value ) {
+            m_stream << value;
+            return *this;
+        }
+
+        ReusableStringStream m_stream;
+    };
+
+    struct MessageBuilder : MessageStream {
+        MessageBuilder( StringRef const& macroName,
                         SourceLineInfo const& lineInfo,
-                        ResultWas::OfType type )
-        : m_info( macroName, lineInfo, type )
-        {}
+                        ResultWas::OfType type );
 
         template<typename T>
         MessageBuilder& operator << ( T const& value ) {
@@ -2034,400 +2636,244 @@ namespace Catch {
         }
 
         MessageInfo m_info;
-        std::ostringstream m_stream;
     };
 
     class ScopedMessage {
     public:
-        ScopedMessage( MessageBuilder const& builder );
-        ScopedMessage( ScopedMessage const& other );
+        explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
         ~ScopedMessage();
 
         MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
     };
 
 } // end namespace Catch
 
-// #included from: catch_interfaces_capture.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CAPTURE_H_INCLUDED
-
-#include <string>
-
-namespace Catch {
-
-    class TestCase;
-    class AssertionResult;
-    struct AssertionInfo;
-    struct SectionInfo;
-    struct SectionEndInfo;
-    struct MessageInfo;
-    class ScopedMessageBuilder;
-    struct Counts;
-
-    struct IResultCapture {
-
-        virtual ~IResultCapture();
-
-        virtual void assertionEnded( AssertionResult const& result ) = 0;
-        virtual bool sectionStarted(    SectionInfo const& sectionInfo,
-                                        Counts& assertions ) = 0;
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
-        virtual void pushScopedMessage( MessageInfo const& message ) = 0;
-        virtual void popScopedMessage( MessageInfo const& message ) = 0;
-
-        virtual std::string getCurrentTestName() const = 0;
-        virtual const AssertionResult* getLastResult() const = 0;
-
-        virtual void exceptionEarlyReported() = 0;
-
-        virtual void handleFatalErrorCondition( std::string const& message ) = 0;
-
-        virtual bool lastAssertionPassed() = 0;
-        virtual void assertionPassed() = 0;
-        virtual void assertionRun() = 0;
-    };
-
-    IResultCapture& getResultCapture();
-}
-
-// #included from: catch_debugger.h
-#define TWOBLUECUBES_CATCH_DEBUGGER_H_INCLUDED
-
-// #included from: catch_platform.h
-#define TWOBLUECUBES_CATCH_PLATFORM_H_INCLUDED
-
-#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED)
-#  define CATCH_PLATFORM_MAC
-#elif  defined(__IPHONE_OS_VERSION_MIN_REQUIRED)
-#  define CATCH_PLATFORM_IPHONE
-#elif defined(linux) || defined(__linux) || defined(__linux__)
-#  define CATCH_PLATFORM_LINUX
-#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#  define CATCH_PLATFORM_WINDOWS
-#  if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
-#    define CATCH_DEFINES_NOMINMAX
-#  endif
-#  if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
-#    define CATCH_DEFINES_WIN32_LEAN_AND_MEAN
-#  endif
-#endif
-
-#include <string>
-
-namespace Catch{
-
-    bool isDebuggerActive();
-    void writeToDebugConsole( std::string const& text );
-}
-
-#ifdef CATCH_PLATFORM_MAC
-
-    // The following code snippet based on:
-    // http://cocoawithlove.com/2008/03/break-into-debugger.html
-    #if defined(__ppc64__) || defined(__ppc__)
-        #define CATCH_TRAP() \
-                __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
-                : : : "memory","r0","r3","r4" ) /* NOLINT */
-    #else
-        #define CATCH_TRAP() __asm__("int $3\n" : : /* NOLINT */ )
-    #endif
-
-#elif defined(CATCH_PLATFORM_LINUX)
-    // If we can use inline assembler, do it because this allows us to break
-    // directly at the location of the failing check instead of breaking inside
-    // raise() called from it, i.e. one stack frame below.
-    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
-        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
-    #else // Fall back to the generic way.
-        #include <signal.h>
-
-        #define CATCH_TRAP() raise(SIGTRAP)
-    #endif
-#elif defined(_MSC_VER)
-    #define CATCH_TRAP() __debugbreak()
-#elif defined(__MINGW32__)
-    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
-    #define CATCH_TRAP() DebugBreak()
-#endif
-
-#ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
-#else
-    #define CATCH_BREAK_INTO_DEBUGGER() Catch::alwaysTrue();
-#endif
-
-// #included from: catch_interfaces_runner.h
-#define TWOBLUECUBES_CATCH_INTERFACES_RUNNER_H_INCLUDED
-
-namespace Catch {
-    class TestCase;
-
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
+// end catch_message.h
+#if !defined(CATCH_CONFIG_DISABLE)
 
 #if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
-# define CATCH_INTERNAL_STRINGIFY(expr) #expr
+  #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__
 #else
-# define CATCH_INTERNAL_STRINGIFY(expr) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
+  #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-///////////////////////////////////////////////////////////////////////////////
-// We can speedup compilation significantly by breaking into debugger lower in
-// the callstack, because then we don't have to expand CATCH_BREAK_INTO_DEBUGGER
-// macro in each assertion
-#define INTERNAL_CATCH_REACT( resultBuilder ) \
-    resultBuilder.react();
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 
 ///////////////////////////////////////////////////////////////////////////////
 // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
 // macros.
-// This can potentially cause false negative, if the test code catches
-// the exception before it propagates back up to the runner.
-#define INTERNAL_CATCH_TEST_NO_TRY( macroName, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
-        __catchResult.setExceptionGuard(); \
-        CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-        ( __catchResult <= expr ).endExpression(); \
-        CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        __catchResult.unsetExceptionGuard(); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
-// The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+#define INTERNAL_CATCH_TRY
+#define INTERNAL_CATCH_CATCH( capturer )
 
-#define INTERNAL_CHECK_THAT_NO_TRY( macroName, matcher, resultDisposition, arg ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        __catchResult.setExceptionGuard(); \
-        __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        __catchResult.unsetExceptionGuard(); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
+#else // CATCH_CONFIG_FAST_COMPILE
+
+#define INTERNAL_CATCH_TRY try
+#define INTERNAL_CATCH_CATCH( handler ) catch(...) { handler.handleUnexpectedInflightException(); }
 
-#else
-///////////////////////////////////////////////////////////////////////////////
-// In the event of a failure works out if the debugger needs to be invoked
-// and/or an exception thrown and takes appropriate action.
-// This needs to be done as a macro so the debugger will stop in the user
-// source code rather than in Catch library code
-#define INTERNAL_CATCH_REACT( resultBuilder ) \
-    if( resultBuilder.shouldDebugBreak() ) CATCH_BREAK_INTO_DEBUGGER(); \
-    resultBuilder.react();
 #endif
 
-///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ) \
-    do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
-        try { \
-            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            ( __catchResult <= expr ).endExpression(); \
-            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-        } \
-        catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::isTrue( false && static_cast<bool>( !!(expr) ) ) ) // expr here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+#define INTERNAL_CATCH_REACT( handler ) handler.complete();
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_IF( macroName, resultDisposition, expr ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+    do { \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+            CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+            catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
     if( Catch::getResultCapture().lastAssertionPassed() )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, expr ) \
-    INTERNAL_CATCH_TEST( macroName, resultDisposition, expr ); \
+#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+    INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
     if( !Catch::getResultCapture().lastAssertionPassed() )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, expr ) \
+#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         try { \
-            static_cast<void>(expr); \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            static_cast<void>(__VA_ARGS__); \
+            catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
         } \
         catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition ); \
+            catchAssertionHandler.handleUnexpectedInflightException(); \
         } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, matcher, expr ) \
+#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr), resultDisposition, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        if( __catchResult.allowThrows() ) \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        if( catchAssertionHandler.allowThrows() ) \
             try { \
-                static_cast<void>(expr); \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( ... ) { \
-                __catchResult.captureExpectedException( matcher ); \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
             } \
         else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
-        if( __catchResult.allowThrows() ) \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
-                __catchResult.captureResult( Catch::ResultWas::DidntThrowException ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
-            catch( exceptionType ) { \
-                __catchResult.captureResult( Catch::ResultWas::Ok ); \
+            catch( exceptionType const& ) { \
+                catchAssertionHandler.handleExceptionThrownAsExpected(); \
             } \
             catch( ... ) { \
-                __catchResult.useActiveException( resultDisposition ); \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
             } \
         else \
-            __catchResult.captureResult( Catch::ResultWas::Ok ); \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
 
 ///////////////////////////////////////////////////////////////////////////////
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#else
-    #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, log ) \
-        do { \
-            Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
-            __catchResult << log + ::Catch::StreamEndStop(); \
-            __catchResult.captureResult( messageType ); \
-            INTERNAL_CATCH_REACT( __catchResult ) \
-        } while( Catch::alwaysFalse() )
-#endif
+#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+        catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage ) = Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log;
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
 
 ///////////////////////////////////////////////////////////////////////////////
-#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+
+///////////////////////////////////////////////////////////////////////////////
+// Although this is matcher-based, it can be used with just a string
+#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
     do { \
-        Catch::ResultBuilder __catchResult( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
-        try { \
-            __catchResult.captureMatch( arg, matcher, CATCH_INTERNAL_STRINGIFY(matcher) ); \
-        } catch( ... ) { \
-            __catchResult.useActiveException( resultDisposition | Catch::ResultDisposition::ContinueOnFailure ); \
-        } \
-        INTERNAL_CATCH_REACT( __catchResult ) \
-    } while( Catch::alwaysFalse() )
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( ... ) { \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
 
-// #included from: internal/catch_section.h
-#define TWOBLUECUBES_CATCH_SECTION_H_INCLUDED
+#endif // CATCH_CONFIG_DISABLE
 
-// #included from: catch_section_info.h
-#define TWOBLUECUBES_CATCH_SECTION_INFO_H_INCLUDED
+// end catch_capture.hpp
+// start catch_section.h
 
-// #included from: catch_totals.hpp
-#define TWOBLUECUBES_CATCH_TOTALS_HPP_INCLUDED
+// start catch_section_info.h
+
+// start catch_totals.h
 
 #include <cstddef>
 
 namespace Catch {
 
     struct Counts {
-        Counts() : passed( 0 ), failed( 0 ), failedButOk( 0 ) {}
+        Counts operator - ( Counts const& other ) const;
+        Counts& operator += ( Counts const& other );
 
-        Counts operator - ( Counts const& other ) const {
-            Counts diff;
-            diff.passed = passed - other.passed;
-            diff.failed = failed - other.failed;
-            diff.failedButOk = failedButOk - other.failedButOk;
-            return diff;
-        }
-        Counts& operator += ( Counts const& other ) {
-            passed += other.passed;
-            failed += other.failed;
-            failedButOk += other.failedButOk;
-            return *this;
-        }
+        std::size_t total() const;
+        bool allPassed() const;
+        bool allOk() const;
 
-        std::size_t total() const {
-            return passed + failed + failedButOk;
-        }
-        bool allPassed() const {
-            return failed == 0 && failedButOk == 0;
-        }
-        bool allOk() const {
-            return failed == 0;
-        }
-
-        std::size_t passed;
-        std::size_t failed;
-        std::size_t failedButOk;
+        std::size_t passed = 0;
+        std::size_t failed = 0;
+        std::size_t failedButOk = 0;
     };
 
     struct Totals {
 
-        Totals operator - ( Totals const& other ) const {
-            Totals diff;
-            diff.assertions = assertions - other.assertions;
-            diff.testCases = testCases - other.testCases;
-            return diff;
-        }
+        Totals operator - ( Totals const& other ) const;
+        Totals& operator += ( Totals const& other );
 
-        Totals delta( Totals const& prevTotals ) const {
-            Totals diff = *this - prevTotals;
-            if( diff.assertions.failed > 0 )
-                ++diff.testCases.failed;
-            else if( diff.assertions.failedButOk > 0 )
-                ++diff.testCases.failedButOk;
-            else
-                ++diff.testCases.passed;
-            return diff;
-        }
-
-        Totals& operator += ( Totals const& other ) {
-            assertions += other.assertions;
-            testCases += other.testCases;
-            return *this;
-        }
+        Totals delta( Totals const& prevTotals ) const;
 
+        int error = 0;
         Counts assertions;
         Counts testCases;
     };
 }
 
+// end catch_totals.h
 #include <string>
 
 namespace Catch {
 
     struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
         SectionInfo
             (   SourceLineInfo const& _lineInfo,
                 std::string const& _name,
-                std::string const& _description = std::string() );
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
 
         std::string name;
-        std::string description;
+        std::string description; // !Deprecated: this will always be empty
         SourceLineInfo lineInfo;
     };
 
     struct SectionEndInfo {
-        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
-        : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
-        {}
-
         SectionInfo sectionInfo;
         Counts prevAssertions;
         double durationInSeconds;
@@ -2435,36 +2881,29 @@ namespace Catch {
 
 } // end namespace Catch
 
-// #included from: catch_timer.h
-#define TWOBLUECUBES_CATCH_TIMER_H_INCLUDED
+// end catch_section_info.h
+// start catch_timer.h
 
-#ifdef _MSC_VER
+#include <cstdint>
 
 namespace Catch {
-    typedef unsigned long long UInt64;
-}
-#else
-#include <stdint.h>
-namespace Catch {
-    typedef uint64_t UInt64;
-}
-#endif
 
-namespace Catch {
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t;
+    auto getEstimatedClockResolution() -> uint64_t;
+
     class Timer {
+        uint64_t m_nanoseconds = 0;
     public:
-        Timer() : m_ticks( 0 ) {}
         void start();
-        unsigned int getElapsedMicroseconds() const;
-        unsigned int getElapsedMilliseconds() const;
-        double getElapsedSeconds() const;
-
-    private:
-        UInt64 m_ticks;
+        auto getElapsedNanoseconds() const -> uint64_t;
+        auto getElapsedMicroseconds() const -> uint64_t;
+        auto getElapsedMilliseconds() const -> unsigned int;
+        auto getElapsedSeconds() const -> double;
     };
 
 } // namespace Catch
 
+// end catch_timer.h
 #include <string>
 
 namespace Catch {
@@ -2475,7 +2914,7 @@ namespace Catch {
         ~Section();
 
         // This indicates whether the section should be executed or not
-        operator bool() const;
+        explicit operator bool() const;
 
     private:
         SectionInfo m_info;
@@ -2488,203 +2927,25 @@ namespace Catch {
 
 } // end namespace Catch
 
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define INTERNAL_CATCH_SECTION( ... ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
-#else
-    #define INTERNAL_CATCH_SECTION( name, desc ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, name, desc ) )
-#endif
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-// #included from: internal/catch_generators.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_HPP_INCLUDED
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-#include <vector>
-#include <string>
-#include <stdlib.h>
+// end catch_section.h
+// start catch_interfaces_exception.h
 
-namespace Catch {
-
-template<typename T>
-struct IGenerator {
-    virtual ~IGenerator() {}
-    virtual T getValue( std::size_t index ) const = 0;
-    virtual std::size_t size () const = 0;
-};
-
-template<typename T>
-class BetweenGenerator : public IGenerator<T> {
-public:
-    BetweenGenerator( T from, T to ) : m_from( from ), m_to( to ){}
-
-    virtual T getValue( std::size_t index ) const {
-        return m_from+static_cast<int>( index );
-    }
-
-    virtual std::size_t size() const {
-        return static_cast<std::size_t>( 1+m_to-m_from );
-    }
-
-private:
-
-    T m_from;
-    T m_to;
-};
-
-template<typename T>
-class ValuesGenerator : public IGenerator<T> {
-public:
-    ValuesGenerator(){}
-
-    void add( T value ) {
-        m_values.push_back( value );
-    }
-
-    virtual T getValue( std::size_t index ) const {
-        return m_values[index];
-    }
-
-    virtual std::size_t size() const {
-        return m_values.size();
-    }
-
-private:
-    std::vector<T> m_values;
-};
-
-template<typename T>
-class CompositeGenerator {
-public:
-    CompositeGenerator() : m_totalSize( 0 ) {}
-
-    // *** Move semantics, similar to auto_ptr ***
-    CompositeGenerator( CompositeGenerator& other )
-    :   m_fileInfo( other.m_fileInfo ),
-        m_totalSize( 0 )
-    {
-        move( other );
-    }
-
-    CompositeGenerator& setFileInfo( const char* fileInfo ) {
-        m_fileInfo = fileInfo;
-        return *this;
-    }
-
-    ~CompositeGenerator() {
-        deleteAll( m_composed );
-    }
-
-    operator T () const {
-        size_t overallIndex = getCurrentContext().getGeneratorIndex( m_fileInfo, m_totalSize );
-
-        typename std::vector<const IGenerator<T>*>::const_iterator it = m_composed.begin();
-        typename std::vector<const IGenerator<T>*>::const_iterator itEnd = m_composed.end();
-        for( size_t index = 0; it != itEnd; ++it )
-        {
-            const IGenerator<T>* generator = *it;
-            if( overallIndex >= index && overallIndex < index + generator->size() )
-            {
-                return generator->getValue( overallIndex-index );
-            }
-            index += generator->size();
-        }
-        CATCH_INTERNAL_ERROR( "Indexed past end of generated range" );
-        return T(); // Suppress spurious "not all control paths return a value" warning in Visual Studio - if you know how to fix this please do so
-    }
-
-    void add( const IGenerator<T>* generator ) {
-        m_totalSize += generator->size();
-        m_composed.push_back( generator );
-    }
-
-    CompositeGenerator& then( CompositeGenerator& other ) {
-        move( other );
-        return *this;
-    }
-
-    CompositeGenerator& then( T value ) {
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( value );
-        add( valuesGen );
-        return *this;
-    }
-
-private:
-
-    void move( CompositeGenerator& other ) {
-        m_composed.insert( m_composed.end(), other.m_composed.begin(), other.m_composed.end() );
-        m_totalSize += other.m_totalSize;
-        other.m_composed.clear();
-    }
-
-    std::vector<const IGenerator<T>*> m_composed;
-    std::string m_fileInfo;
-    size_t m_totalSize;
-};
-
-namespace Generators
-{
-    template<typename T>
-    CompositeGenerator<T> between( T from, T to ) {
-        CompositeGenerator<T> generators;
-        generators.add( new BetweenGenerator<T>( from, to ) );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3 ){
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-    template<typename T>
-    CompositeGenerator<T> values( T val1, T val2, T val3, T val4 ) {
-        CompositeGenerator<T> generators;
-        ValuesGenerator<T>* valuesGen = new ValuesGenerator<T>();
-        valuesGen->add( val1 );
-        valuesGen->add( val2 );
-        valuesGen->add( val3 );
-        valuesGen->add( val4 );
-        generators.add( valuesGen );
-        return generators;
-    }
-
-} // end namespace Generators
-
-using namespace Generators;
-
-} // end namespace Catch
-
-#define INTERNAL_CATCH_LINESTR2( line ) #line
-#define INTERNAL_CATCH_LINESTR( line ) INTERNAL_CATCH_LINESTR2( line )
-
-#define INTERNAL_CATCH_GENERATE( expr ) expr.setFileInfo( __FILE__ "(" INTERNAL_CATCH_LINESTR( __LINE__ ) ")" )
-
-// #included from: internal/catch_interfaces_exception.h
-#define TWOBLUECUBES_CATCH_INTERFACES_EXCEPTION_H_INCLUDED
-
-#include <string>
-#include <vector>
-
-// #included from: catch_interfaces_registry_hub.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REGISTRY_HUB_H_INCLUDED
+// start catch_interfaces_registry_hub.h
 
 #include <string>
+#include <memory>
 
 namespace Catch {
 
@@ -2695,6 +2956,11 @@ namespace Catch {
     struct IReporterRegistry;
     struct IReporterFactory;
     struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
+    class StartupExceptionRegistry;
+
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
 
     struct IRegistryHub {
         virtual ~IRegistryHub();
@@ -2702,32 +2968,44 @@ namespace Catch {
         virtual IReporterRegistry const& getReporterRegistry() const = 0;
         virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
         virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
 
-        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+        virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
     };
 
     struct IMutableRegistryHub {
         virtual ~IMutableRegistryHub();
-        virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) = 0;
-        virtual void registerListener( Ptr<IReporterFactory> const& factory ) = 0;
+        virtual void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) = 0;
+        virtual void registerListener( IReporterFactoryPtr const& factory ) = 0;
         virtual void registerTest( TestCase const& testInfo ) = 0;
         virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
         virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+        virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
     };
 
-    IRegistryHub& getRegistryHub();
+    IRegistryHub const& getRegistryHub();
     IMutableRegistryHub& getMutableRegistryHub();
     void cleanUp();
     std::string translateActiveException();
 
 }
 
-namespace Catch {
+// end catch_interfaces_registry_hub.h
+#if defined(CATCH_CONFIG_DISABLE)
+    #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+        static std::string translatorName( signature )
+#endif
 
-    typedef std::string(*exceptionTranslateFunction)();
+#include <exception>
+#include <string>
+#include <vector>
+
+namespace Catch {
+    using exceptionTranslateFunction = std::string(*)();
 
     struct IExceptionTranslator;
-    typedef std::vector<const IExceptionTranslator*> ExceptionTranslators;
+    using ExceptionTranslators = std::vector<std::unique_ptr<IExceptionTranslator const>>;
 
     struct IExceptionTranslator {
         virtual ~IExceptionTranslator();
@@ -2749,16 +3027,20 @@ namespace Catch {
             : m_translateFunction( translateFunction )
             {}
 
-            virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const CATCH_OVERRIDE {
+            std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                return "";
+#else
                 try {
                     if( it == itEnd )
-                        throw;
+                        std::rethrow_exception(std::current_exception());
                     else
                         return (*it)->translate( it+1, itEnd );
                 }
                 catch( T& ex ) {
                     return m_translateFunction( ex );
                 }
+#endif
             }
 
         protected:
@@ -2777,62 +3059,56 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
     static std::string translatorName( signature ); \
-    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); }\
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+    namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
     static std::string translatorName( signature )
 
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
 
-// #included from: internal/catch_approx.hpp
-#define TWOBLUECUBES_CATCH_APPROX_HPP_INCLUDED
+// end catch_interfaces_exception.h
+// start catch_approx.h
 
-#include <cmath>
-#include <limits>
-
-#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
 #include <type_traits>
-#endif
 
 namespace Catch {
 namespace Detail {
 
     class Approx {
+    private:
+        bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
+
     public:
-        explicit Approx ( double value )
-        :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
-            m_margin( 0.0 ),
-            m_scale( 1.0 ),
-            m_value( value )
-        {}
+        explicit Approx ( double value );
 
-        static Approx custom() {
-            return Approx( 0 );
-        }
+        static Approx custom();
 
-#if defined(CATCH_CONFIG_CPP11_TYPE_TRAITS)
+        Approx operator-() const;
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx operator()( T value ) {
+        Approx operator()( T const& value ) const {
             Approx approx( static_cast<double>(value) );
-            approx.epsilon( m_epsilon );
-            approx.margin( m_margin );
-            approx.scale( m_scale );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
             return approx;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        explicit Approx( T value ): Approx(static_cast<double>(value))
+        explicit Approx( T const& value ): Approx(static_cast<double>(value))
         {}
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
         friend bool operator == ( const T& lhs, Approx const& rhs ) {
-            // Thanks to Richard Harris for his help refining this formula
-            auto lhs_v = double(lhs);
-            bool relativeOK = std::fabs(lhs_v - rhs.m_value) < rhs.m_epsilon * (rhs.m_scale + (std::max)(std::fabs(lhs_v), std::fabs(rhs.m_value)));
-            if (relativeOK) {
-                return true;
-            }
-
-            return std::fabs(lhs_v - rhs.m_value) <= rhs.m_margin;
+            auto lhs_v = static_cast<double>(lhs);
+            return rhs.equalityComparisonImpl(lhs_v);
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
@@ -2841,121 +3117,56 @@ namespace Detail {
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( T lhs, Approx const& rhs ) {
+        friend bool operator != ( T const& lhs, Approx const& rhs ) {
             return !operator==( lhs, rhs );
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator != ( Approx const& lhs, T rhs ) {
+        friend bool operator != ( Approx const& lhs, T const& rhs ) {
             return !operator==( rhs, lhs );
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( T lhs, Approx const& rhs ) {
-            return double(lhs) < rhs.m_value || lhs == rhs;
+        friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator <= ( Approx const& lhs, T rhs ) {
-            return lhs.m_value < double(rhs) || lhs == rhs;
+        friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( T lhs, Approx const& rhs ) {
-            return double(lhs) > rhs.m_value || lhs == rhs;
+        friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+            return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        friend bool operator >= ( Approx const& lhs, T rhs ) {
-            return lhs.m_value > double(rhs) || lhs == rhs;
+        friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+            return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& epsilon( T newEpsilon ) {
-            m_epsilon = double(newEpsilon);
+        Approx& epsilon( T const& newEpsilon ) {
+            double epsilonAsDouble = static_cast<double>(newEpsilon);
+            setEpsilon(epsilonAsDouble);
             return *this;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& margin( T newMargin ) {
-            m_margin = double(newMargin);
+        Approx& margin( T const& newMargin ) {
+            double marginAsDouble = static_cast<double>(newMargin);
+            setMargin(marginAsDouble);
             return *this;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
-        Approx& scale( T newScale ) {
-            m_scale = double(newScale);
+        Approx& scale( T const& newScale ) {
+            m_scale = static_cast<double>(newScale);
             return *this;
         }
 
-#else
-
-        Approx operator()( double value ) {
-            Approx approx( value );
-            approx.epsilon( m_epsilon );
-            approx.margin( m_margin );
-            approx.scale( m_scale );
-            return approx;
-        }
-
-        friend bool operator == ( double lhs, Approx const& rhs ) {
-            // Thanks to Richard Harris for his help refining this formula
-            bool relativeOK = std::fabs( lhs - rhs.m_value ) < rhs.m_epsilon * (rhs.m_scale + (std::max)( std::fabs(lhs), std::fabs(rhs.m_value) ) );
-            if (relativeOK) {
-                return true;
-            }
-            return std::fabs(lhs - rhs.m_value) <= rhs.m_margin;
-        }
-
-        friend bool operator == ( Approx const& lhs, double rhs ) {
-            return operator==( rhs, lhs );
-        }
-
-        friend bool operator != ( double lhs, Approx const& rhs ) {
-            return !operator==( lhs, rhs );
-        }
-
-        friend bool operator != ( Approx const& lhs, double rhs ) {
-            return !operator==( rhs, lhs );
-        }
-
-        friend bool operator <= ( double lhs, Approx const& rhs ) {
-            return lhs < rhs.m_value || lhs == rhs;
-        }
-
-        friend bool operator <= ( Approx const& lhs, double rhs ) {
-            return lhs.m_value < rhs || lhs == rhs;
-        }
-
-        friend bool operator >= ( double lhs, Approx const& rhs ) {
-            return lhs > rhs.m_value || lhs == rhs;
-        }
-
-        friend bool operator >= ( Approx const& lhs, double rhs ) {
-            return lhs.m_value > rhs || lhs == rhs;
-        }
-
-        Approx& epsilon( double newEpsilon ) {
-            m_epsilon = newEpsilon;
-            return *this;
-        }
-
-        Approx& margin( double newMargin ) {
-            m_margin = newMargin;
-            return *this;
-        }
-
-        Approx& scale( double newScale ) {
-            m_scale = newScale;
-            return *this;
-        }
-#endif
-
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << "Approx( " << Catch::toString( m_value ) << " )";
-            return oss.str();
-        }
+        std::string toString() const;
 
     private:
         double m_epsilon;
@@ -2963,17 +3174,361 @@ namespace Detail {
         double m_scale;
         double m_value;
     };
-}
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
 
 template<>
-inline std::string toString<Detail::Approx>( Detail::Approx const& value ) {
-    return value.toString();
-}
+struct StringMaker<Catch::Detail::Approx> {
+    static std::string convert(Catch::Detail::Approx const& value);
+};
 
 } // end namespace Catch
 
-// #included from: internal/catch_matchers_string.h
-#define TWOBLUECUBES_CATCH_MATCHERS_STRING_H_INCLUDED
+// end catch_approx.h
+// start catch_string_manip.h
+
+#include <string>
+#include <iosfwd>
+#include <vector>
+
+namespace Catch {
+
+    bool startsWith( std::string const& s, std::string const& prefix );
+    bool startsWith( std::string const& s, char prefix );
+    bool endsWith( std::string const& s, std::string const& suffix );
+    bool endsWith( std::string const& s, char suffix );
+    bool contains( std::string const& s, std::string const& infix );
+    void toLowerInPlace( std::string& s );
+    std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
+    std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+
+    struct pluralise {
+        pluralise( std::size_t count, std::string const& label );
+
+        friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+
+        std::size_t m_count;
+        std::string m_label;
+    };
+}
+
+// end catch_string_manip.h
+#ifndef CATCH_CONFIG_DISABLE_MATCHERS
+// start catch_capture_matchers.h
+
+// start catch_matchers.h
+
+#include <string>
+#include <vector>
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        template<typename ArgT> struct MatchAllOf;
+        template<typename ArgT> struct MatchAnyOf;
+        template<typename ArgT> struct MatchNotOf;
+
+        class MatcherUntypedBase {
+        public:
+            MatcherUntypedBase() = default;
+            MatcherUntypedBase ( MatcherUntypedBase const& ) = default;
+            MatcherUntypedBase& operator = ( MatcherUntypedBase const& ) = delete;
+            std::string toString() const;
+
+        protected:
+            virtual ~MatcherUntypedBase();
+            virtual std::string describe() const = 0;
+            mutable std::string m_cachedToString;
+        };
+
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+        template<typename ObjectT>
+        struct MatcherMethod {
+            virtual bool match( ObjectT const& arg ) const = 0;
+        };
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
+        };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
+
+        template<typename T>
+        struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
+
+            MatchAllOf<T> operator && ( MatcherBase const& other ) const;
+            MatchAnyOf<T> operator || ( MatcherBase const& other ) const;
+            MatchNotOf<T> operator ! () const;
+        };
+
+        template<typename ArgT>
+        struct MatchAllOf : MatcherBase<ArgT> {
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (!matcher->match(arg))
+                        return false;
+                }
+                return true;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " and ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+        template<typename ArgT>
+        struct MatchAnyOf : MatcherBase<ArgT> {
+
+            bool match( ArgT const& arg ) const override {
+                for( auto matcher : m_matchers ) {
+                    if (matcher->match(arg))
+                        return true;
+                }
+                return false;
+            }
+            std::string describe() const override {
+                std::string description;
+                description.reserve( 4 + m_matchers.size()*32 );
+                description += "( ";
+                bool first = true;
+                for( auto matcher : m_matchers ) {
+                    if( first )
+                        first = false;
+                    else
+                        description += " or ";
+                    description += matcher->toString();
+                }
+                description += " )";
+                return description;
+            }
+
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
+            }
+
+            std::vector<MatcherBase<ArgT> const*> m_matchers;
+        };
+
+        template<typename ArgT>
+        struct MatchNotOf : MatcherBase<ArgT> {
+
+            MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ) : m_underlyingMatcher( underlyingMatcher ) {}
+
+            bool match( ArgT const& arg ) const override {
+                return !m_underlyingMatcher.match( arg );
+            }
+
+            std::string describe() const override {
+                return "not " + m_underlyingMatcher.toString();
+            }
+            MatcherBase<ArgT> const& m_underlyingMatcher;
+        };
+
+        template<typename T>
+        MatchAllOf<T> MatcherBase<T>::operator && ( MatcherBase const& other ) const {
+            return MatchAllOf<T>() && *this && other;
+        }
+        template<typename T>
+        MatchAnyOf<T> MatcherBase<T>::operator || ( MatcherBase const& other ) const {
+            return MatchAnyOf<T>() || *this || other;
+        }
+        template<typename T>
+        MatchNotOf<T> MatcherBase<T>::operator ! () const {
+            return MatchNotOf<T>( *this );
+        }
+
+    } // namespace Impl
+
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+
+// end catch_matchers.h
+// start catch_matchers_exception.hpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
+
+namespace Catch {
+namespace Matchers {
+
+    namespace Floating {
+
+        enum class FloatingPointKind : uint8_t;
+
+        struct WithinAbsMatcher : MatcherBase<double> {
+            WithinAbsMatcher(double target, double margin);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_margin;
+        };
+
+        struct WithinUlpsMatcher : MatcherBase<double> {
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            uint64_t m_ulps;
+            FloatingPointKind m_type;
+        };
+
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
+    } // namespace Floating
+
+    // The following functions create the actual matcher objects.
+    // This allows the types to be inferred
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+    Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_floating.h
+// start catch_matchers_generic.hpp
+
+#include <functional>
+#include <string>
+
+namespace Catch {
+namespace Matchers {
+namespace Generic {
+
+namespace Detail {
+    std::string finalizeDescription(const std::string& desc);
+}
+
+template <typename T>
+class PredicateMatcher : public MatcherBase<T> {
+    std::function<bool(T const&)> m_predicate;
+    std::string m_description;
+public:
+
+    PredicateMatcher(std::function<bool(T const&)> const& elem, std::string const& descr)
+        :m_predicate(std::move(elem)),
+        m_description(Detail::finalizeDescription(descr))
+    {}
+
+    bool match( T const& item ) const override {
+        return m_predicate(item);
+    }
+
+    std::string describe() const override {
+        return m_description;
+    }
+};
+
+} // namespace Generic
+
+    // The following functions create the actual matcher objects.
+    // The user has to explicitly specify type to the function, because
+    // inferring std::function<bool(T const&)> is hard (but possible) and
+    // requires a lot of TMP.
+    template<typename T>
+    Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
+        return Generic::PredicateMatcher<T>(predicate, description);
+    }
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_generic.hpp
+// start catch_matchers_string.h
+
+#include <string>
 
 namespace Catch {
 namespace Matchers {
@@ -2992,7 +3547,7 @@ namespace Matchers {
 
         struct StringMatcherBase : MatcherBase<std::string> {
             StringMatcherBase( std::string const& operation, CasedString const& comparator );
-            virtual std::string describe() const CATCH_OVERRIDE;
+            std::string describe() const override;
 
             CasedString m_comparator;
             std::string m_operation;
@@ -3000,19 +3555,29 @@ namespace Matchers {
 
         struct EqualsMatcher : StringMatcherBase {
             EqualsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+            bool match( std::string const& source ) const override;
         };
         struct ContainsMatcher : StringMatcherBase {
             ContainsMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+            bool match( std::string const& source ) const override;
         };
         struct StartsWithMatcher : StringMatcherBase {
             StartsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+            bool match( std::string const& source ) const override;
         };
         struct EndsWithMatcher : StringMatcherBase {
             EndsWithMatcher( CasedString const& comparator );
-            virtual bool match( std::string const& source ) const CATCH_OVERRIDE;
+            bool match( std::string const& source ) const override;
+        };
+
+        struct RegexMatcher : MatcherBase<std::string> {
+            RegexMatcher( std::string regex, CaseSensitive::Choice caseSensitivity );
+            bool match( std::string const& matchee ) const override;
+            std::string describe() const override;
+
+        private:
+            std::string m_regex;
+            CaseSensitive::Choice m_caseSensitivity;
         };
 
     } // namespace StdString
@@ -3024,76 +3589,145 @@ namespace Matchers {
     StdString::ContainsMatcher Contains( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
     StdString::EndsWithMatcher EndsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
     StdString::StartsWithMatcher StartsWith( std::string const& str, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
+    StdString::RegexMatcher Matches( std::string const& regex, CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes );
 
 } // namespace Matchers
 } // namespace Catch
 
-// #included from: internal/catch_matchers_vector.h
-#define TWOBLUECUBES_CATCH_MATCHERS_VECTOR_H_INCLUDED
+// end catch_matchers_string.h
+// start catch_matchers_vector.h
+
+#include <algorithm>
 
 namespace Catch {
 namespace Matchers {
 
     namespace Vector {
-
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>, T> {
+        template<typename T, typename Alloc>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
 
             ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
 
-            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
-                return std::find(v.begin(), v.end(), m_comparator) != v.end();
+            bool match(std::vector<T, Alloc> const &v) const override {
+                for (auto const& el : v) {
+                    if (el == m_comparator) {
+                        return true;
+                    }
+                }
+                return false;
             }
 
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Contains: " + Catch::toString( m_comparator );
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
             }
 
             T const& m_comparator;
         };
 
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
 
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+            ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
 
-            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+            bool match(std::vector<T, AllocMatch> const &v) const override {
                 // !TBD: see note in EqualsMatcher
                 if (m_comparator.size() > v.size())
                     return false;
-                for (size_t i = 0; i < m_comparator.size(); ++i)
-                    if (std::find(v.begin(), v.end(), m_comparator[i]) == v.end())
+                for (auto const& comparator : m_comparator) {
+                    auto present = false;
+                    for (const auto& el : v) {
+                        if (el == comparator) {
+                            present = true;
+                            break;
+                        }
+                    }
+                    if (!present) {
                         return false;
+                    }
+                }
                 return true;
             }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Contains: " + Catch::toString( m_comparator );
+            std::string describe() const override {
+                return "Contains: " + ::Catch::Detail::stringify( m_comparator );
             }
 
-            std::vector<T> const& m_comparator;
+            std::vector<T, AllocComp> const& m_comparator;
         };
 
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>, std::vector<T> > {
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
 
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+            EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
 
-            bool match(std::vector<T> const &v) const CATCH_OVERRIDE {
+            bool match(std::vector<T, AllocMatch> const &v) const override {
                 // !TBD: This currently works if all elements can be compared using !=
                 // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // to using !=. but could be specialised for, e.g. std::vector<T, Alloc> etc
                 // - then just call that directly
                 if (m_comparator.size() != v.size())
                     return false;
-                for (size_t i = 0; i < v.size(); ++i)
+                for (std::size_t i = 0; i < v.size(); ++i)
                     if (m_comparator[i] != v[i])
                         return false;
                 return true;
             }
-            virtual std::string describe() const CATCH_OVERRIDE {
-                return "Equals: " + Catch::toString( m_comparator );
+            std::string describe() const override {
+                return "Equals: " + ::Catch::Detail::stringify( m_comparator );
             }
-            std::vector<T> const& m_comparator;
+            std::vector<T, AllocComp> const& m_comparator;
+        };
+
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
+
+            ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_comparator( comparator ) {}
+
+            bool match(std::vector<T, AllocMatch> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
+                return true;
+            }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T, AllocComp> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
+            UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) : m_target(target) {}
+            bool match(std::vector<T, AllocMatch> const& vec) const override {
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
+
+            std::string describe() const override {
+                return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+            }
+        private:
+            std::vector<T, AllocComp> const& m_target;
         };
 
     } // namespace Vector
@@ -3101,50 +3735,672 @@ namespace Matchers {
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
 
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::ContainsMatcher<T, AllocComp, AllocMatch>( comparator );
     }
 
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
+    template<typename T, typename Alloc = std::allocator<T>>
+    Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T, Alloc>( comparator );
     }
 
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::EqualsMatcher<T, AllocComp, AllocMatch>( comparator );
+    }
+
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::ApproxMatcher<T, AllocComp, AllocMatch>( comparator );
+    }
+
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+        return Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch>( target );
     }
 
 } // namespace Matchers
 } // namespace Catch
 
-// #included from: internal/catch_interfaces_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_INTERFACES_TAG_ALIAS_REGISTRY_H_INCLUDED
+// end catch_matchers_vector.h
+namespace Catch {
 
-// #included from: catch_tag_alias.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_H_INCLUDED
+    template<typename ArgT, typename MatcherT>
+    class MatchExpr : public ITransientExpression {
+        ArgT const& m_arg;
+        MatcherT m_matcher;
+        StringRef m_matcherString;
+    public:
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
+        :   ITransientExpression{ true, matcher.match( arg ) },
+            m_arg( arg ),
+            m_matcher( matcher ),
+            m_matcherString( matcherString )
+        {}
 
-#include <string>
+        void streamReconstructedExpression( std::ostream &os ) const override {
+            auto matcherAsString = m_matcher.toString();
+            os << Catch::Detail::stringify( m_arg ) << ' ';
+            if( matcherAsString == Detail::unprintableString )
+                os << m_matcherString;
+            else
+                os << matcherAsString;
+        }
+    };
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
+
+    template<typename ArgT, typename MatcherT>
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+        return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
+    }
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        INTERNAL_CATCH_TRY { \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
+        } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+    do { \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        if( catchAssertionHandler.allowThrows() ) \
+            try { \
+                static_cast<void>(__VA_ARGS__ ); \
+                catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+            } \
+            catch( exceptionType const& ex ) { \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
+            } \
+            catch( ... ) { \
+                catchAssertionHandler.handleUnexpectedInflightException(); \
+            } \
+        else \
+            catchAssertionHandler.handleThrowingCallSkipped(); \
+        INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+    } while( false )
+
+// end catch_capture_matchers.h
+#endif
+// start catch_generators.hpp
+
+// start catch_interfaces_generatortracker.h
+
+
+#include <memory>
 
 namespace Catch {
 
-    struct TagAlias {
-        TagAlias( std::string const& _tag, SourceLineInfo _lineInfo ) : tag( _tag ), lineInfo( _lineInfo ) {}
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
+        };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
 
-        std::string tag;
-        SourceLineInfo lineInfo;
+    } // namespace Generators
+
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
     };
 
-    struct RegistrarForTagAliases {
-        RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+} // namespace Catch
+
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
+
+#include <exception>
+
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
+
+} // namespace Catch;
+
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
+
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
+
+#include <utility>
+#include <exception>
+
+namespace Catch {
+
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
+
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
+
+    const char* what() const noexcept override final;
+};
+
+namespace Generators {
+
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
+
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
     };
 
-} // end namespace Catch
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
 
-#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); }
-// #included from: catch_option.hpp
-#define TWOBLUECUBES_CATCH_OPTION_HPP_INCLUDED
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
+
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
+
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
+    public:
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
+
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
+
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
+
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
+
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
+        }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
+    }
+
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
+
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
+
+    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
+
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
+        }
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+#define GENERATE( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
+
+namespace Catch {
+namespace Generators {
+
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
+
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
+
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = nextImpl();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
+                }
+            }
+        }
+
+        T const& get() const override {
+            return m_generator.get();
+        }
+
+        bool next() override {
+            return nextImpl();
+        }
+
+    private:
+        bool nextImpl() {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
+
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
+
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
+
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
+
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
+
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
+                }
+                return m_current_repeat < m_target_repeats;
+            }
+
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
+
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
+
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
+
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
+
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
+
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
+
+// start catch_context.h
+
+#include <memory>
+
+namespace Catch {
+
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+
+    struct IContext
+    {
+        virtual ~IContext();
+
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
+
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
+
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
+
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
+
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
+
+    void cleanUpContext();
+
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
+
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
 
 namespace Catch {
 
@@ -3152,12 +4408,12 @@ namespace Catch {
     template<typename T>
     class Option {
     public:
-        Option() : nullableValue( CATCH_NULL ) {}
+        Option() : nullableValue( nullptr ) {}
         Option( T const& _value )
         : nullableValue( new( storage ) T( _value ) )
         {}
         Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : CATCH_NULL )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
         {}
 
         ~Option() {
@@ -3181,7 +4437,7 @@ namespace Catch {
         void reset() {
             if( nullableValue )
                 nullableValue->~T();
-            nullableValue = CATCH_NULL;
+            nullableValue = nullptr;
         }
 
         T& operator*() { return *nullableValue; }
@@ -3193,50 +4449,316 @@ namespace Catch {
             return nullableValue ? *nullableValue : defaultValue;
         }
 
-        bool some() const { return nullableValue != CATCH_NULL; }
-        bool none() const { return nullableValue == CATCH_NULL; }
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
 
-        bool operator !() const { return nullableValue == CATCH_NULL; }
-        operator SafeBool::type() const {
-            return SafeBool::makeSafe( some() );
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
         }
 
     private:
         T *nullableValue;
-        union {
-            char storage[sizeof(T)];
-
-            // These are here to force alignment for the storage
-            long double dummy1;
-            void (*dummy2)();
-            long double dummy3;
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-            long long dummy4;
-#endif
-        };
+        alignas(alignof(T)) char storage[sizeof(T)];
     };
 
 } // end namespace Catch
 
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <memory>
+
 namespace Catch {
 
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
 
-        static ITagAliasRegistry const& get();
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
+
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
+
+    class TestSpec;
+
+    struct IConfig : NonCopyable {
+
+        virtual ~IConfig();
+
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual double minDuration() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
+
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+    };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
     };
 
 } // end namespace Catch
 
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
 // These files are included here so the single_include script doesn't put them
 // in the conditionally compiled sections
-// #included from: internal/catch_test_case_info.h
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_H_INCLUDED
+// start catch_test_case_info.h
 
 #include <string>
-#include <set>
+#include <vector>
+#include <memory>
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ -3245,7 +4767,7 @@ namespace Catch {
 
 namespace Catch {
 
-    struct ITestCase;
+    struct ITestInvoker;
 
     struct TestCaseInfo {
         enum SpecialProperties{
@@ -3254,30 +4776,30 @@ namespace Catch {
             ShouldFail = 1 << 2,
             MayFail = 1 << 3,
             Throws = 1 << 4,
-            NonPortable = 1 << 5
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
         };
 
         TestCaseInfo(   std::string const& _name,
                         std::string const& _className,
                         std::string const& _description,
-                        std::set<std::string> const& _tags,
+                        std::vector<std::string> const& _tags,
                         SourceLineInfo const& _lineInfo );
 
-        TestCaseInfo( TestCaseInfo const& other );
-
-        friend void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags );
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
 
         bool isHidden() const;
         bool throws() const;
         bool okToFail() const;
         bool expectedToFail() const;
 
+        std::string tagsAsString() const;
+
         std::string name;
         std::string className;
         std::string description;
-        std::set<std::string> tags;
-        std::set<std::string> lcaseTags;
-        std::string tagsAsString;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
         SourceLineInfo lineInfo;
         SpecialProperties properties;
     };
@@ -3285,8 +4807,7 @@ namespace Catch {
     class TestCase : public TestCaseInfo {
     public:
 
-        TestCase( ITestCase* testCase, TestCaseInfo const& info );
-        TestCase( TestCase const& other );
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
 
         TestCase withName( std::string const& _newName ) const;
 
@@ -3294,19 +4815,16 @@ namespace Catch {
 
         TestCaseInfo const& getTestCaseInfo() const;
 
-        void swap( TestCase& other );
         bool operator == ( TestCase const& other ) const;
         bool operator < ( TestCase const& other ) const;
-        TestCase& operator = ( TestCase const& other );
 
     private:
-        Ptr<ITestCase> test;
+        std::shared_ptr<ITestInvoker> test;
     };
 
-    TestCase makeTestCase(  ITestCase* testCase,
+    TestCase makeTestCase(  ITestInvoker* testCase,
                             std::string const& className,
-                            std::string const& name,
-                            std::string const& description,
+                            NameAndTags const& nameAndTags,
                             SourceLineInfo const& lineInfo );
 }
 
@@ -3314,10 +4832,21 @@ namespace Catch {
 #pragma clang diagnostic pop
 #endif
 
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
 
 #ifdef __OBJC__
-// #included from: internal/catch_objc.hpp
-#define TWOBLUECUBES_CATCH_OBJC_HPP_INCLUDED
+// start catch_objc.hpp
 
 #import <objc/runtime.h>
 
@@ -3341,7 +4870,7 @@ namespace Catch {
 
 namespace Catch {
 
-    class OcMethod : public SharedImpl<ITestCase> {
+    class OcMethod : public ITestInvoker {
 
     public:
         OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
@@ -3377,9 +4906,9 @@ namespace Catch {
         }
     }
 
-    inline size_t registerTestMethods() {
-        size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( CATCH_NULL, 0 );
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
 
         Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
         objc_getClassList( classes, noClasses );
@@ -3398,7 +4927,7 @@ namespace Catch {
                         std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
                         const char* className = class_getName( cls );
 
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo() ) );
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
                         noTestMethods++;
                     }
                 }
@@ -3408,6 +4937,8 @@ namespace Catch {
         return noTestMethods;
     }
 
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
     namespace Matchers {
         namespace Impl {
         namespace NSStringMatchers {
@@ -3419,61 +4950,61 @@ namespace Catch {
                     arcSafeRelease( m_substr );
                 }
 
-                virtual bool match( NSString* arg ) const CATCH_OVERRIDE {
+                bool match( NSString* str ) const override {
                     return false;
                 }
 
-                NSString* m_substr;
+                NSString* CATCH_ARC_STRONG m_substr;
             };
 
             struct Equals : StringHolder {
                 Equals( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const CATCH_OVERRIDE {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str isEqualToString:m_substr];
                 }
 
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "equals string: " + Catch::toString( m_substr );
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
                 }
             };
 
             struct Contains : StringHolder {
                 Contains( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location != NSNotFound;
                 }
 
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "contains string: " + Catch::toString( m_substr );
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
                 }
             };
 
             struct StartsWith : StringHolder {
                 StartsWith( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location == 0;
                 }
 
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "starts with: " + Catch::toString( m_substr );
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
                 }
             };
             struct EndsWith : StringHolder {
                 EndsWith( NSString* substr ) : StringHolder( substr ){}
 
-                virtual bool match( NSString* str ) const {
+                bool match( NSString* str ) const override {
                     return  (str != nil || m_substr == nil ) &&
                             [str rangeOfString:m_substr].location == [str length] - [m_substr length];
                 }
 
-                virtual std::string describe() const CATCH_OVERRIDE {
-                    return "ends with: " + Catch::toString( m_substr );
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
                 }
             };
 
@@ -3496,86 +5027,53 @@ namespace Catch {
 
     using namespace Matchers;
 
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
 } // namespace Catch
 
 ///////////////////////////////////////////////////////////////////////////////
-#define OC_TEST_CASE( name, desc )\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Name_test ) \
-{\
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
 return @ name; \
-}\
-+(NSString*) INTERNAL_CATCH_UNIQUE_NAME( Catch_Description_test ) \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
 { \
 return @ desc; \
 } \
--(void) INTERNAL_CATCH_UNIQUE_NAME( Catch_TestCase_test )
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
 
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
 #endif
 
-#ifdef CATCH_IMPL
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
 
-// !TBD: Move the leak detector code into a separate header
-#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
-#include <crtdbg.h>
-class LeakDetector {
-public:
-    LeakDetector() {
-        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-        flag |= _CRTDBG_LEAK_CHECK_DF;
-        flag |= _CRTDBG_ALLOC_MEM_DF;
-        _CrtSetDbgFlag(flag);
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        // Change this to leaking allocation's number to break there
-        _CrtSetBreakAlloc(-1);
-    }
-};
-#else
-class LeakDetector {};
-#endif
+// start catch_reporter_bases.hpp
 
-LeakDetector leakDetector;
+// start catch_interfaces_reporter.h
 
-// #included from: internal/catch_impl.hpp
-#define TWOBLUECUBES_CATCH_IMPL_HPP_INCLUDED
+// start catch_config.hpp
 
-// Collect all the implementation files together here
-// These are the equivalent of what would usually be cpp files
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wweak-vtables"
-#endif
-
-// #included from: ../catch_session.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_HPP_INCLUDED
-
-// #included from: internal/catch_commandline.hpp
-#define TWOBLUECUBES_CATCH_COMMANDLINE_HPP_INCLUDED
-
-// #included from: catch_config.hpp
-#define TWOBLUECUBES_CATCH_CONFIG_HPP_INCLUDED
-
-// #included from: catch_test_spec_parser.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+// start catch_test_spec_parser.h
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
 
-// #included from: catch_test_spec.hpp
-#define TWOBLUECUBES_CATCH_TEST_SPEC_HPP_INCLUDED
+// start catch_test_spec.h
 
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wpadded"
 #endif
 
-// #included from: catch_wildcard_pattern.hpp
-#define TWOBLUECUBES_CATCH_WILDCARD_PATTERN_HPP_INCLUDED
-
-#include <stdexcept>
+// start catch_wildcard_pattern.h
 
 namespace Catch
 {
@@ -3589,123 +5087,86 @@ namespace Catch
 
     public:
 
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity )
-        :   m_caseSensitivity( caseSensitivity ),
-            m_wildcard( NoWildcard ),
-            m_pattern( adjustCase( pattern ) )
-        {
-            if( startsWith( m_pattern, '*' ) ) {
-                m_pattern = m_pattern.substr( 1 );
-                m_wildcard = WildcardAtStart;
-            }
-            if( endsWith( m_pattern, '*' ) ) {
-                m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
-                m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
-            }
-        }
-        virtual ~WildcardPattern();
-        virtual bool matches( std::string const& str ) const {
-            switch( m_wildcard ) {
-                case NoWildcard:
-                    return m_pattern == adjustCase( str );
-                case WildcardAtStart:
-                    return endsWith( adjustCase( str ), m_pattern );
-                case WildcardAtEnd:
-                    return startsWith( adjustCase( str ), m_pattern );
-                case WildcardAtBothEnds:
-                    return contains( adjustCase( str ), m_pattern );
-            }
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wunreachable-code"
-#endif
-            throw std::logic_error( "Unknown enum" );
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-        }
     private:
-        std::string adjustCase( std::string const& str ) const {
-            return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
-        }
+        std::string normaliseString( std::string const& str ) const;
         CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard;
+        WildcardPosition m_wildcard = NoWildcard;
         std::string m_pattern;
     };
 }
 
+// end catch_wildcard_pattern.h
 #include <string>
 #include <vector>
+#include <memory>
 
 namespace Catch {
 
+    struct IConfig;
+
     class TestSpec {
-        struct Pattern : SharedImpl<> {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
             virtual ~Pattern();
             virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
         };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
         class NamePattern : public Pattern {
         public:
-            NamePattern( std::string const& name )
-            : m_wildcardPattern( toLower( name ), CaseSensitive::No )
-            {}
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                return m_wildcardPattern.matches( toLower( testCase.name ) );
-            }
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
         private:
             WildcardPattern m_wildcardPattern;
         };
 
         class TagPattern : public Pattern {
         public:
-            TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const {
-                return testCase.lcaseTags.find( m_tag ) != testCase.lcaseTags.end();
-            }
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
         private:
             std::string m_tag;
         };
 
         class ExcludedPattern : public Pattern {
         public:
-            ExcludedPattern( Ptr<Pattern> const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
         private:
-            Ptr<Pattern> m_underlyingPattern;
+            PatternPtr m_underlyingPattern;
         };
 
         struct Filter {
-            std::vector<Ptr<Pattern> > m_patterns;
+            std::vector<PatternPtr> m_patterns;
 
-            bool matches( TestCaseInfo const& testCase ) const {
-                // All patterns in a filter must match for the filter to be a match
-                for( std::vector<Ptr<Pattern> >::const_iterator it = m_patterns.begin(), itEnd = m_patterns.end(); it != itEnd; ++it ) {
-                    if( !(*it)->matches( testCase ) )
-                        return false;
-                }
-                return true;
-            }
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
         };
 
     public:
-        bool hasFilters() const {
-            return !m_filters.empty();
-        }
-        bool matches( TestCaseInfo const& testCase ) const {
-            // A TestSpec matches if any filter matches
-            for( std::vector<Filter>::const_iterator it = m_filters.begin(), itEnd = m_filters.end(); it != itEnd; ++it )
-                if( it->matches( testCase ) )
-                    return true;
-            return false;
-        }
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
 
     private:
         std::vector<Filter> m_filters;
-
+        std::vector<std::string> m_invalidArgs;
         friend class TestSpecParser;
     };
 }
@@ -3714,112 +5175,79 @@ namespace Catch {
 #pragma clang diagnostic pop
 #endif
 
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
 namespace Catch {
 
     class TestSpecParser {
         enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode;
-        bool m_exclusion;
-        std::size_t m_start, m_pos;
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
         std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
         std::vector<std::size_t> m_escapeChars;
         TestSpec::Filter m_currentFilter;
         TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
 
     public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases ) :m_mode(None), m_exclusion(false), m_start(0), m_pos(0), m_tagAliases( &tagAliases ) {}
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
 
-        TestSpecParser& parse( std::string const& arg ) {
-            m_mode = None;
-            m_exclusion = false;
-            m_start = std::string::npos;
-            m_arg = m_tagAliases->expandAliases( arg );
-            m_escapeChars.clear();
-            for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-                visitChar( m_arg[m_pos] );
-            if( m_mode == Name )
-                addPattern<TestSpec::NamePattern>();
-            return *this;
-        }
-        TestSpec testSpec() {
-            addFilter();
-            return m_testSpec;
-        }
     private:
-        void visitChar( char c ) {
-            if( m_mode == None ) {
-                switch( c ) {
-                case ' ': return;
-                case '~': m_exclusion = true; return;
-                case '[': return startNewMode( Tag, ++m_pos );
-                case '"': return startNewMode( QuotedName, ++m_pos );
-                case '\\': return escape();
-                default: startNewMode( Name, m_pos ); break;
-                }
-            }
-            if( m_mode == Name ) {
-                if( c == ',' ) {
-                    addPattern<TestSpec::NamePattern>();
-                    addFilter();
-                }
-                else if( c == '[' ) {
-                    if( subString() == "exclude:" )
-                        m_exclusion = true;
-                    else
-                        addPattern<TestSpec::NamePattern>();
-                    startNewMode( Tag, ++m_pos );
-                }
-                else if( c == '\\' )
-                    escape();
-            }
-            else if( m_mode == EscapedName )
-                m_mode = Name;
-            else if( m_mode == QuotedName && c == '"' )
-                addPattern<TestSpec::NamePattern>();
-            else if( m_mode == Tag && c == ']' )
-                addPattern<TestSpec::TagPattern>();
-        }
-        void startNewMode( Mode mode, std::size_t start ) {
-            m_mode = mode;
-            m_start = start;
-        }
-        void escape() {
-            if( m_mode == None )
-                m_start = m_pos;
-            m_mode = EscapedName;
-            m_escapeChars.push_back( m_pos );
-        }
-        std::string subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
-            }
-            if( !token.empty() ) {
-                Ptr<TestSpec::Pattern> pattern = new T( token );
-                if( m_exclusion )
-                    pattern = new TestSpec::ExcludedPattern( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
-            }
-            m_exclusion = false;
-            m_mode = None;
-        }
-        void addFilter() {
-            if( !m_currentFilter.m_patterns.empty() ) {
-                m_testSpec.m_filters.push_back( m_currentFilter );
-                m_currentFilter = TestSpec::Filter();
-            }
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
         }
+
     };
-    inline TestSpec parseTestSpec( std::string const& arg ) {
-        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
-    }
+    TestSpec parseTestSpec( std::string const& arg );
 
 } // namespace Catch
 
@@ -3827,139 +5255,12 @@ namespace Catch {
 #pragma clang diagnostic pop
 #endif
 
-// #included from: catch_interfaces_config.h
-#define TWOBLUECUBES_CATCH_INTERFACES_CONFIG_H_INCLUDED
-
-#include <iosfwd>
-#include <string>
-#include <vector>
-
-namespace Catch {
-
-    struct Verbosity { enum Level {
-        NoOutput = 0,
-        Quiet,
-        Normal
-    }; };
-
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : IShared {
-
-        virtual ~IConfig();
-
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-
-    };
-}
-
-// #included from: catch_stream.h
-#define TWOBLUECUBES_CATCH_STREAM_H_INCLUDED
-
-// #included from: catch_streambuf.h
-#define TWOBLUECUBES_CATCH_STREAMBUF_H_INCLUDED
-
-#include <streambuf>
-
-namespace Catch {
-
-    class StreamBufBase : public std::streambuf {
-    public:
-        virtual ~StreamBufBase() CATCH_NOEXCEPT;
-    };
-}
-
-#include <streambuf>
-#include <ostream>
-#include <fstream>
-#include <memory>
-
-namespace Catch {
-
-    std::ostream& cout();
-    std::ostream& cerr();
-    std::ostream& clog();
-
-    struct IStream {
-        virtual ~IStream() CATCH_NOEXCEPT;
-        virtual std::ostream& stream() const = 0;
-    };
-
-    class FileStream : public IStream {
-        mutable std::ofstream m_ofs;
-    public:
-        FileStream( std::string const& filename );
-        virtual ~FileStream() CATCH_NOEXCEPT;
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-
-    class CoutStream : public IStream {
-        mutable std::ostream m_os;
-    public:
-        CoutStream();
-        virtual ~CoutStream() CATCH_NOEXCEPT;
-
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-
-    class DebugOutStream : public IStream {
-        CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
-        mutable std::ostream m_os;
-    public:
-        DebugOutStream();
-        virtual ~DebugOutStream() CATCH_NOEXCEPT;
-
-    public: // IStream
-        virtual std::ostream& stream() const CATCH_OVERRIDE;
-    };
-}
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
 
 #include <memory>
 #include <vector>
 #include <string>
-#include <stdexcept>
 
 #ifndef CATCH_CONFIG_CONSOLE_WIDTH
 #define CATCH_CONFIG_CONSOLE_WIDTH 80
@@ -3967,1583 +5268,722 @@ namespace Catch {
 
 namespace Catch {
 
+    struct IStream;
+
     struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
 
-        ConfigData()
-        :   listTests( false ),
-            listTags( false ),
-            listReporters( false ),
-            listTestNamesOnly( false ),
-            listExtraInfo( false ),
-            showSuccessfulTests( false ),
-            shouldDebugBreak( false ),
-            noThrow( false ),
-            showHelp( false ),
-            showInvisibles( false ),
-            filenamesAsTags( false ),
-            libIdentify( false ),
-            abortAfter( -1 ),
-            rngSeed( 0 ),
-            verbosity( Verbosity::Normal ),
-            warnings( WarnAbout::Nothing ),
-            showDurations( ShowDurations::DefaultForReporter ),
-            runOrder( RunTests::InDeclarationOrder ),
-            useColour( UseColour::Auto ),
-            waitForKeypress( WaitForKeypress::Never )
-        {}
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
 
-        bool listTests;
-        bool listTags;
-        bool listReporters;
-        bool listTestNamesOnly;
-        bool listExtraInfo;
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
 
-        bool showSuccessfulTests;
-        bool shouldDebugBreak;
-        bool noThrow;
-        bool showHelp;
-        bool showInvisibles;
-        bool filenamesAsTags;
-        bool libIdentify;
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
 
-        int abortAfter;
-        unsigned int rngSeed;
-
-        Verbosity::Level verbosity;
-        WarnAbout::What warnings;
-        ShowDurations::OrNot showDurations;
-        RunTests::InWhatOrder runOrder;
-        UseColour::YesOrNo useColour;
-        WaitForKeypress::When waitForKeypress;
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        double minDuration = -1;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
 
         std::string outputFilename;
         std::string name;
         std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
 
-        std::vector<std::string> reporterNames;
         std::vector<std::string> testsOrTags;
         std::vector<std::string> sectionsToRun;
     };
 
-    class Config : public SharedImpl<IConfig> {
-    private:
-        Config( Config const& other );
-        Config& operator = ( Config const& other );
-        virtual void dummy();
+    class Config : public IConfig {
     public:
 
-        Config()
-        {}
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
 
-        Config( ConfigData const& data )
-        :   m_data( data ),
-            m_stream( openStream() )
-        {
-            if( !data.testsOrTags.empty() ) {
-                TestSpecParser parser( ITagAliasRegistry::get() );
-                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
-                    parser.parse( data.testsOrTags[i] );
-                m_testSpec = parser.testSpec();
-            }
-        }
+        std::string const& getFilename() const;
 
-        virtual ~Config() {}
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
 
-        std::string const& getFilename() const {
-            return m_data.outputFilename ;
-        }
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
 
-        bool listTests() const { return m_data.listTests; }
-        bool listTestNamesOnly() const { return m_data.listTestNamesOnly; }
-        bool listTags() const { return m_data.listTags; }
-        bool listReporters() const { return m_data.listReporters; }
-        bool listExtraInfo() const { return m_data.listExtraInfo; }
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
 
-        std::string getProcessName() const { return m_data.processName; }
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
 
-        std::vector<std::string> const& getReporterNames() const { return m_data.reporterNames; }
-        std::vector<std::string> const& getSectionsToRun() const CATCH_OVERRIDE { return m_data.sectionsToRun; }
-
-        virtual TestSpec const& testSpec() const CATCH_OVERRIDE { return m_testSpec; }
-
-        bool showHelp() const { return m_data.showHelp; }
+        bool showHelp() const;
 
         // IConfig interface
-        virtual bool allowThrows() const CATCH_OVERRIDE                 { return !m_data.noThrow; }
-        virtual std::ostream& stream() const CATCH_OVERRIDE             { return m_stream->stream(); }
-        virtual std::string name() const CATCH_OVERRIDE                 { return m_data.name.empty() ? m_data.processName : m_data.name; }
-        virtual bool includeSuccessfulResults() const CATCH_OVERRIDE    { return m_data.showSuccessfulTests; }
-        virtual bool warnAboutMissingAssertions() const CATCH_OVERRIDE  { return m_data.warnings & WarnAbout::NoAssertions; }
-        virtual ShowDurations::OrNot showDurations() const CATCH_OVERRIDE { return m_data.showDurations; }
-        virtual RunTests::InWhatOrder runOrder() const CATCH_OVERRIDE   { return m_data.runOrder; }
-        virtual unsigned int rngSeed() const CATCH_OVERRIDE             { return m_data.rngSeed; }
-        virtual UseColour::YesOrNo useColour() const CATCH_OVERRIDE     { return m_data.useColour; }
-        virtual bool shouldDebugBreak() const CATCH_OVERRIDE { return m_data.shouldDebugBreak; }
-        virtual int abortAfter() const CATCH_OVERRIDE { return m_data.abortAfter; }
-        virtual bool showInvisibles() const CATCH_OVERRIDE { return m_data.showInvisibles; }
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        double minDuration() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
 
     private:
 
-        IStream const* openStream() {
-            if( m_data.outputFilename.empty() )
-                return new CoutStream();
-            else if( m_data.outputFilename[0] == '%' ) {
-                if( m_data.outputFilename == "%debug" )
-                    return new DebugOutStream();
-                else
-                    throw std::domain_error( "Unrecognised stream: " + m_data.outputFilename );
-            }
-            else
-                return new FileStream( m_data.outputFilename );
-        }
+        IStream const* openStream();
         ConfigData m_data;
 
-        CATCH_AUTO_PTR( IStream const ) m_stream;
+        std::unique_ptr<IStream const> m_stream;
         TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
     };
 
 } // end namespace Catch
 
-// #included from: catch_clara.h
-#define TWOBLUECUBES_CATCH_CLARA_H_INCLUDED
-
-// Use Catch's value for console width (store Clara's off to the side, if present)
-#ifdef CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CLARA_CONFIG_CONSOLE_WIDTH
-#undef CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-// Declare Clara inside the Catch namespace
-#define STITCH_CLARA_OPEN_NAMESPACE namespace Catch {
-// #included from: ../external/clara.h
-
-// Version 0.0.2.4
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TWOBLUECUBES_CLARA_H_INCLUDED) || defined(STITCH_CLARA_OPEN_NAMESPACE)
-
-#ifndef STITCH_CLARA_OPEN_NAMESPACE
-#define TWOBLUECUBES_CLARA_H_INCLUDED
-#define STITCH_CLARA_OPEN_NAMESPACE
-#define STITCH_CLARA_CLOSE_NAMESPACE
-#else
-#define STITCH_CLARA_CLOSE_NAMESPACE }
-#endif
-
-#define STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE STITCH_CLARA_OPEN_NAMESPACE
-
-// ----------- #included from tbc_text_format.h -----------
-
-// Only use header guard if we are not using an outer namespace
-#if !defined(TBC_TEXT_FORMAT_H_INCLUDED) || defined(STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE)
-#ifndef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-#define TBC_TEXT_FORMAT_H_INCLUDED
-#endif
+// end catch_config.hpp
+// start catch_assertionresult.h
 
 #include <string>
-#include <vector>
-#include <sstream>
-#include <algorithm>
-#include <cctype>
 
-// Use optional outer namespace
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
+namespace Catch {
 
-namespace Tbc {
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
 
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
 
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 ),
-            tabChar( '\t' )
-        {}
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
 
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-        TextAttributes& setTabChar( char _value )               { tabChar = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-        char tabChar;               // If this char is seen the indent is changed to current pos
+        std::string reconstructExpression() const;
     };
 
-    class Text {
+    class AssertionResult {
     public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            std::string wrappableChars = " [({.,/|\\-";
-            std::size_t indent = _attr.initialIndent != std::string::npos
-                ? _attr.initialIndent
-                : _attr.indent;
-            std::string remainder = _str;
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
 
-            while( !remainder.empty() ) {
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-                std::size_t tabPos = std::string::npos;
-                std::size_t width = (std::min)( remainder.size(), _attr.width - indent );
-                std::size_t pos = remainder.find_first_of( '\n' );
-                if( pos <= width ) {
-                    width = pos;
-                }
-                pos = remainder.find_last_of( _attr.tabChar, width );
-                if( pos != std::string::npos ) {
-                    tabPos = pos;
-                    if( remainder[width] == '\n' )
-                        width--;
-                    remainder = remainder.substr( 0, tabPos ) + remainder.substr( tabPos+1 );
-                }
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
 
-                if( width == remainder.size() ) {
-                    spliceLine( indent, remainder, width );
-                }
-                else if( remainder[width] == '\n' ) {
-                    spliceLine( indent, remainder, width );
-                    if( width <= 1 || remainder.size() != 1 )
-                        remainder = remainder.substr( 1 );
-                    indent = _attr.indent;
-                }
-                else {
-                    pos = remainder.find_last_of( wrappableChars, width );
-                    if( pos != std::string::npos && pos > 0 ) {
-                        spliceLine( indent, remainder, pos );
-                        if( remainder[0] == ' ' )
-                            remainder = remainder.substr( 1 );
-                    }
-                    else {
-                        spliceLine( indent, remainder, width-1 );
-                        lines.back() += "-";
-                    }
-                    if( lines.size() == 1 )
-                        indent = _attr.indent;
-                    if( tabPos != std::string::npos )
-                        indent += tabPos;
-                }
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
             }
-        }
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-        void spliceLine( std::size_t _indent, std::string& _remainder, std::size_t _pos ) {
-            lines.push_back( std::string( _indent, ' ' ) + _remainder.substr( 0, _pos ) );
-            _remainder = _remainder.substr( _pos );
-        }
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
 
-        typedef std::vector<std::string>::const_iterator const_iterator;
+// Outlier information
 
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
 
-        friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
             }
-            return _stream;
-        }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+
+#include <iterator>
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
 
     private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
     };
 
-} // end namespace Tbc
-
-#ifdef STITCH_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TBC_TEXT_FORMAT_H_INCLUDED
-
-// ----------- end of #include from tbc_text_format.h -----------
-// ........... back in clara.h
-
-#undef STITCH_TBC_TEXT_FORMAT_OPEN_NAMESPACE
-
-// ----------- #included from clara_compilers.h -----------
-
-#ifndef TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-#define TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-
-// Detect a number of compiler features - mostly C++11/14 conformance - by compiler
-// The following features are defined:
-//
-// CLARA_CONFIG_CPP11_NULLPTR : is nullptr supported?
-// CLARA_CONFIG_CPP11_NOEXCEPT : is noexcept supported?
-// CLARA_CONFIG_CPP11_GENERATED_METHODS : The delete and default keywords for compiler generated methods
-// CLARA_CONFIG_CPP11_OVERRIDE : is override supported?
-// CLARA_CONFIG_CPP11_UNIQUE_PTR : is unique_ptr supported (otherwise use auto_ptr)
-
-// CLARA_CONFIG_CPP11_OR_GREATER : Is C++11 supported?
-
-// CLARA_CONFIG_VARIADIC_MACROS : are variadic macros supported?
-
-// In general each macro has a _NO_<feature name> form
-// (e.g. CLARA_CONFIG_CPP11_NO_NULLPTR) which disables the feature.
-// Many features, at point of detection, define an _INTERNAL_ macro, so they
-// can be combined, en-mass, with the _NO_ forms later.
-
-// All the C++11 features can be disabled with CLARA_CONFIG_NO_CPP11
-
-#ifdef __clang__
-
-#if __has_feature(cxx_nullptr)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-#if __has_feature(cxx_noexcept)
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#endif
-
-#endif // __clang__
-
-////////////////////////////////////////////////////////////////////////////////
-// GCC
-#ifdef __GNUC__
-
-#if __GNUC__ == 4 && __GNUC_MINOR__ >= 6 && defined(__GXX_EXPERIMENTAL_CXX0X__)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-// - otherwise more recent versions define __cplusplus >= 201103L
-// and will get picked up below
-
-#endif // __GNUC__
-
-////////////////////////////////////////////////////////////////////////////////
-// Visual C++
-#ifdef _MSC_VER
-
-#if (_MSC_VER >= 1600)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-#if (_MSC_VER >= 1900 ) // (VC++ 13 (VS2015))
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#endif
-
-#endif // _MSC_VER
-
-////////////////////////////////////////////////////////////////////////////////
-// C++ language feature support
-
-// catch all support for C++11
-#if defined(__cplusplus) && __cplusplus >= 201103L
-
-#define CLARA_CPP11_OR_GREATER
-
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR)
-#define CLARA_INTERNAL_CONFIG_CPP11_NULLPTR
-#endif
-
-#ifndef CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#define CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT
-#endif
-
-#ifndef CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#define CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS
-#endif
-
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE)
-#define CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE
-#endif
-#if !defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR)
-#define CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-#endif // __cplusplus >= 201103L
-
-// Now set the actual defines based on the above + anything the user has configured
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NO_NULLPTR) && !defined(CLARA_CONFIG_CPP11_NULLPTR) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_NULLPTR
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NO_NOEXCEPT) && !defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_NOEXCEPT
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_NO_GENERATED_METHODS) && !defined(CLARA_CONFIG_CPP11_GENERATED_METHODS) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_GENERATED_METHODS
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_OVERRIDE) && !defined(CLARA_CONFIG_CPP11_OVERRIDE) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_OVERRIDE
-#endif
-#if defined(CLARA_INTERNAL_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_UNIQUE_PTR) && !defined(CLARA_CONFIG_CPP11_UNIQUE_PTR) && !defined(CLARA_CONFIG_NO_CPP11)
-#define CLARA_CONFIG_CPP11_UNIQUE_PTR
-#endif
-
-// noexcept support:
-#if defined(CLARA_CONFIG_CPP11_NOEXCEPT) && !defined(CLARA_NOEXCEPT)
-#define CLARA_NOEXCEPT noexcept
-#  define CLARA_NOEXCEPT_IS(x) noexcept(x)
-#else
-#define CLARA_NOEXCEPT throw()
-#  define CLARA_NOEXCEPT_IS(x)
-#endif
-
-// nullptr support
-#ifdef CLARA_CONFIG_CPP11_NULLPTR
-#define CLARA_NULL nullptr
-#else
-#define CLARA_NULL NULL
-#endif
-
-// override support
-#ifdef CLARA_CONFIG_CPP11_OVERRIDE
-#define CLARA_OVERRIDE override
-#else
-#define CLARA_OVERRIDE
-#endif
-
-// unique_ptr support
-#ifdef CLARA_CONFIG_CPP11_UNIQUE_PTR
-#   define CLARA_AUTO_PTR( T ) std::unique_ptr<T>
-#else
-#   define CLARA_AUTO_PTR( T ) std::auto_ptr<T>
-#endif
-
-#endif // TWOBLUECUBES_CLARA_COMPILERS_H_INCLUDED
-
-// ----------- end of #include from clara_compilers.h -----------
-// ........... back in clara.h
-
-#include <map>
-#include <stdexcept>
-#include <memory>
-
-#if defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER)
-#define CLARA_PLATFORM_WINDOWS
-#endif
-
-// Use optional outer namespace
-#ifdef STITCH_CLARA_OPEN_NAMESPACE
-STITCH_CLARA_OPEN_NAMESPACE
-#endif
-
-namespace Clara {
-
-    struct UnpositionalTag {};
-
-    extern UnpositionalTag _;
-
-#ifdef CLARA_CONFIG_MAIN
-    UnpositionalTag _;
-#endif
-
-    namespace Detail {
-
-#ifdef CLARA_CONSOLE_WIDTH
-    const unsigned int consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-        using namespace Tbc;
-
-        inline bool startsWith( std::string const& str, std::string const& prefix ) {
-            return str.size() >= prefix.size() && str.substr( 0, prefix.size() ) == prefix;
-        }
-
-        template<typename T> struct RemoveConstRef{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const&>{ typedef T type; };
-        template<typename T> struct RemoveConstRef<T const>{ typedef T type; };
-
-        template<typename T>    struct IsBool       { static const bool value = false; };
-        template<>              struct IsBool<bool> { static const bool value = true; };
-
-        template<typename T>
-        void convertInto( std::string const& _source, T& _dest ) {
-            std::stringstream ss;
-            ss << _source;
-            ss >> _dest;
-            if( ss.fail() )
-                throw std::runtime_error( "Unable to convert " + _source + " to destination type" );
-        }
-        inline void convertInto( std::string const& _source, std::string& _dest ) {
-            _dest = _source;
-        }
-        char toLowerCh(char c) {
-            return static_cast<char>( std::tolower( c ) );
-        }
-        inline void convertInto( std::string const& _source, bool& _dest ) {
-            std::string sourceLC = _source;
-            std::transform( sourceLC.begin(), sourceLC.end(), sourceLC.begin(), toLowerCh );
-            if( sourceLC == "y" || sourceLC == "1" || sourceLC == "true" || sourceLC == "yes" || sourceLC == "on" )
-                _dest = true;
-            else if( sourceLC == "n" || sourceLC == "0" || sourceLC == "false" || sourceLC == "no" || sourceLC == "off" )
-                _dest = false;
-            else
-                throw std::runtime_error( "Expected a boolean value but did not recognise:\n  '" + _source + "'" );
-        }
-
-        template<typename ConfigT>
-        struct IArgFunction {
-            virtual ~IArgFunction() {}
-#ifdef CLARA_CONFIG_CPP11_GENERATED_METHODS
-            IArgFunction()                      = default;
-            IArgFunction( IArgFunction const& ) = default;
-#endif
-            virtual void set( ConfigT& config, std::string const& value ) const = 0;
-            virtual bool takesArg() const = 0;
-            virtual IArgFunction* clone() const = 0;
-        };
-
-        template<typename ConfigT>
-        class BoundArgFunction {
-        public:
-            BoundArgFunction() : functionObj( CLARA_NULL ) {}
-            BoundArgFunction( IArgFunction<ConfigT>* _functionObj ) : functionObj( _functionObj ) {}
-            BoundArgFunction( BoundArgFunction const& other ) : functionObj( other.functionObj ? other.functionObj->clone() : CLARA_NULL ) {}
-            BoundArgFunction& operator = ( BoundArgFunction const& other ) {
-                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : CLARA_NULL;
-                delete functionObj;
-                functionObj = newFunctionObj;
-                return *this;
-            }
-            ~BoundArgFunction() { delete functionObj; }
-
-            void set( ConfigT& config, std::string const& value ) const {
-                functionObj->set( config, value );
-            }
-            bool takesArg() const { return functionObj->takesArg(); }
-
-            bool isSet() const {
-                return functionObj != CLARA_NULL;
-            }
-        private:
-            IArgFunction<ConfigT>* functionObj;
-        };
-
-        template<typename C>
-        struct NullBinder : IArgFunction<C>{
-            virtual void set( C&, std::string const& ) const {}
-            virtual bool takesArg() const { return true; }
-            virtual IArgFunction<C>* clone() const { return new NullBinder( *this ); }
-        };
-
-        template<typename C, typename M>
-        struct BoundDataMember : IArgFunction<C>{
-            BoundDataMember( M C::* _member ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                convertInto( stringValue, p.*member );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundDataMember( *this ); }
-            M C::* member;
-        };
-        template<typename C, typename M>
-        struct BoundUnaryMethod : IArgFunction<C>{
-            BoundUnaryMethod( void (C::*_member)( M ) ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                typename RemoveConstRef<M>::type value;
-                convertInto( stringValue, value );
-                (p.*member)( value );
-            }
-            virtual bool takesArg() const { return !IsBool<M>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryMethod( *this ); }
-            void (C::*member)( M );
-        };
-        template<typename C>
-        struct BoundNullaryMethod : IArgFunction<C>{
-            BoundNullaryMethod( void (C::*_member)() ) : member( _member ) {}
-            virtual void set( C& p, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    (p.*member)();
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundNullaryMethod( *this ); }
-            void (C::*member)();
-        };
-
-        template<typename C>
-        struct BoundUnaryFunction : IArgFunction<C>{
-            BoundUnaryFunction( void (*_function)( C& ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                bool value;
-                convertInto( stringValue, value );
-                if( value )
-                    function( obj );
-            }
-            virtual bool takesArg() const { return false; }
-            virtual IArgFunction<C>* clone() const { return new BoundUnaryFunction( *this ); }
-            void (*function)( C& );
-        };
-
-        template<typename C, typename T>
-        struct BoundBinaryFunction : IArgFunction<C>{
-            BoundBinaryFunction( void (*_function)( C&, T ) ) : function( _function ) {}
-            virtual void set( C& obj, std::string const& stringValue ) const {
-                typename RemoveConstRef<T>::type value;
-                convertInto( stringValue, value );
-                function( obj, value );
-            }
-            virtual bool takesArg() const { return !IsBool<T>::value; }
-            virtual IArgFunction<C>* clone() const { return new BoundBinaryFunction( *this ); }
-            void (*function)( C&, T );
-        };
-
-    } // namespace Detail
-
-    inline std::vector<std::string> argsToVector( int argc, char const* const* const argv ) {
-        std::vector<std::string> args( static_cast<std::size_t>( argc ) );
-        for( std::size_t i = 0; i < static_cast<std::size_t>( argc ); ++i )
-            args[i] = argv[i];
-
-        return args;
-    }
-
-    class Parser {
-        enum Mode { None, MaybeShortOpt, SlashOpt, ShortOpt, LongOpt, Positional };
-        Mode mode;
-        std::size_t from;
-        bool inQuotes;
-    public:
-
-        struct Token {
-            enum Type { Positional, ShortOpt, LongOpt };
-            Token( Type _type, std::string const& _data ) : type( _type ), data( _data ) {}
-            Type type;
-            std::string data;
-        };
-
-        Parser() : mode( None ), from( 0 ), inQuotes( false ){}
-
-        void parseIntoTokens( std::vector<std::string> const& args, std::vector<Token>& tokens ) {
-            const std::string doubleDash = "--";
-            for( std::size_t i = 1; i < args.size() && args[i] != doubleDash; ++i )
-                parseIntoTokens( args[i], tokens);
-        }
-
-        void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
-            for( std::size_t i = 0; i < arg.size(); ++i ) {
-                char c = arg[i];
-                if( c == '"' )
-                    inQuotes = !inQuotes;
-                mode = handleMode( i, c, arg, tokens );
-            }
-            mode = handleMode( arg.size(), '\0', arg, tokens );
-        }
-        Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            switch( mode ) {
-                case None: return handleNone( i, c );
-                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
-                case ShortOpt:
-                case LongOpt:
-                case SlashOpt: return handleOpt( i, c, arg, tokens );
-                case Positional: return handlePositional( i, c, arg, tokens );
-                default: throw std::logic_error( "Unknown mode" );
-            }
-        }
-
-        Mode handleNone( std::size_t i, char c ) {
-            if( inQuotes ) {
-                from = i;
-                return Positional;
-            }
-            switch( c ) {
-                case '-': return MaybeShortOpt;
-#ifdef CLARA_PLATFORM_WINDOWS
-                case '/': from = i+1; return SlashOpt;
-#endif
-                default: from = i; return Positional;
-            }
-        }
-        Mode handleMaybeShortOpt( std::size_t i, char c ) {
-            switch( c ) {
-                case '-': from = i+1; return LongOpt;
-                default: from = i; return ShortOpt;
-            }
-        }
-
-        Mode handleOpt( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            if( std::string( ":=\0", 3 ).find( c ) == std::string::npos )
-                return mode;
-
-            std::string optName = arg.substr( from, i-from );
-            if( mode == ShortOpt )
-                for( std::size_t j = 0; j < optName.size(); ++j )
-                    tokens.push_back( Token( Token::ShortOpt, optName.substr( j, 1 ) ) );
-            else if( mode == SlashOpt && optName.size() == 1 )
-                tokens.push_back( Token( Token::ShortOpt, optName ) );
-            else
-                tokens.push_back( Token( Token::LongOpt, optName ) );
-            return None;
-        }
-        Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
-            if( inQuotes || std::string( "\0", 1 ).find( c ) == std::string::npos )
-                return mode;
-
-            std::string data = arg.substr( from, i-from );
-            tokens.push_back( Token( Token::Positional, data ) );
-            return None;
-        }
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
     };
 
-    template<typename ConfigT>
-    struct CommonArgProperties {
-        CommonArgProperties() {}
-        CommonArgProperties( Detail::BoundArgFunction<ConfigT> const& _boundField ) : boundField( _boundField ) {}
-
-        Detail::BoundArgFunction<ConfigT> boundField;
-        std::string description;
-        std::string detail;
-        std::string placeholder; // Only value if boundField takes an arg
-
-        bool takesArg() const {
-            return !placeholder.empty();
-        }
-        void validate() const {
-            if( !boundField.isSet() )
-                throw std::logic_error( "option not bound" );
-        }
-    };
-    struct OptionArgProperties {
-        std::vector<std::string> shortNames;
-        std::string longName;
-
-        bool hasShortName( std::string const& shortName ) const {
-            return std::find( shortNames.begin(), shortNames.end(), shortName ) != shortNames.end();
-        }
-        bool hasLongName( std::string const& _longName ) const {
-            return _longName == longName;
-        }
-    };
-    struct PositionalArgProperties {
-        PositionalArgProperties() : position( -1 ) {}
-        int position; // -1 means non-positional (floating)
-
-        bool isFixedPositional() const {
-            return position != -1;
-        }
-    };
-
-    template<typename ConfigT>
-    class CommandLine {
-
-        struct Arg : CommonArgProperties<ConfigT>, OptionArgProperties, PositionalArgProperties {
-            Arg() {}
-            Arg( Detail::BoundArgFunction<ConfigT> const& _boundField ) : CommonArgProperties<ConfigT>( _boundField ) {}
-
-            using CommonArgProperties<ConfigT>::placeholder; // !TBD
-
-            std::string dbgName() const {
-                if( !longName.empty() )
-                    return "--" + longName;
-                if( !shortNames.empty() )
-                    return "-" + shortNames[0];
-                return "positional args";
-            }
-            std::string commands() const {
-                std::ostringstream oss;
-                bool first = true;
-                std::vector<std::string>::const_iterator it = shortNames.begin(), itEnd = shortNames.end();
-                for(; it != itEnd; ++it ) {
-                    if( first )
-                        first = false;
-                    else
-                        oss << ", ";
-                    oss << "-" << *it;
-                }
-                if( !longName.empty() ) {
-                    if( !first )
-                        oss << ", ";
-                    oss << "--" << longName;
-                }
-                if( !placeholder.empty() )
-                    oss << " <" << placeholder << ">";
-                return oss.str();
-            }
-        };
-
-        typedef CLARA_AUTO_PTR( Arg ) ArgAutoPtr;
-
-        friend void addOptName( Arg& arg, std::string const& optName )
-        {
-            if( optName.empty() )
-                return;
-            if( Detail::startsWith( optName, "--" ) ) {
-                if( !arg.longName.empty() )
-                    throw std::logic_error( "Only one long opt may be specified. '"
-                        + arg.longName
-                        + "' already specified, now attempting to add '"
-                        + optName + "'" );
-                arg.longName = optName.substr( 2 );
-            }
-            else if( Detail::startsWith( optName, "-" ) )
-                arg.shortNames.push_back( optName.substr( 1 ) );
-            else
-                throw std::logic_error( "option must begin with - or --. Option was: '" + optName + "'" );
-        }
-        friend void setPositionalArg( Arg& arg, int position )
-        {
-            arg.position = position;
-        }
-
-        class ArgBuilder {
-        public:
-            ArgBuilder( Arg* arg ) : m_arg( arg ) {}
-
-            // Bind a non-boolean data member (requires placeholder string)
-            template<typename C, typename M>
-            void bind( M C::* field, std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,M>( field );
-                m_arg->placeholder = placeholder;
-            }
-            // Bind a boolean data member (no placeholder required)
-            template<typename C>
-            void bind( bool C::* field ) {
-                m_arg->boundField = new Detail::BoundDataMember<C,bool>( field );
-            }
-
-            // Bind a method taking a single, non-boolean argument (requires a placeholder string)
-            template<typename C, typename M>
-            void bind( void (C::* unaryMethod)( M ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,M>( unaryMethod );
-                m_arg->placeholder = placeholder;
-            }
-
-            // Bind a method taking a single, boolean argument (no placeholder string required)
-            template<typename C>
-            void bind( void (C::* unaryMethod)( bool ) ) {
-                m_arg->boundField = new Detail::BoundUnaryMethod<C,bool>( unaryMethod );
-            }
-
-            // Bind a method that takes no arguments (will be called if opt is present)
-            template<typename C>
-            void bind( void (C::* nullaryMethod)() ) {
-                m_arg->boundField = new Detail::BoundNullaryMethod<C>( nullaryMethod );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (no placeholder string required)
-            template<typename C>
-            void bind( void (* unaryFunction)( C& ) ) {
-                m_arg->boundField = new Detail::BoundUnaryFunction<C>( unaryFunction );
-            }
-
-            // Bind a free function taking a single argument - the object to operate on (requires a placeholder string)
-            template<typename C, typename T>
-            void bind( void (* binaryFunction)( C&, T ), std::string const& placeholder ) {
-                m_arg->boundField = new Detail::BoundBinaryFunction<C, T>( binaryFunction );
-                m_arg->placeholder = placeholder;
-            }
-
-            ArgBuilder& describe( std::string const& description ) {
-                m_arg->description = description;
-                return *this;
-            }
-            ArgBuilder& detail( std::string const& detail ) {
-                m_arg->detail = detail;
-                return *this;
-            }
-
-        protected:
-            Arg* m_arg;
-        };
-
-        class OptBuilder : public ArgBuilder {
-        public:
-            OptBuilder( Arg* arg ) : ArgBuilder( arg ) {}
-            OptBuilder( OptBuilder& other ) : ArgBuilder( other ) {}
-
-            OptBuilder& operator[]( std::string const& optName ) {
-                addOptName( *ArgBuilder::m_arg, optName );
-                return *this;
-            }
-        };
-
-    public:
-
-        CommandLine()
-        :   m_boundProcessName( new Detail::NullBinder<ConfigT>() ),
-            m_highestSpecifiedArgPosition( 0 ),
-            m_throwOnUnrecognisedTokens( false )
-        {}
-        CommandLine( CommandLine const& other )
-        :   m_boundProcessName( other.m_boundProcessName ),
-            m_options ( other.m_options ),
-            m_positionalArgs( other.m_positionalArgs ),
-            m_highestSpecifiedArgPosition( other.m_highestSpecifiedArgPosition ),
-            m_throwOnUnrecognisedTokens( other.m_throwOnUnrecognisedTokens )
-        {
-            if( other.m_floatingArg.get() )
-                m_floatingArg.reset( new Arg( *other.m_floatingArg ) );
-        }
-
-        CommandLine& setThrowOnUnrecognisedTokens( bool shouldThrow = true ) {
-            m_throwOnUnrecognisedTokens = shouldThrow;
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
             return *this;
         }
-
-        OptBuilder operator[]( std::string const& optName ) {
-            m_options.push_back( Arg() );
-            addOptName( m_options.back(), optName );
-            OptBuilder builder( &m_options.back() );
-            return builder;
+        void reset() {
+            Option<T>::reset();
+            used = false;
         }
-
-        ArgBuilder operator[]( int position ) {
-            m_positionalArgs.insert( std::make_pair( position, Arg() ) );
-            if( position > m_highestSpecifiedArgPosition )
-                m_highestSpecifiedArgPosition = position;
-            setPositionalArg( m_positionalArgs[position], position );
-            ArgBuilder builder( &m_positionalArgs[position] );
-            return builder;
-        }
-
-        // Invoke this with the _ instance
-        ArgBuilder operator[]( UnpositionalTag ) {
-            if( m_floatingArg.get() )
-                throw std::logic_error( "Only one unpositional argument can be added" );
-            m_floatingArg.reset( new Arg() );
-            ArgBuilder builder( m_floatingArg.get() );
-            return builder;
-        }
-
-        template<typename C, typename M>
-        void bindProcessName( M C::* field ) {
-            m_boundProcessName = new Detail::BoundDataMember<C,M>( field );
-        }
-        template<typename C, typename M>
-        void bindProcessName( void (C::*_unaryMethod)( M ) ) {
-            m_boundProcessName = new Detail::BoundUnaryMethod<C,M>( _unaryMethod );
-        }
-
-        void optUsage( std::ostream& os, std::size_t indent = 0, std::size_t width = Detail::consoleWidth ) const {
-            typename std::vector<Arg>::const_iterator itBegin = m_options.begin(), itEnd = m_options.end(), it;
-            std::size_t maxWidth = 0;
-            for( it = itBegin; it != itEnd; ++it )
-                maxWidth = (std::max)( maxWidth, it->commands().size() );
-
-            for( it = itBegin; it != itEnd; ++it ) {
-                Detail::Text usage( it->commands(), Detail::TextAttributes()
-                                                        .setWidth( maxWidth+indent )
-                                                        .setIndent( indent ) );
-                Detail::Text desc( it->description, Detail::TextAttributes()
-                                                        .setWidth( width - maxWidth - 3 ) );
-
-                for( std::size_t i = 0; i < (std::max)( usage.size(), desc.size() ); ++i ) {
-                    std::string usageCol = i < usage.size() ? usage[i] : "";
-                    os << usageCol;
-
-                    if( i < desc.size() && !desc[i].empty() )
-                        os  << std::string( indent + 2 + maxWidth - usageCol.size(), ' ' )
-                            << desc[i];
-                    os << "\n";
-                }
-            }
-        }
-        std::string optUsage() const {
-            std::ostringstream oss;
-            optUsage( oss );
-            return oss.str();
-        }
-
-        void argSynopsis( std::ostream& os ) const {
-            for( int i = 1; i <= m_highestSpecifiedArgPosition; ++i ) {
-                if( i > 1 )
-                    os << " ";
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( i );
-                if( it != m_positionalArgs.end() )
-                    os << "<" << it->second.placeholder << ">";
-                else if( m_floatingArg.get() )
-                    os << "<" << m_floatingArg->placeholder << ">";
-                else
-                    throw std::logic_error( "non consecutive positional arguments with no floating args" );
-            }
-            // !TBD No indication of mandatory args
-            if( m_floatingArg.get() ) {
-                if( m_highestSpecifiedArgPosition > 1 )
-                    os << " ";
-                os << "[<" << m_floatingArg->placeholder << "> ...]";
-            }
-        }
-        std::string argSynopsis() const {
-            std::ostringstream oss;
-            argSynopsis( oss );
-            return oss.str();
-        }
-
-        void usage( std::ostream& os, std::string const& procName ) const {
-            validate();
-            os << "usage:\n  " << procName << " ";
-            argSynopsis( os );
-            if( !m_options.empty() ) {
-                os << " [options]\n\nwhere options are: \n";
-                optUsage( os, 2 );
-            }
-            os << "\n";
-        }
-        std::string usage( std::string const& procName ) const {
-            std::ostringstream oss;
-            usage( oss, procName );
-            return oss.str();
-        }
-
-        ConfigT parse( std::vector<std::string> const& args ) const {
-            ConfigT config;
-            parseInto( args, config );
-            return config;
-        }
-
-        std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
-            std::string processName = args.empty() ? std::string() : args[0];
-            std::size_t lastSlash = processName.find_last_of( "/\\" );
-            if( lastSlash != std::string::npos )
-                processName = processName.substr( lastSlash+1 );
-            m_boundProcessName.set( config, processName );
-            std::vector<Parser::Token> tokens;
-            Parser parser;
-            parser.parseIntoTokens( args, tokens );
-            return populate( tokens, config );
-        }
-
-        std::vector<Parser::Token> populate( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            validate();
-            std::vector<Parser::Token> unusedTokens = populateOptions( tokens, config );
-            unusedTokens = populateFixedArgs( unusedTokens, config );
-            unusedTokens = populateFloatingArgs( unusedTokens, config );
-            return unusedTokens;
-        }
-
-        std::vector<Parser::Token> populateOptions( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            std::vector<std::string> errors;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::vector<Arg>::const_iterator it = m_options.begin(), itEnd = m_options.end();
-                for(; it != itEnd; ++it ) {
-                    Arg const& arg = *it;
-
-                    try {
-                        if( ( token.type == Parser::Token::ShortOpt && arg.hasShortName( token.data ) ) ||
-                            ( token.type == Parser::Token::LongOpt && arg.hasLongName( token.data ) ) ) {
-                            if( arg.takesArg() ) {
-                                if( i == tokens.size()-1 || tokens[i+1].type != Parser::Token::Positional )
-                                    errors.push_back( "Expected argument to option: " + token.data );
-                                else
-                                    arg.boundField.set( config, tokens[++i].data );
-                            }
-                            else {
-                                arg.boundField.set( config, "true" );
-                            }
-                            break;
-                        }
-                    }
-                    catch( std::exception& ex ) {
-                        errors.push_back( std::string( ex.what() ) + "\n- while parsing: (" + arg.commands() + ")" );
-                    }
-                }
-                if( it == itEnd ) {
-                    if( token.type == Parser::Token::Positional || !m_throwOnUnrecognisedTokens )
-                        unusedTokens.push_back( token );
-                    else if( errors.empty() && m_throwOnUnrecognisedTokens )
-                        errors.push_back( "unrecognised option: " + token.data );
-                }
-            }
-            if( !errors.empty() ) {
-                std::ostringstream oss;
-                for( std::vector<std::string>::const_iterator it = errors.begin(), itEnd = errors.end();
-                        it != itEnd;
-                        ++it ) {
-                    if( it != errors.begin() )
-                        oss << "\n";
-                    oss << *it;
-                }
-                throw std::runtime_error( oss.str() );
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFixedArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            std::vector<Parser::Token> unusedTokens;
-            int position = 1;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                typename std::map<int, Arg>::const_iterator it = m_positionalArgs.find( position );
-                if( it != m_positionalArgs.end() )
-                    it->second.boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-                if( token.type == Parser::Token::Positional )
-                    position++;
-            }
-            return unusedTokens;
-        }
-        std::vector<Parser::Token> populateFloatingArgs( std::vector<Parser::Token> const& tokens, ConfigT& config ) const {
-            if( !m_floatingArg.get() )
-                return tokens;
-            std::vector<Parser::Token> unusedTokens;
-            for( std::size_t i = 0; i < tokens.size(); ++i ) {
-                Parser::Token const& token = tokens[i];
-                if( token.type == Parser::Token::Positional )
-                    m_floatingArg->boundField.set( config, token.data );
-                else
-                    unusedTokens.push_back( token );
-            }
-            return unusedTokens;
-        }
-
-        void validate() const
-        {
-            if( m_options.empty() && m_positionalArgs.empty() && !m_floatingArg.get() )
-                throw std::logic_error( "No options or arguments specified" );
-
-            for( typename std::vector<Arg>::const_iterator  it = m_options.begin(),
-                                                            itEnd = m_options.end();
-                    it != itEnd; ++it )
-                it->validate();
-        }
-
-    private:
-        Detail::BoundArgFunction<ConfigT> m_boundProcessName;
-        std::vector<Arg> m_options;
-        std::map<int, Arg> m_positionalArgs;
-        ArgAutoPtr m_floatingArg;
-        int m_highestSpecifiedArgPosition;
-        bool m_throwOnUnrecognisedTokens;
+        bool used = false;
     };
 
-} // end namespace Clara
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
 
-STITCH_CLARA_CLOSE_NAMESPACE
-#undef STITCH_CLARA_OPEN_NAMESPACE
-#undef STITCH_CLARA_CLOSE_NAMESPACE
-
-#endif // TWOBLUECUBES_CLARA_H_INCLUDED
-#undef STITCH_CLARA_OPEN_NAMESPACE
-
-// Restore Clara's value for console width, if present
-#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#define CLARA_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#include <fstream>
-#include <ctime>
-
-namespace Catch {
-
-    inline void abortAfterFirst( ConfigData& config ) { config.abortAfter = 1; }
-    inline void abortAfterX( ConfigData& config, int x ) {
-        if( x < 1 )
-            throw std::runtime_error( "Value after -x or --abortAfter must be greater than zero" );
-        config.abortAfter = x;
-    }
-    inline void addTestOrTags( ConfigData& config, std::string const& _testSpec ) { config.testsOrTags.push_back( _testSpec ); }
-    inline void addSectionToRun( ConfigData& config, std::string const& sectionName ) { config.sectionsToRun.push_back( sectionName ); }
-    inline void addReporterName( ConfigData& config, std::string const& _reporterName ) { config.reporterNames.push_back( _reporterName ); }
-
-    inline void addWarning( ConfigData& config, std::string const& _warning ) {
-        if( _warning == "NoAssertions" )
-            config.warnings = static_cast<WarnAbout::What>( config.warnings | WarnAbout::NoAssertions );
-        else
-            throw std::runtime_error( "Unrecognised warning: '" + _warning + '\'' );
-    }
-    inline void setOrder( ConfigData& config, std::string const& order ) {
-        if( startsWith( "declared", order ) )
-            config.runOrder = RunTests::InDeclarationOrder;
-        else if( startsWith( "lexical", order ) )
-            config.runOrder = RunTests::InLexicographicalOrder;
-        else if( startsWith( "random", order ) )
-            config.runOrder = RunTests::InRandomOrder;
-        else
-            throw std::runtime_error( "Unrecognised ordering: '" + order + '\'' );
-    }
-    inline void setRngSeed( ConfigData& config, std::string const& seed ) {
-        if( seed == "time" ) {
-            config.rngSeed = static_cast<unsigned int>( std::time(0) );
-        }
-        else {
-            std::stringstream ss;
-            ss << seed;
-            ss >> config.rngSeed;
-            if( ss.fail() )
-                throw std::runtime_error( "Argument to --rng-seed should be the word 'time' or a number" );
-        }
-    }
-    inline void setVerbosity( ConfigData& config, int level ) {
-        // !TBD: accept strings?
-        config.verbosity = static_cast<Verbosity::Level>( level );
-    }
-    inline void setShowDurations( ConfigData& config, bool _showDurations ) {
-        config.showDurations = _showDurations
-            ? ShowDurations::Always
-            : ShowDurations::Never;
-    }
-    inline void setUseColour( ConfigData& config, std::string const& value ) {
-        std::string mode = toLower( value );
-
-        if( mode == "yes" )
-            config.useColour = UseColour::Yes;
-        else if( mode == "no" )
-            config.useColour = UseColour::No;
-        else if( mode == "auto" )
-            config.useColour = UseColour::Auto;
-        else
-            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
-    }
-    inline void setWaitForKeypress( ConfigData& config, std::string const& keypress ) {
-        std::string keypressLc = toLower( keypress );
-        if( keypressLc == "start" )
-            config.waitForKeypress = WaitForKeypress::BeforeStart;
-        else if( keypressLc == "exit" )
-            config.waitForKeypress = WaitForKeypress::BeforeExit;
-        else if( keypressLc == "both" )
-            config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
-        else
-            throw std::runtime_error( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
     };
 
-    inline void forceColour( ConfigData& config ) {
-        config.useColour = UseColour::Yes;
-    }
-    inline void loadTestNamesFromFile( ConfigData& config, std::string const& _filename ) {
-        std::ifstream f( _filename.c_str() );
-        if( !f.is_open() )
-            throw std::domain_error( "Unable to load input file: " + _filename );
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
 
-        std::string line;
-        while( std::getline( f, line ) ) {
-            line = trim(line);
-            if( !line.empty() && !startsWith( line, '#' ) ) {
-                if( !startsWith( line, '"' ) )
-                    line = '"' + line + '"';
-                addTestOrTags( config, line + ',' );
-            }
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
         }
-    }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    inline Clara::CommandLine<ConfigData> makeCommandLineParser() {
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
 
-        using namespace Clara;
-        CommandLine<ConfigData> cli;
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
 
-        cli.bindProcessName( &ConfigData::processName );
+        virtual ReporterPreferences getPreferences() const = 0;
 
-        cli["-?"]["-h"]["--help"]
-            .describe( "display usage information" )
-            .bind( &ConfigData::showHelp );
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
 
-        cli["-l"]["--list-tests"]
-            .describe( "list all/matching test cases" )
-            .bind( &ConfigData::listTests );
+        virtual void reportInvalidArguments(std::string const&) {}
 
-        cli["-t"]["--list-tags"]
-            .describe( "list all/matching tags" )
-            .bind( &ConfigData::listTags );
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
 
-        cli["-s"]["--success"]
-            .describe( "include successful tests in output" )
-            .bind( &ConfigData::showSuccessfulTests );
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
 
-        cli["-b"]["--break"]
-            .describe( "break into debugger on failure" )
-            .bind( &ConfigData::shouldDebugBreak );
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-        cli["-e"]["--nothrow"]
-            .describe( "skip exception tests" )
-            .bind( &ConfigData::noThrow );
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
 
-        cli["-i"]["--invisibles"]
-            .describe( "show invisibles (tabs, newlines)" )
-            .bind( &ConfigData::showInvisibles );
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
 
-        cli["-o"]["--out"]
-            .describe( "output filename" )
-            .bind( &ConfigData::outputFilename, "filename" );
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
 
-        cli["-r"]["--reporter"]
-//            .placeholder( "name[:filename]" )
-            .describe( "reporter to use (defaults to console)" )
-            .bind( &addReporterName, "name" );
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
 
-        cli["-n"]["--name"]
-            .describe( "suite name" )
-            .bind( &ConfigData::name, "name" );
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
 
-        cli["-a"]["--abort"]
-            .describe( "abort at first failure" )
-            .bind( &abortAfterFirst );
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
 
-        cli["-x"]["--abortx"]
-            .describe( "abort after x failures" )
-            .bind( &abortAfterX, "no. failures" );
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
 
-        cli["-w"]["--warn"]
-            .describe( "enable warnings" )
-            .bind( &addWarning, "warning name" );
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
 
-// - needs updating if reinstated
-//        cli.into( &setVerbosity )
-//            .describe( "level of verbosity (0=no output)" )
-//            .shortOpt( "v")
-//            .longOpt( "verbosity" )
-//            .placeholder( "level" );
-
-        cli[_]
-            .describe( "which test or tests to use" )
-            .bind( &addTestOrTags, "test name, pattern or tags" );
-
-        cli["-d"]["--durations"]
-            .describe( "show test durations" )
-            .bind( &setShowDurations, "yes|no" );
-
-        cli["-f"]["--input-file"]
-            .describe( "load test names to run from a file" )
-            .bind( &loadTestNamesFromFile, "filename" );
-
-        cli["-#"]["--filenames-as-tags"]
-            .describe( "adds a tag for the filename" )
-            .bind( &ConfigData::filenamesAsTags );
-
-        cli["-c"]["--section"]
-                .describe( "specify section to run" )
-                .bind( &addSectionToRun, "section name" );
-
-        // Less common commands which don't have a short form
-        cli["--list-test-names-only"]
-            .describe( "list all/matching test cases names only" )
-            .bind( &ConfigData::listTestNamesOnly );
-
-        cli["--list-extra-info"]
-            .describe( "list all/matching test cases with more info" )
-            .bind( &ConfigData::listExtraInfo );
-
-        cli["--list-reporters"]
-            .describe( "list all reporters" )
-            .bind( &ConfigData::listReporters );
-
-        cli["--order"]
-            .describe( "test case order (defaults to decl)" )
-            .bind( &setOrder, "decl|lex|rand" );
-
-        cli["--rng-seed"]
-            .describe( "set a specific seed for random numbers" )
-            .bind( &setRngSeed, "'time'|number" );
-
-        cli["--force-colour"]
-            .describe( "force colourised output (deprecated)" )
-            .bind( &forceColour );
-
-        cli["--use-colour"]
-            .describe( "should output be colourised" )
-            .bind( &setUseColour, "yes|no" );
-
-        cli["--libidentify"]
-            .describe( "report name and version according to libidentify standard" )
-            .bind( &ConfigData::libIdentify );
-
-        cli["--wait-for-keypress"]
-                .describe( "waits for a keypress before exiting" )
-                .bind( &setWaitForKeypress, "start|exit|both" );
-
-        return cli;
-    }
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
 
 } // end namespace Catch
 
-// #included from: internal/catch_list.hpp
-#define TWOBLUECUBES_CATCH_LIST_HPP_INCLUDED
-
-// #included from: catch_text.h
-#define TWOBLUECUBES_CATCH_TEXT_H_INCLUDED
-
-#define TBC_TEXT_FORMAT_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH
-
-#define CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE Catch
-// #included from: ../external/tbc_text_format.h
-// Only use header guard if we are not using an outer namespace
-#ifndef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-# ifdef TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-#  ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#   define TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#  endif
-# else
-#  define TWOBLUECUBES_TEXT_FORMAT_H_INCLUDED
-# endif
-#endif
-#ifndef TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#include <string>
-#include <vector>
-#include <sstream>
-
-// Use optional outer namespace
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-namespace CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE {
-#endif
-
-namespace Tbc {
-
-#ifdef TBC_TEXT_FORMAT_CONSOLE_WIDTH
-    const unsigned int consoleWidth = TBC_TEXT_FORMAT_CONSOLE_WIDTH;
-#else
-    const unsigned int consoleWidth = 80;
-#endif
-
-    struct TextAttributes {
-        TextAttributes()
-        :   initialIndent( std::string::npos ),
-            indent( 0 ),
-            width( consoleWidth-1 )
-        {}
-
-        TextAttributes& setInitialIndent( std::size_t _value )  { initialIndent = _value; return *this; }
-        TextAttributes& setIndent( std::size_t _value )         { indent = _value; return *this; }
-        TextAttributes& setWidth( std::size_t _value )          { width = _value; return *this; }
-
-        std::size_t initialIndent;  // indent of first line, or npos
-        std::size_t indent;         // indent of subsequent lines, or all if initialIndent is npos
-        std::size_t width;          // maximum width of text, including indent. Longer text will wrap
-    };
-
-    class Text {
-    public:
-        Text( std::string const& _str, TextAttributes const& _attr = TextAttributes() )
-        : attr( _attr )
-        {
-            const std::string wrappableBeforeChars = "[({<\t";
-            const std::string wrappableAfterChars = "])}>-,./|\\";
-            const std::string wrappableInsteadOfChars = " \n\r";
-            std::string indent = _attr.initialIndent != std::string::npos
-                ? std::string( _attr.initialIndent, ' ' )
-                : std::string( _attr.indent, ' ' );
-
-            typedef std::string::const_iterator iterator;
-            iterator it = _str.begin();
-            const iterator strEnd = _str.end();
-
-            while( it != strEnd ) {
-
-                if( lines.size() >= 1000 ) {
-                    lines.push_back( "... message truncated due to excessive size" );
-                    return;
-                }
-
-                std::string suffix;
-                std::size_t width = (std::min)( static_cast<size_t>( strEnd-it ), _attr.width-static_cast<size_t>( indent.size() ) );
-                iterator itEnd = it+width;
-                iterator itNext = _str.end();
-
-                iterator itNewLine = std::find( it, itEnd, '\n' );
-                if( itNewLine != itEnd )
-                    itEnd = itNewLine;
-
-                if( itEnd != strEnd  ) {
-                    bool foundWrapPoint = false;
-                    iterator findIt = itEnd;
-                    do {
-                        if( wrappableAfterChars.find( *findIt ) != std::string::npos && findIt != itEnd ) {
-                            itEnd = findIt+1;
-                            itNext = findIt+1;
-                            foundWrapPoint = true;
-                        }
-                        else if( findIt > it && wrappableBeforeChars.find( *findIt ) != std::string::npos ) {
-                            itEnd = findIt;
-                            itNext = findIt;
-                            foundWrapPoint = true;
-                        }
-                        else if( wrappableInsteadOfChars.find( *findIt ) != std::string::npos ) {
-                            itNext = findIt+1;
-                            itEnd = findIt;
-                            foundWrapPoint = true;
-                        }
-                        if( findIt == it )
-                            break;
-                        else
-                            --findIt;
-                    }
-                    while( !foundWrapPoint );
-
-                    if( !foundWrapPoint ) {
-                        // No good wrap char, so we'll break mid word and add a hyphen
-                        --itEnd;
-                        itNext = itEnd;
-                        suffix = "-";
-                    }
-                    else {
-                        while( itEnd > it && wrappableInsteadOfChars.find( *(itEnd-1) ) != std::string::npos )
-                            --itEnd;
-                    }
-                }
-                lines.push_back( indent + std::string( it, itEnd ) + suffix );
-
-                if( indent.size() != _attr.indent )
-                    indent = std::string( _attr.indent, ' ' );
-                it = itNext;
-            }
-        }
-
-        typedef std::vector<std::string>::const_iterator const_iterator;
-
-        const_iterator begin() const { return lines.begin(); }
-        const_iterator end() const { return lines.end(); }
-        std::string const& last() const { return lines.back(); }
-        std::size_t size() const { return lines.size(); }
-        std::string const& operator[]( std::size_t _index ) const { return lines[_index]; }
-        std::string toString() const {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-
-        inline friend std::ostream& operator << ( std::ostream& _stream, Text const& _text ) {
-            for( Text::const_iterator it = _text.begin(), itEnd = _text.end();
-                it != itEnd; ++it ) {
-                if( it != _text.begin() )
-                    _stream << "\n";
-                _stream << *it;
-            }
-            return _stream;
-        }
-
-    private:
-        std::string str;
-        TextAttributes attr;
-        std::vector<std::string> lines;
-    };
-
-} // end namespace Tbc
-
-#ifdef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
-} // end outer namespace
-#endif
-
-#endif // TWOBLUECUBES_TEXT_FORMAT_H_ALREADY_INCLUDED
-#undef CLICHE_TBC_TEXT_FORMAT_OUTER_NAMESPACE
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
 
 namespace Catch {
-    using Tbc::Text;
-    using Tbc::TextAttributes;
-}
+    void prepareExpandedExpression(AssertionResult& result);
 
-// #included from: catch_console_colour.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    //! Should the reporter show
+    bool shouldShowDuration( IConfig const& config, double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
 
 namespace Catch {
 
@@ -5565,10 +6005,11 @@ namespace Catch {
             BrightGreen = Bright | Green,
             LightGrey = Bright | Grey,
             BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
 
             // By intention
             FileName = LightGrey,
-            Warning = Yellow,
+            Warning = BrightYellow,
             ResultError = BrightRed,
             ResultSuccess = BrightGreen,
             ResultExpectedFailure = Warning,
@@ -5577,7 +6018,7 @@ namespace Catch {
             Success = Green,
 
             OriginalExpression = Cyan,
-            ReconstructedExpression = Yellow,
+            ReconstructedExpression = BrightYellow,
 
             SecondaryText = LightGrey,
             Headers = White
@@ -5585,462 +6026,1451 @@ namespace Catch {
 
         // Use constructed object for RAII guard
         Colour( Code _colourCode );
-        Colour( Colour const& other );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
         ~Colour();
 
         // Use static method for one-shot changes
         static void use( Code _colourCode );
 
     private:
-        bool m_moved;
+        bool m_moved = false;
     };
 
-    inline std::ostream& operator << ( std::ostream& os, Colour const& ) { return os; }
+    std::ostream& operator << ( std::ostream& os, Colour const& );
 
 } // end namespace Catch
 
-// #included from: catch_interfaces_reporter.h
-#define TWOBLUECUBES_CATCH_INTERFACES_REPORTER_H_INCLUDED
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
 
-#include <string>
-#include <ostream>
-#include <map>
-
-namespace Catch
-{
-    struct ReporterConfig {
-        explicit ReporterConfig( Ptr<IConfig const> const& _fullConfig )
-        :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
-
-        ReporterConfig( Ptr<IConfig const> const& _fullConfig, std::ostream& _stream )
-        :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
-
-        std::ostream& stream() const    { return *m_stream; }
-        Ptr<IConfig const> fullConfig() const { return m_fullConfig; }
-
-    private:
-        std::ostream* m_stream;
-        Ptr<IConfig const> m_fullConfig;
-    };
-
-    struct ReporterPreferences {
-        ReporterPreferences()
-        : shouldRedirectStdOut( false )
-        {}
-
-        bool shouldRedirectStdOut;
-    };
-
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat() : used( false ) {}
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used;
-    };
-
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name ) : name( _name ) {}
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount )
-        :   name( _name ),
-            groupIndex( _groupIndex ),
-            groupsCounts( _groupsCount )
-        {}
-
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
-
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals )
-        :   assertionResult( _assertionResult ),
-            infoMessages( _infoMessages ),
-            totals( _totals )
-        {
-            if( assertionResult.hasMessage() ) {
-                // Copy message into messages list.
-                // !TBD This should have been done earlier, somewhere
-                MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
-                builder << assertionResult.getMessage();
-                builder.m_info.message = builder.m_stream.str();
-
-                infoMessages.push_back( builder.m_info );
-            }
-        }
-        virtual ~AssertionStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-#  endif
-
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
-
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions )
-        :   sectionInfo( _sectionInfo ),
-            assertions( _assertions ),
-            durationInSeconds( _durationInSeconds ),
-            missingAssertions( _missingAssertions )
-        {}
-        virtual ~SectionStats();
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-#  endif
-
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
-
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting )
-        : testInfo( _testInfo ),
-            totals( _totals ),
-            stdOut( _stdOut ),
-            stdErr( _stdErr ),
-            aborting( _aborting )
-        {}
-        virtual ~TestCaseStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-#  endif
-
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
-
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   groupInfo( _groupInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        TestGroupStats( GroupInfo const& _groupInfo )
-        :   groupInfo( _groupInfo ),
-            aborting( false )
-        {}
-        virtual ~TestGroupStats();
-
-#  ifdef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-#  endif
-
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting )
-        :   runInfo( _runInfo ),
-            totals( _totals ),
-            aborting( _aborting )
-        {}
-        virtual ~TestRunStats();
-
-#  ifndef CATCH_CONFIG_CPP11_GENERATED_METHODS
-        TestRunStats( TestRunStats const& _other )
-        :   runInfo( _other.runInfo ),
-            totals( _other.totals ),
-            aborting( _other.aborting )
-        {}
-#  else
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-#  endif
-
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
-
-    class MultipleReporters;
-
-    struct IStreamingReporter : IShared {
-        virtual ~IStreamingReporter();
-
-        // Implementing class must also provide the following static method:
-        // static std::string getDescription();
-
-        virtual ReporterPreferences getPreferences() const = 0;
-
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
-
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
-
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
-
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
-
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
-
-        virtual MultipleReporters* tryAsMulti() { return CATCH_NULL; }
-    };
-
-    struct IReporterFactory : IShared {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-
-    struct IReporterRegistry {
-        typedef std::map<std::string, Ptr<IReporterFactory> > FactoryMap;
-        typedef std::vector<Ptr<IReporterFactory> > Listeners;
-
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
-    };
-
-    Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
-
-}
-
-#include <limits>
-#include <algorithm>
 
 namespace Catch {
 
-    inline std::size_t listTests( Config const& config ) {
+    template<typename T>
+    class ReporterRegistrar {
 
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Matching test cases:\n";
-        else {
-            Catch::cout() << "All available test cases:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
+        class ReporterFactory : public IReporterFactory {
 
-        std::size_t matchedTests = 0;
-        TextAttributes nameAttr, descAttr, tagsAttr;
-        nameAttr.setInitialIndent( 2 ).setIndent( 4 );
-        descAttr.setIndent( 4 );
-        tagsAttr.setIndent( 6 );
-
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            Colour::Code colour = testCaseInfo.isHidden()
-                ? Colour::SecondaryText
-                : Colour::None;
-            Colour colourGuard( colour );
-
-            Catch::cout() << Text( testCaseInfo.name, nameAttr ) << std::endl;
-            if( config.listExtraInfo() ) {
-                Catch::cout() << "    " << testCaseInfo.lineInfo << std::endl;
-                std::string description = testCaseInfo.description;
-                if( description.empty() )
-                    description = "(NO DESCRIPTION)";
-                Catch::cout() << Text( description, descAttr ) << std::endl;
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
             }
-            if( !testCaseInfo.tags.empty() )
-                Catch::cout() << Text( testCaseInfo.tagsAsString, tagsAttr ) << std::endl;
-        }
 
-        if( !config.testSpec().hasFilters() )
-            Catch::cout() << pluralise( matchedTests, "test case" ) << '\n' << std::endl;
-        else
-            Catch::cout() << pluralise( matchedTests, "matching test case" ) << '\n' << std::endl;
-        return matchedTests;
-    }
+            std::string getDescription() const override {
+                return T::getDescription();
+            }
+        };
 
-    inline std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( !config.testSpec().hasFilters() )
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        std::size_t matchedTests = 0;
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            matchedTests++;
-            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
-            if( startsWith( testCaseInfo.name, '#' ) )
-               Catch::cout() << '"' << testCaseInfo.name << '"';
-            else
-               Catch::cout() << testCaseInfo.name;
-            if ( config.listExtraInfo() )
-                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
-            Catch::cout() << std::endl;
-        }
-        return matchedTests;
-    }
+    public:
 
-    struct TagInfo {
-        TagInfo() : count ( 0 ) {}
-        void add( std::string const& spelling ) {
-            ++count;
-            spellings.insert( spelling );
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
         }
-        std::string all() const {
-            std::string out;
-            for( std::set<std::string>::const_iterator it = spellings.begin(), itEnd = spellings.end();
-                        it != itEnd;
-                        ++it )
-                out += "[" + *it + "]";
-            return out;
-        }
-        std::set<std::string> spellings;
-        std::size_t count;
     };
 
-    inline std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
-        if( config.testSpec().hasFilters() )
-            Catch::cout() << "Tags for matching test cases:\n";
-        else {
-            Catch::cout() << "All available tags:\n";
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
-        }
+    template<typename T>
+    class ListenerRegistrar {
 
-        std::map<std::string, TagInfo> tagCounts;
+        class ListenerFactory : public IReporterFactory {
 
-        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
-        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
-                it != itEnd;
-                ++it ) {
-            for( std::set<std::string>::const_iterator  tagIt = it->getTestCaseInfo().tags.begin(),
-                                                        tagItEnd = it->getTestCaseInfo().tags.end();
-                    tagIt != tagItEnd;
-                    ++tagIt ) {
-                std::string tagName = *tagIt;
-                std::string lcaseTagName = toLower( tagName );
-                std::map<std::string, TagInfo>::iterator countIt = tagCounts.find( lcaseTagName );
-                if( countIt == tagCounts.end() )
-                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
-                countIt->second.add( tagName );
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
             }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
+
+    public:
+
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
         }
+    };
+}
 
-        for( std::map<std::string, TagInfo>::const_iterator countIt = tagCounts.begin(),
-                                                            countItEnd = tagCounts.end();
-                countIt != countItEnd;
-                ++countIt ) {
-            std::ostringstream oss;
-            oss << "  " << std::setw(2) << countIt->second.count << "  ";
-            Text wrapper( countIt->second.all(), TextAttributes()
-                                                    .setInitialIndent( 0 )
-                                                    .setIndent( oss.str().size() )
-                                                    .setWidth( CATCH_CONFIG_CONSOLE_WIDTH-10 ) );
-            Catch::cout() << oss.str() << wrapper << '\n';
-        }
-        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
-        return tagCounts.size();
-    }
+#if !defined(CATCH_CONFIG_DISABLE)
 
-    inline std::size_t listReporters( Config const& /*config*/ ) {
-        Catch::cout() << "Available reporters:\n";
-        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
-        IReporterRegistry::FactoryMap::const_iterator itBegin = factories.begin(), itEnd = factories.end(), it;
-        std::size_t maxNameLen = 0;
-        for(it = itBegin; it != itEnd; ++it )
-            maxNameLen = (std::max)( maxNameLen, it->first.size() );
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-        for(it = itBegin; it != itEnd; ++it ) {
-            Text wrapper( it->second->getDescription(), TextAttributes()
-                                                        .setInitialIndent( 0 )
-                                                        .setIndent( 7+maxNameLen )
-                                                        .setWidth( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 ) );
-            Catch::cout() << "  "
-                    << it->first
-                    << ':'
-                    << std::string( maxNameLen - it->first.size() + 2, ' ' )
-                    << wrapper << '\n';
-        }
-        Catch::cout() << std::endl;
-        return factories.size();
-    }
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
 
-    inline Option<std::size_t> list( Config const& config ) {
-        Option<std::size_t> listedCount;
-        if( config.listTests() || ( config.listExtraInfo() && !config.listTestNamesOnly() ) )
-            listedCount = listedCount.valueOr(0) + listTests( config );
-        if( config.listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
-        if( config.listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( config );
-        if( config.listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters( config );
-        return listedCount;
-    }
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
+
+#endif // CATCH_CONFIG_DISABLE
+
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
+
+namespace Catch {
+
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+
+        using StreamingReporterBase::StreamingReporterBase;
+
+        ~CompactReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+
+    };
 
 } // end namespace Catch
 
-// #included from: internal/catch_run_context.hpp
-#define TWOBLUECUBES_CATCH_RUNNER_IMPL_HPP_INCLUDED
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
+
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
+
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& spec) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
+
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
+
+        void lazyPrint();
+
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
+
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
+
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
+    };
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
+
+// start catch_xmlwriter.h
+
+#include <vector>
+
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
+
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
+
+        void encodeTo( std::ostream& os ) const;
+
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+
+    private:
+        std::string m_str;
+        ForWhat m_forWhat;
+    };
+
+    class XmlWriter {
+    public:
+
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+
+            ~ScopedElement();
+
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
+
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
+
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
+
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
+
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
+
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
+
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+
+        void writeStylesheetRef( std::string const& url );
+
+        XmlWriter& writeBlankLine();
+
+        void ensureTagClosed();
+
+    private:
+
+        void applyFormatting(XmlFormatting fmt);
+
+        void writeDeclaration();
+
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
+    };
+
+}
+
+// end catch_xmlwriter.h
+namespace Catch {
+
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
+
+        ~JunitReporter() override;
+
+        static std::string getDescription();
+
+        void noMatchingTestCases(std::string const& /*spec*/) override;
+
+        void testRunStarting(TestRunInfo const& runInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEndedCumulative() override;
+
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+
+        void writeTestCase(TestCaseNode const& testCaseNode);
+
+        void writeSection( std::string const& className,
+                           std::string const& rootName,
+                           SectionNode const& sectionNode,
+                           bool testOkToFail );
+
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
+
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
+
+namespace Catch {
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
+
+        ~XmlReporter() override;
+
+        static std::string getDescription();
+
+        virtual std::string getStylesheetRef() const;
+
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+
+    public: // StreamingReporterBase
+
+        void noMatchingTestCases(std::string const& s) override;
+
+        void testRunStarting(TestRunInfo const& testInfo) override;
+
+        void testGroupStarting(GroupInfo const& groupInfo) override;
+
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
+
+        void sectionStarting(SectionInfo const& sectionInfo) override;
+
+        void assertionStarting(AssertionInfo const&) override;
+
+        bool assertionEnded(AssertionStats const& assertionStats) override;
+
+        void sectionEnded(SectionStats const& sectionStats) override;
+
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_xml.h
+
+// end catch_external_interfaces.h
+#endif
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
+
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
+
+// start catch_benchmark.hpp
+
+ // Benchmark
+
+// start catch_chronometer.hpp
+
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
+
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
+
+        using default_clock = std::chrono::steady_clock;
+
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
+            }
+        };
+
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_clock.hpp
+// start catch_optimizer.hpp
+
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
+        }
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
+        }
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+        }
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
+
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
+
+#endif
+
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
+
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
+
+// Invoke with a special case for void
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
+
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
+
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
+
+        template <typename Fun>
+        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
+
+                ClockDuration<Clock> elapsed() const { return finished - started; }
+
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
+
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
+
+            int runs() const { return k; }
+
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
+
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
+
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
+
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_chronometer.hpp
+// start catch_environment.hpp
+
+// Environment information
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
+
+ // Execution plan
+
+
+// start catch_benchmark_function.hpp
+
+ // Dumb std::function implementation for consistent call overhead
+
+
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
+
+                    Fun fun;
+                };
+
+                struct do_nothing { void operator()() const {} };
+
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
+
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
+
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
+
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
+
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
+
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
+
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
+
+                void operator()(Chronometer meter) const { f->call(meter); }
+
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
+
+// repeat algorithm
+
+
+#include <type_traits>
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
+
+// Run a function for a minimum amount of time
+
+
+// start catch_measure.hpp
+
+// Measure
+
+
+// start catch_timing.hpp
+
+// Timing
+
+
+#include <tuple>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Func, typename... Args>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_timing.hpp
+#include <utility>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+
+                return { meter.elapsed(), std::move(result), iters };
+            }
+
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
+
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
+
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                Catch::throw_exception(optimized_away_error{});
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_run_for_at_least.hpp
+#include <algorithm>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
+
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
+
+ // Environment measurement
+
+
+// start catch_stats.hpp
+
+// Statistical analysis tools
 
-// #included from: catch_test_case_tracker.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
 
 #include <algorithm>
-#include <string>
-#include <assert.h>
+#include <functional>
 #include <vector>
-#include <stdexcept>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
 
-CATCH_INTERNAL_SUPPRESS_ETD_WARNINGS
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
+
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
+
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
+
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
+
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
+
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
+
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
+
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
+
+                return results;
+            }
+
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
+
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = (std::max)(cumn(a1), 0);
+                auto hi = (std::min)(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
+
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
+
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = (std::min)(
+                    resolution * clock_cost_estimation_tick_limit,
+                    FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
+
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
+
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
+
+ // Run and analyse one benchmark
+
+
+// start catch_sample_analysis.hpp
+
+// Benchmark results
+
+
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
+
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
+
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
+
+                auto env = Detail::measure_environment<Clock>();
+
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
+
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
+
+                    getResultCapture().benchmarkStarting(info);
+
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
+
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
+
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
+
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
+
+            explicit operator bool() {
+                return true;
+            }
+
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
+
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
+
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
+
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
+
+// Constructor and destructor helpers
+
+
+#include <type_traits>
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
+
+                ObjectStorage() : data() {}
+
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
+
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
+
+                ~ObjectStorage() { destruct_on_exit<T>(); }
+
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
+
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
+
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
+
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
+
+                TStorage data;
+            };
+        }
+
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
+
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
+
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+#ifdef CATCH_IMPL
+// start catch_impl.hpp
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
+// Keep these here for external reporters
+// start catch_test_case_tracker.h
+
+#include <string>
+#include <vector>
+#include <memory>
 
 namespace Catch {
 namespace TestCaseTracking {
@@ -6049,23 +7479,38 @@ namespace TestCaseTracking {
         std::string name;
         SourceLineInfo location;
 
-        NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
-        :   name( _name ),
-            location( _location )
-        {}
+        NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+            return lhs.name == rhs.name
+                && lhs.location == rhs.location;
+        }
     };
 
-    struct ITracker : SharedImpl<> {
-        virtual ~ITracker();
+    class ITracker;
+
+    using ITrackerPtr = std::shared_ptr<ITracker>;
+
+    class  ITracker {
+        NameAndLocation m_nameAndLocation;
+
+    public:
+        ITracker(NameAndLocation const& nameAndLoc) :
+            m_nameAndLocation(nameAndLoc)
+        {}
 
         // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
+        NameAndLocation const& nameAndLocation() const {
+            return m_nameAndLocation;
+        }
+
+        virtual ~ITracker();
 
         // dynamic queries
         virtual bool isComplete() const = 0; // Successfully completed or failed
         virtual bool isSuccessfullyCompleted() const = 0;
         virtual bool isOpen() const = 0; // Started but not complete
         virtual bool hasChildren() const = 0;
+        virtual bool hasStarted() const = 0;
 
         virtual ITracker& parent() = 0;
 
@@ -6074,16 +7519,16 @@ namespace TestCaseTracking {
         virtual void fail() = 0;
         virtual void markAsNeedingAnotherRun() = 0;
 
-        virtual void addChild( Ptr<ITracker> const& child ) = 0;
-        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) = 0;
+        virtual void addChild( ITrackerPtr const& child ) = 0;
+        virtual ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) = 0;
         virtual void openChild() = 0;
 
         // Debug/ checking
         virtual bool isSectionTracker() const = 0;
-        virtual bool isIndexTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
     };
 
-    class  TrackerContext {
+    class TrackerContext {
 
         enum RunState {
             NotStarted,
@@ -6091,47 +7536,21 @@ namespace TestCaseTracking {
             CompletedCycle
         };
 
-        Ptr<ITracker> m_rootTracker;
-        ITracker* m_currentTracker;
-        RunState m_runState;
+        ITrackerPtr m_rootTracker;
+        ITracker* m_currentTracker = nullptr;
+        RunState m_runState = NotStarted;
 
     public:
 
-        static TrackerContext& instance() {
-            static TrackerContext s_instance;
-            return s_instance;
-        }
-
-        TrackerContext()
-        :   m_currentTracker( CATCH_NULL ),
-            m_runState( NotStarted )
-        {}
-
         ITracker& startRun();
+        void endRun();
 
-        void endRun() {
-            m_rootTracker.reset();
-            m_currentTracker = CATCH_NULL;
-            m_runState = NotStarted;
-        }
+        void startCycle();
+        void completeCycle();
 
-        void startCycle() {
-            m_currentTracker = m_rootTracker.get();
-            m_runState = Executing;
-        }
-        void completeCycle() {
-            m_runState = CompletedCycle;
-        }
-
-        bool completedCycle() const {
-            return m_runState == CompletedCycle;
-        }
-        ITracker& currentTracker() {
-            return *m_currentTracker;
-        }
-        void setCurrentTracker( ITracker* tracker ) {
-            m_currentTracker = tracker;
-        }
+        bool completedCycle() const;
+        ITracker& currentTracker();
+        void setCurrentTracker( ITracker* tracker );
     };
 
     class TrackerBase : public ITracker {
@@ -6144,274 +7563,2500 @@ namespace TestCaseTracking {
             CompletedSuccessfully,
             Failed
         };
-        class TrackerHasName {
-            NameAndLocation m_nameAndLocation;
-        public:
-            TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
-            bool operator ()( Ptr<ITracker> const& tracker ) {
-                return
-                    tracker->nameAndLocation().name == m_nameAndLocation.name &&
-                    tracker->nameAndLocation().location == m_nameAndLocation.location;
-            }
-        };
-        typedef std::vector<Ptr<ITracker> > Children;
-        NameAndLocation m_nameAndLocation;
+
+        using Children = std::vector<ITrackerPtr>;
         TrackerContext& m_ctx;
         ITracker* m_parent;
         Children m_children;
-        CycleState m_runState;
+        CycleState m_runState = NotStarted;
+
     public:
-        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-        :   m_nameAndLocation( nameAndLocation ),
-            m_ctx( ctx ),
-            m_parent( parent ),
-            m_runState( NotStarted )
-        {}
-        virtual ~TrackerBase();
+        TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
 
-        virtual NameAndLocation const& nameAndLocation() const CATCH_OVERRIDE {
-            return m_nameAndLocation;
-        }
-        virtual bool isComplete() const CATCH_OVERRIDE {
-            return m_runState == CompletedSuccessfully || m_runState == Failed;
-        }
-        virtual bool isSuccessfullyCompleted() const CATCH_OVERRIDE {
-            return m_runState == CompletedSuccessfully;
-        }
-        virtual bool isOpen() const CATCH_OVERRIDE {
-            return m_runState != NotStarted && !isComplete();
-        }
-        virtual bool hasChildren() const CATCH_OVERRIDE {
-            return !m_children.empty();
+        bool isComplete() const override;
+        bool isSuccessfullyCompleted() const override;
+        bool isOpen() const override;
+        bool hasChildren() const override;
+        bool hasStarted() const override {
+            return m_runState != NotStarted;
         }
 
-        virtual void addChild( Ptr<ITracker> const& child ) CATCH_OVERRIDE {
-            m_children.push_back( child );
-        }
+        void addChild( ITrackerPtr const& child ) override;
 
-        virtual ITracker* findChild( NameAndLocation const& nameAndLocation ) CATCH_OVERRIDE {
-            Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
-            return( it != m_children.end() )
-                ? it->get()
-                : CATCH_NULL;
-        }
-        virtual ITracker& parent() CATCH_OVERRIDE {
-            assert( m_parent ); // Should always be non-null except for root
-            return *m_parent;
-        }
+        ITrackerPtr findChild( NameAndLocation const& nameAndLocation ) override;
+        ITracker& parent() override;
 
-        virtual void openChild() CATCH_OVERRIDE {
-            if( m_runState != ExecutingChildren ) {
-                m_runState = ExecutingChildren;
-                if( m_parent )
-                    m_parent->openChild();
-            }
-        }
+        void openChild() override;
 
-        virtual bool isSectionTracker() const CATCH_OVERRIDE { return false; }
-        virtual bool isIndexTracker() const CATCH_OVERRIDE { return false; }
+        bool isSectionTracker() const override;
+        bool isGeneratorTracker() const override;
 
-        void open() {
-            m_runState = Executing;
-            moveToThis();
-            if( m_parent )
-                m_parent->openChild();
-        }
+        void open();
 
-        virtual void close() CATCH_OVERRIDE {
+        void close() override;
+        void fail() override;
+        void markAsNeedingAnotherRun() override;
 
-            // Close any still open children (e.g. generators)
-            while( &m_ctx.currentTracker() != this )
-                m_ctx.currentTracker().close();
-
-            switch( m_runState ) {
-                case NotStarted:
-                case CompletedSuccessfully:
-                case Failed:
-                    throw std::logic_error( "Illogical state" );
-
-                case NeedsAnotherRun:
-                    break;;
-
-                case Executing:
-                    m_runState = CompletedSuccessfully;
-                    break;
-                case ExecutingChildren:
-                    if( m_children.empty() || m_children.back()->isComplete() )
-                        m_runState = CompletedSuccessfully;
-                    break;
-
-                default:
-                    throw std::logic_error( "Unexpected state" );
-            }
-            moveToParent();
-            m_ctx.completeCycle();
-        }
-        virtual void fail() CATCH_OVERRIDE {
-            m_runState = Failed;
-            if( m_parent )
-                m_parent->markAsNeedingAnotherRun();
-            moveToParent();
-            m_ctx.completeCycle();
-        }
-        virtual void markAsNeedingAnotherRun() CATCH_OVERRIDE {
-            m_runState = NeedsAnotherRun;
-        }
     private:
-        void moveToParent() {
-            assert( m_parent );
-            m_ctx.setCurrentTracker( m_parent );
-        }
-        void moveToThis() {
-            m_ctx.setCurrentTracker( this );
-        }
+        void moveToParent();
+        void moveToThis();
     };
 
     class SectionTracker : public TrackerBase {
         std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
     public:
-        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-        :   TrackerBase( nameAndLocation, ctx, parent )
-        {
-            if( parent ) {
-                while( !parent->isSectionTracker() )
-                    parent = &parent->parent();
+        SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
 
-                SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
-                addNextFilters( parentSection.m_filters );
-            }
-        }
-        virtual ~SectionTracker();
+        bool isSectionTracker() const override;
 
-        virtual bool isSectionTracker() const CATCH_OVERRIDE { return true; }
+        bool isComplete() const override;
 
-        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
-            SectionTracker* section = CATCH_NULL;
+        static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
 
-            ITracker& currentTracker = ctx.currentTracker();
-            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                assert( childTracker );
-                assert( childTracker->isSectionTracker() );
-                section = static_cast<SectionTracker*>( childTracker );
-            }
-            else {
-                section = new SectionTracker( nameAndLocation, ctx, &currentTracker );
-                currentTracker.addChild( section );
-            }
-            if( !ctx.completedCycle() )
-                section->tryOpen();
-            return *section;
-        }
+        void tryOpen();
 
-        void tryOpen() {
-            if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
-                open();
-        }
-
-        void addInitialFilters( std::vector<std::string> const& filters ) {
-            if( !filters.empty() ) {
-                m_filters.push_back(""); // Root - should never be consulted
-                m_filters.push_back(""); // Test Case - not a section filter
-                m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
-            }
-        }
-        void addNextFilters( std::vector<std::string> const& filters ) {
-            if( filters.size() > 1 )
-                m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
-        }
+        void addInitialFilters( std::vector<std::string> const& filters );
+        void addNextFilters( std::vector<std::string> const& filters );
+        //! Returns filters active in this tracker
+        std::vector<std::string> const& getFilters() const;
+        //! Returns whitespace-trimmed name of the tracked section
+        std::string const& trimmedName() const;
     };
 
-    class IndexTracker : public TrackerBase {
-        int m_size;
-        int m_index;
-    public:
-        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
-        :   TrackerBase( nameAndLocation, ctx, parent ),
-            m_size( size ),
-            m_index( -1 )
-        {}
-        virtual ~IndexTracker();
-
-        virtual bool isIndexTracker() const CATCH_OVERRIDE { return true; }
-
-        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
-            IndexTracker* tracker = CATCH_NULL;
-
-            ITracker& currentTracker = ctx.currentTracker();
-            if( ITracker* childTracker = currentTracker.findChild( nameAndLocation ) ) {
-                assert( childTracker );
-                assert( childTracker->isIndexTracker() );
-                tracker = static_cast<IndexTracker*>( childTracker );
-            }
-            else {
-                tracker = new IndexTracker( nameAndLocation, ctx, &currentTracker, size );
-                currentTracker.addChild( tracker );
-            }
-
-            if( !ctx.completedCycle() && !tracker->isComplete() ) {
-                if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
-                    tracker->moveNext();
-                tracker->open();
-            }
-
-            return *tracker;
-        }
-
-        int index() const { return m_index; }
-
-        void moveNext() {
-            m_index++;
-            m_children.clear();
-        }
-
-        virtual void close() CATCH_OVERRIDE {
-            TrackerBase::close();
-            if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
-                m_runState = Executing;
-        }
-    };
-
-    inline ITracker& TrackerContext::startRun() {
-        m_rootTracker = new SectionTracker( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, CATCH_NULL );
-        m_currentTracker = CATCH_NULL;
-        m_runState = Executing;
-        return *m_rootTracker;
-    }
-
 } // namespace TestCaseTracking
 
 using TestCaseTracking::ITracker;
 using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
 
 } // namespace Catch
 
-CATCH_INTERNAL_UNSUPPRESS_ETD_WARNINGS
+// end catch_test_case_tracker.h
 
-// #included from: catch_fatal_condition.hpp
-#define TWOBLUECUBES_CATCH_FATAL_CONDITION_H_INCLUDED
+// start catch_leak_detector.h
 
 namespace Catch {
 
-    // Report the error condition
-    inline void reportFatal( std::string const& message ) {
-        IContext& context = Catch::getCurrentContext();
-        IResultCapture* resultCapture = context.getResultCapture();
-        resultCapture->handleFatalErrorCondition( message );
+    struct LeakDetector {
+        LeakDetector();
+        ~LeakDetector();
+    };
+
+}
+// end catch_leak_detector.h
+// Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = (std::min)(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return (std::min)(var_out(1), var_out((std::min)(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
+// start catch_approx.cpp
+
+#include <cmath>
+#include <limits>
+
+namespace {
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+}
+
+namespace Catch {
+namespace Detail {
+
+    Approx::Approx ( double value )
+    :   m_epsilon( std::numeric_limits<float>::epsilon()*100 ),
+        m_margin( 0.0 ),
+        m_scale( 0.0 ),
+        m_value( value )
+    {}
+
+    Approx Approx::custom() {
+        return Approx( 0 );
+    }
+
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
+    std::string Approx::toString() const {
+        ReusableStringStream rss;
+        rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+        return rss.str();
+    }
+
+    bool Approx::equalityComparisonImpl(const double other) const {
+        // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+        // Thanks to Richard Harris for his help refining the scaled margin value
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
+    }
+
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
+std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
+    return value.toString();
+}
+
+} // end namespace Catch
+// end catch_approx.cpp
+// start catch_assertionhandler.cpp
+
+// start catch_debugger.h
+
+namespace Catch {
+    bool isDebuggerActive();
+}
+
+#ifdef CATCH_PLATFORM_MAC
+
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #endif
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
+
+#elif defined(CATCH_PLATFORM_LINUX)
+    // If we can use inline assembler, do it because this allows us to break
+    // directly at the location of the failing check instead of breaking inside
+    // raise() called from it, i.e. one stack frame below.
+    #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+        #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+    #else // Fall back to the generic way.
+        #include <signal.h>
+
+        #define CATCH_TRAP() raise(SIGTRAP)
+    #endif
+#elif defined(_MSC_VER)
+    #define CATCH_TRAP() __debugbreak()
+#elif defined(__MINGW32__)
+    extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+    #define CATCH_TRAP() DebugBreak()
+#endif
+
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
+#endif
+
+// end catch_debugger.h
+// start catch_run_context.h
+
+// start catch_fatal_condition.h
+
+#include <cassert>
+
+namespace Catch {
+
+    // Wrapper for platform-specific fatal error (signals/SEH) handlers
+    //
+    // Tries to be cooperative with other handlers, and not step over
+    // other handlers. This means that unknown structured exceptions
+    // are passed on, previous signal handlers are called, and so on.
+    //
+    // Can only be instantiated once, and assumes that once a signal
+    // is caught, the binary will end up terminating. Thus, there
+    class FatalConditionHandler {
+        bool m_started = false;
+
+        // Install/disengage implementation for specific platform.
+        // Should be if-defed to work on current platform, can assume
+        // engage-disengage 1:1 pairing.
+        void engage_platform();
+        void disengage_platform();
+    public:
+        // Should also have platform-specific implementations as needed
+        FatalConditionHandler();
+        ~FatalConditionHandler();
+
+        void engage() {
+            assert(!m_started && "Handler cannot be installed twice.");
+            m_started = true;
+            engage_platform();
+        }
+
+        void disengage() {
+            assert(m_started && "Handler cannot be uninstalled without being installed first");
+            m_started = false;
+            disengage_platform();
+        }
+    };
+
+    //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+    class FatalConditionHandlerGuard {
+        FatalConditionHandler* m_handler;
+    public:
+        FatalConditionHandlerGuard(FatalConditionHandler* handler):
+            m_handler(handler) {
+            m_handler->engage();
+        }
+        ~FatalConditionHandlerGuard() {
+            m_handler->disengage();
+        }
+    };
+
+} // end namespace Catch
+
+// end catch_fatal_condition.h
+#include <string>
+
+namespace Catch {
+
+    struct IMutableContext;
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class RunContext : public IResultCapture, public IRunner {
+
+    public:
+        RunContext( RunContext const& ) = delete;
+        RunContext& operator =( RunContext const& ) = delete;
+
+        explicit RunContext( IConfigPtr const& _config, IStreamingReporterPtr&& reporter );
+
+        ~RunContext() override;
+
+        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount );
+        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount );
+
+        Totals runTest(TestCase const& testCase);
+
+        IConfigPtr config() const;
+        IStreamingReporter& reporter() const;
+
+    public: // IResultCapture
+
+        // Assertion handlers
+        void handleExpr
+                (   AssertionInfo const& info,
+                    ITransientExpression const& expr,
+                    AssertionReaction& reaction ) override;
+        void handleMessage
+                (   AssertionInfo const& info,
+                    ResultWas::OfType resultType,
+                    StringRef const& message,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedExceptionNotThrown
+                (   AssertionInfo const& info,
+                    AssertionReaction& reaction ) override;
+        void handleUnexpectedInflightException
+                (   AssertionInfo const& info,
+                    std::string const& message,
+                    AssertionReaction& reaction ) override;
+        void handleIncomplete
+                (   AssertionInfo const& info ) override;
+        void handleNonExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    AssertionReaction &reaction ) override;
+
+        bool sectionStarted( SectionInfo const& sectionInfo, Counts& assertions ) override;
+
+        void sectionEnded( SectionEndInfo const& endInfo ) override;
+        void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
+
+        auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
+        void benchmarkStarting( BenchmarkInfo const& info ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void pushScopedMessage( MessageInfo const& message ) override;
+        void popScopedMessage( MessageInfo const& message ) override;
+
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
+        std::string getCurrentTestName() const override;
+
+        const AssertionResult* getLastResult() const override;
+
+        void exceptionEarlyReported() override;
+
+        void handleFatalErrorCondition( StringRef message ) override;
+
+        bool lastAssertionPassed() override;
+
+        void assertionPassed() override;
+
+    public:
+        // !TBD We need to do this another way!
+        bool aborting() const final;
+
+    private:
+
+        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+        void invokeActiveTestCase();
+
+        void resetAssertionInfo();
+        bool testForMissingAssertions( Counts& assertions );
+
+        void assertionEnded( AssertionResult const& result );
+        void reportExpr
+                (   AssertionInfo const &info,
+                    ResultWas::OfType resultType,
+                    ITransientExpression const *expr,
+                    bool negated );
+
+        void populateReaction( AssertionReaction& reaction );
+
+    private:
+
+        void handleUnfinishedSections();
+
+        TestRunInfo m_runInfo;
+        IMutableContext& m_context;
+        TestCase const* m_activeTestCase = nullptr;
+        ITracker* m_testCaseTracker = nullptr;
+        Option<AssertionResult> m_lastResult;
+
+        IConfigPtr m_config;
+        Totals m_totals;
+        IStreamingReporterPtr m_reporter;
+        std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+        AssertionInfo m_lastAssertionInfo;
+        std::vector<SectionEndInfo> m_unfinishedSections;
+        std::vector<ITracker*> m_activeSections;
+        TrackerContext m_trackerContext;
+        FatalConditionHandler m_fatalConditionhandler;
+        bool m_lastAssertionPassed = false;
+        bool m_shouldReportUnexpected = true;
+        bool m_includeSuccessfulResults;
+    };
+
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
+} // end namespace Catch
+
+// end catch_run_context.h
+namespace Catch {
+
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
+    }
+
+    LazyExpression::LazyExpression( bool isNegated )
+    :   m_isNegated( isNegated )
+    {}
+
+    LazyExpression::LazyExpression( LazyExpression const& other ) : m_isNegated( other.m_isNegated ) {}
+
+    LazyExpression::operator bool() const {
+        return m_transientExpression != nullptr;
+    }
+
+    auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream& {
+        if( lazyExpr.m_isNegated )
+            os << "!";
+
+        if( lazyExpr ) {
+            if( lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression() )
+                os << "(" << *lazyExpr.m_transientExpression << ")";
+            else
+                os << *lazyExpr.m_transientExpression;
+        }
+        else {
+            os << "{** error - unchecked empty expression requested **}";
+        }
+        return os;
+    }
+
+    AssertionHandler::AssertionHandler
+        (   StringRef const& macroName,
+            SourceLineInfo const& lineInfo,
+            StringRef capturedExpression,
+            ResultDisposition::Flags resultDisposition )
+    :   m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+        m_resultCapture( getResultCapture() )
+    {}
+
+    void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+        m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+    }
+    void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef const& message) {
+        m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+    }
+
+    auto AssertionHandler::allowThrows() const -> bool {
+        return getCurrentContext().getConfig()->allowThrows();
+    }
+
+    void AssertionHandler::complete() {
+        setCompleted();
+        if( m_reaction.shouldDebugBreak ) {
+
+            // If you find your debugger stopping you here then go one level up on the
+            // call-stack for the code that caused it (typically a failed assertion)
+
+            // (To go back to the test and change execution, jump over the throw, next)
+            CATCH_BREAK_INTO_DEBUGGER();
+        }
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+            throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
+    }
+    void AssertionHandler::setCompleted() {
+        m_completed = true;
+    }
+
+    void AssertionHandler::handleUnexpectedInflightException() {
+        m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+    }
+
+    void AssertionHandler::handleExceptionThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+    void AssertionHandler::handleExceptionNotThrownAsExpected() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+        m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+    }
+
+    void AssertionHandler::handleThrowingCallSkipped() {
+        m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+    }
+
+    // This is the overload that takes a string and infers the Equals matcher from it
+    // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
+        handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
     }
 
 } // namespace Catch
+// end catch_assertionhandler.cpp
+// start catch_assertionresult.cpp
 
-#if defined ( CATCH_PLATFORM_WINDOWS ) /////////////////////////////////////////
-// #included from: catch_windows_h_proxy.h
+namespace Catch {
+    AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+        lazyExpression(_lazyExpression),
+        resultType(_resultType) {}
 
-#define TWOBLUECUBES_CATCH_WINDOWS_H_PROXY_H_INCLUDED
+    std::string AssertionResultData::reconstructExpression() const {
 
-#ifdef CATCH_DEFINES_NOMINMAX
+        if( reconstructedExpression.empty() ) {
+            if( lazyExpression ) {
+                ReusableStringStream rss;
+                rss << lazyExpression;
+                reconstructedExpression = rss.str();
+            }
+        }
+        return reconstructedExpression;
+    }
+
+    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
+    :   m_info( info ),
+        m_resultData( data )
+    {}
+
+    // Result was a success
+    bool AssertionResult::succeeded() const {
+        return Catch::isOk( m_resultData.resultType );
+    }
+
+    // Result was a success, or failure is suppressed
+    bool AssertionResult::isOk() const {
+        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+    }
+
+    ResultWas::OfType AssertionResult::getResultType() const {
+        return m_resultData.resultType;
+    }
+
+    bool AssertionResult::hasExpression() const {
+        return !m_info.capturedExpression.empty();
+    }
+
+    bool AssertionResult::hasMessage() const {
+        return !m_resultData.message.empty();
+    }
+
+    std::string AssertionResult::getExpression() const {
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
+    }
+
+    std::string AssertionResult::getExpressionInMacro() const {
+        std::string expr;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
+        else {
+            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+            expr += m_info.macroName;
+            expr += "( ";
+            expr += m_info.capturedExpression;
+            expr += " )";
+        }
+        return expr;
+    }
+
+    bool AssertionResult::hasExpandedExpression() const {
+        return hasExpression() && getExpandedExpression() != getExpression();
+    }
+
+    std::string AssertionResult::getExpandedExpression() const {
+        std::string expr = m_resultData.reconstructExpression();
+        return expr.empty()
+                ? getExpression()
+                : expr;
+    }
+
+    std::string AssertionResult::getMessage() const {
+        return m_resultData.message;
+    }
+    SourceLineInfo AssertionResult::getSourceInfo() const {
+        return m_info.lineInfo;
+    }
+
+    StringRef AssertionResult::getTestMacroName() const {
+        return m_info.macroName;
+    }
+
+} // end namespace Catch
+// end catch_assertionresult.cpp
+// start catch_capture_matchers.cpp
+
+namespace Catch {
+
+    using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
+
+    // This is the general overload that takes a any string matcher
+    // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+    // the Equals matcher (so the header does not mention matchers)
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
+        std::string exceptionMessage = Catch::translateActiveException();
+        MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
+        handler.handleExpr( expr );
+    }
+
+} // namespace Catch
+// end catch_capture_matchers.cpp
+// start catch_commandline.cpp
+
+// start catch_commandline.h
+
+// start catch_clara.h
+
+// Use Catch's value for console width (store Clara's off to the side, if present)
+#ifdef CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#undef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#endif
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CONFIG_CONSOLE_WIDTH-1
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wweak-vtables"
+#pragma clang diagnostic ignored "-Wexit-time-destructors"
+#pragma clang diagnostic ignored "-Wshadow"
+#endif
+
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
+
+// Clara v1.1.5
+
+
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
+
+// ----------- #included from clara_textflow.hpp -----------
+
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
+
+
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
+
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+namespace clara {
+namespace TextFlow {
+
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
+
+class Columns;
+
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
+
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
+
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto operator + (Column const& other)->Columns;
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+class Spacer : public Column {
+
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
+
+class Columns {
+	std::vector<Column> m_columns;
+
+public:
+
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
+
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
+
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
+
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
+
+}
+}
+
+// ----------- end of #include from clara_textflow.hpp -----------
+// ........... back in clara.hpp
+
+#include <cctype>
+#include <string>
+#include <memory>
+#include <set>
+#include <algorithm>
+
+#if !defined(CATCH_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#define CATCH_PLATFORM_WINDOWS
+#endif
+
+namespace Catch { namespace clara {
+namespace detail {
+
+    // Traits for extracting arg and return type of lambdas (for single argument lambdas)
+    template<typename L>
+    struct UnaryLambdaTraits : UnaryLambdaTraits<decltype( &L::operator() )> {};
+
+    template<typename ClassT, typename ReturnT, typename... Args>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( Args... ) const> {
+        static const bool isValid = false;
+    };
+
+    template<typename ClassT, typename ReturnT, typename ArgT>
+    struct UnaryLambdaTraits<ReturnT( ClassT::* )( ArgT ) const> {
+        static const bool isValid = true;
+        using ArgType = typename std::remove_const<typename std::remove_reference<ArgT>::type>::type;
+        using ReturnType = ReturnT;
+    };
+
+    class TokenStream;
+
+    // Transport for raw args (copied from main args, or supplied via init list for testing)
+    class Args {
+        friend TokenStream;
+        std::string m_exeName;
+        std::vector<std::string> m_args;
+
+    public:
+        Args( int argc, char const* const* argv )
+            : m_exeName(argv[0]),
+              m_args(argv + 1, argv + argc) {}
+
+        Args( std::initializer_list<std::string> args )
+        :   m_exeName( *args.begin() ),
+            m_args( args.begin()+1, args.end() )
+        {}
+
+        auto exeName() const -> std::string {
+            return m_exeName;
+        }
+    };
+
+    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+    // may encode an option + its argument if the : or = form is used
+    enum class TokenType {
+        Option, Argument
+    };
+    struct Token {
+        TokenType type;
+        std::string token;
+    };
+
+    inline auto isOptPrefix( char c ) -> bool {
+        return c == '-'
+#ifdef CATCH_PLATFORM_WINDOWS
+            || c == '/'
+#endif
+        ;
+    }
+
+    // Abstracts iterators into args as a stream of tokens, with option arguments uniformly handled
+    class TokenStream {
+        using Iterator = std::vector<std::string>::const_iterator;
+        Iterator it;
+        Iterator itEnd;
+        std::vector<Token> m_tokenBuffer;
+
+        void loadBuffer() {
+            m_tokenBuffer.resize( 0 );
+
+            // Skip any empty strings
+            while( it != itEnd && it->empty() )
+                ++it;
+
+            if( it != itEnd ) {
+                auto const &next = *it;
+                if( isOptPrefix( next[0] ) ) {
+                    auto delimiterPos = next.find_first_of( " :=" );
+                    if( delimiterPos != std::string::npos ) {
+                        m_tokenBuffer.push_back( { TokenType::Option, next.substr( 0, delimiterPos ) } );
+                        m_tokenBuffer.push_back( { TokenType::Argument, next.substr( delimiterPos + 1 ) } );
+                    } else {
+                        if( next[1] != '-' && next.size() > 2 ) {
+                            std::string opt = "- ";
+                            for( size_t i = 1; i < next.size(); ++i ) {
+                                opt[1] = next[i];
+                                m_tokenBuffer.push_back( { TokenType::Option, opt } );
+                            }
+                        } else {
+                            m_tokenBuffer.push_back( { TokenType::Option, next } );
+                        }
+                    }
+                } else {
+                    m_tokenBuffer.push_back( { TokenType::Argument, next } );
+                }
+            }
+        }
+
+    public:
+        explicit TokenStream( Args const &args ) : TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+
+        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+            loadBuffer();
+        }
+
+        explicit operator bool() const {
+            return !m_tokenBuffer.empty() || it != itEnd;
+        }
+
+        auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
+
+        auto operator*() const -> Token {
+            assert( !m_tokenBuffer.empty() );
+            return m_tokenBuffer.front();
+        }
+
+        auto operator->() const -> Token const * {
+            assert( !m_tokenBuffer.empty() );
+            return &m_tokenBuffer.front();
+        }
+
+        auto operator++() -> TokenStream & {
+            if( m_tokenBuffer.size() >= 2 ) {
+                m_tokenBuffer.erase( m_tokenBuffer.begin() );
+            } else {
+                if( it != itEnd )
+                    ++it;
+                loadBuffer();
+            }
+            return *this;
+        }
+    };
+
+    class ResultBase {
+    public:
+        enum Type {
+            Ok, LogicError, RuntimeError
+        };
+
+    protected:
+        ResultBase( Type type ) : m_type( type ) {}
+        virtual ~ResultBase() = default;
+
+        virtual void enforceOk() const = 0;
+
+        Type m_type;
+    };
+
+    template<typename T>
+    class ResultValueBase : public ResultBase {
+    public:
+        auto value() const -> T const & {
+            enforceOk();
+            return m_value;
+        }
+
+    protected:
+        ResultValueBase( Type type ) : ResultBase( type ) {}
+
+        ResultValueBase( ResultValueBase const &other ) : ResultBase( other ) {
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+        }
+
+        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+            new( &m_value ) T( value );
+        }
+
+        auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
+            if( m_type == ResultBase::Ok )
+                m_value.~T();
+            ResultBase::operator=(other);
+            if( m_type == ResultBase::Ok )
+                new( &m_value ) T( other.m_value );
+            return *this;
+        }
+
+        ~ResultValueBase() override {
+            if( m_type == Ok )
+                m_value.~T();
+        }
+
+        union {
+            T m_value;
+        };
+    };
+
+    template<>
+    class ResultValueBase<void> : public ResultBase {
+    protected:
+        using ResultBase::ResultBase;
+    };
+
+    template<typename T = void>
+    class BasicResult : public ResultValueBase<T> {
+    public:
+        template<typename U>
+        explicit BasicResult( BasicResult<U> const &other )
+        :   ResultValueBase<T>( other.type() ),
+            m_errorMessage( other.errorMessage() )
+        {
+            assert( type() != ResultBase::Ok );
+        }
+
+        template<typename U>
+        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+        static auto ok() -> BasicResult { return { ResultBase::Ok }; }
+        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+
+        explicit operator bool() const { return m_type == ResultBase::Ok; }
+        auto type() const -> ResultBase::Type { return m_type; }
+        auto errorMessage() const -> std::string { return m_errorMessage; }
+
+    protected:
+        void enforceOk() const override {
+
+            // Errors shouldn't reach this point, but if they do
+            // the actual error message will be in m_errorMessage
+            assert( m_type != ResultBase::LogicError );
+            assert( m_type != ResultBase::RuntimeError );
+            if( m_type != ResultBase::Ok )
+                std::abort();
+        }
+
+        std::string m_errorMessage; // Only populated if resultType is an error
+
+        BasicResult( ResultBase::Type type, std::string const &message )
+        :   ResultValueBase<T>(type),
+            m_errorMessage(message)
+        {
+            assert( m_type != ResultBase::Ok );
+        }
+
+        using ResultValueBase<T>::ResultValueBase;
+        using ResultBase::m_type;
+    };
+
+    enum class ParseResultType {
+        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
+    };
+
+    class ParseState {
+    public:
+
+        ParseState( ParseResultType type, TokenStream const &remainingTokens )
+        : m_type(type),
+          m_remainingTokens( remainingTokens )
+        {}
+
+        auto type() const -> ParseResultType { return m_type; }
+        auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
+
+    private:
+        ParseResultType m_type;
+        TokenStream m_remainingTokens;
+    };
+
+    using Result = BasicResult<void>;
+    using ParserResult = BasicResult<ParseResultType>;
+    using InternalParseResult = BasicResult<ParseState>;
+
+    struct HelpColumns {
+        std::string left;
+        std::string right;
+    };
+
+    template<typename T>
+    inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
+        std::stringstream ss;
+        ss << source;
+        ss >> target;
+        if( ss.fail() )
+            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
+        else
+            return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, std::string& target ) -> ParserResult {
+        target = source;
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+    inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
+        std::string srcLC = source;
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( unsigned char c ) { return static_cast<char>( std::tolower(c) ); } );
+        if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
+            target = true;
+        else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
+            target = false;
+        else
+            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+        return ParserResult::ok( ParseResultType::Matched );
+    }
+#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+    template<typename T>
+    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+        T temp;
+        auto result = convertInto( source, temp );
+        if( result )
+            target = std::move(temp);
+        return result;
+    }
+#endif // CLARA_CONFIG_OPTIONAL_TYPE
+
+    struct NonCopyable {
+        NonCopyable() = default;
+        NonCopyable( NonCopyable const & ) = delete;
+        NonCopyable( NonCopyable && ) = delete;
+        NonCopyable &operator=( NonCopyable const & ) = delete;
+        NonCopyable &operator=( NonCopyable && ) = delete;
+    };
+
+    struct BoundRef : NonCopyable {
+        virtual ~BoundRef() = default;
+        virtual auto isContainer() const -> bool { return false; }
+        virtual auto isFlag() const -> bool { return false; }
+    };
+    struct BoundValueRefBase : BoundRef {
+        virtual auto setValue( std::string const &arg ) -> ParserResult = 0;
+    };
+    struct BoundFlagRefBase : BoundRef {
+        virtual auto setFlag( bool flag ) -> ParserResult = 0;
+        virtual auto isFlag() const -> bool { return true; }
+    };
+
+    template<typename T>
+    struct BoundValueRef : BoundValueRefBase {
+        T &m_ref;
+
+        explicit BoundValueRef( T &ref ) : m_ref( ref ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return convertInto( arg, m_ref );
+        }
+    };
+
+    template<typename T>
+    struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+        std::vector<T> &m_ref;
+
+        explicit BoundValueRef( std::vector<T> &ref ) : m_ref( ref ) {}
+
+        auto isContainer() const -> bool override { return true; }
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            T temp;
+            auto result = convertInto( arg, temp );
+            if( result )
+                m_ref.push_back( temp );
+            return result;
+        }
+    };
+
+    struct BoundFlagRef : BoundFlagRefBase {
+        bool &m_ref;
+
+        explicit BoundFlagRef( bool &ref ) : m_ref( ref ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            m_ref = flag;
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ReturnType>
+    struct LambdaInvoker {
+        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            return lambda( arg );
+        }
+    };
+
+    template<>
+    struct LambdaInvoker<void> {
+        template<typename L, typename ArgType>
+        static auto invoke( L const &lambda, ArgType const &arg ) -> ParserResult {
+            lambda( arg );
+            return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    template<typename ArgType, typename L>
+    inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
+        ArgType temp{};
+        auto result = convertInto( arg, temp );
+        return !result
+           ? result
+           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
+    }
+
+    template<typename L>
+    struct BoundLambda : BoundValueRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        explicit BoundLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setValue( std::string const &arg ) -> ParserResult override {
+            return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>( m_lambda, arg );
+        }
+    };
+
+    template<typename L>
+    struct BoundFlagLambda : BoundFlagRefBase {
+        L m_lambda;
+
+        static_assert( UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument" );
+        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+
+        explicit BoundFlagLambda( L const &lambda ) : m_lambda( lambda ) {}
+
+        auto setFlag( bool flag ) -> ParserResult override {
+            return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( m_lambda, flag );
+        }
+    };
+
+    enum class Optionality { Optional, Required };
+
+    struct Parser;
+
+    class ParserBase {
+    public:
+        virtual ~ParserBase() = default;
+        virtual auto validate() const -> Result { return Result::ok(); }
+        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+        virtual auto cardinality() const -> size_t { return 1; }
+
+        auto parse( Args const &args ) const -> InternalParseResult {
+            return parse( args.exeName(), TokenStream( args ) );
+        }
+    };
+
+    template<typename DerivedT>
+    class ComposableParserImpl : public ParserBase {
+    public:
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser;
+
+		template<typename T>
+        auto operator+( T const &other ) const -> Parser;
+    };
+
+    // Common code and state for Args and Opts
+    template<typename DerivedT>
+    class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+    protected:
+        Optionality m_optionality = Optionality::Optional;
+        std::shared_ptr<BoundRef> m_ref;
+        std::string m_hint;
+        std::string m_description;
+
+        explicit ParserRefImpl( std::shared_ptr<BoundRef> const &ref ) : m_ref( ref ) {}
+
+    public:
+        template<typename T>
+        ParserRefImpl( T &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+            m_hint( hint )
+        {}
+
+        template<typename LambdaT>
+        ParserRefImpl( LambdaT const &ref, std::string const &hint )
+        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+            m_hint(hint)
+        {}
+
+        auto operator()( std::string const &description ) -> DerivedT & {
+            m_description = description;
+            return static_cast<DerivedT &>( *this );
+        }
+
+        auto optional() -> DerivedT & {
+            m_optionality = Optionality::Optional;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto required() -> DerivedT & {
+            m_optionality = Optionality::Required;
+            return static_cast<DerivedT &>( *this );
+        };
+
+        auto isOptional() const -> bool {
+            return m_optionality == Optionality::Optional;
+        }
+
+        auto cardinality() const -> size_t override {
+            if( m_ref->isContainer() )
+                return 0;
+            else
+                return 1;
+        }
+
+        auto hint() const -> std::string { return m_hint; }
+    };
+
+    class ExeName : public ComposableParserImpl<ExeName> {
+        std::shared_ptr<std::string> m_name;
+        std::shared_ptr<BoundValueRefBase> m_ref;
+
+        template<typename LambdaT>
+        static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+            return std::make_shared<BoundLambda<LambdaT>>( lambda) ;
+        }
+
+    public:
+        ExeName() : m_name( std::make_shared<std::string>( "<executable>" ) ) {}
+
+        explicit ExeName( std::string &ref ) : ExeName() {
+            m_ref = std::make_shared<BoundValueRef<std::string>>( ref );
+        }
+
+        template<typename LambdaT>
+        explicit ExeName( LambdaT const& lambda ) : ExeName() {
+            m_ref = std::make_shared<BoundLambda<LambdaT>>( lambda );
+        }
+
+        // The exe name is not parsed out of the normal tokens, but is handled specially
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+        }
+
+        auto name() const -> std::string { return *m_name; }
+        auto set( std::string const& newName ) -> ParserResult {
+
+            auto lastSlash = newName.find_last_of( "\\/" );
+            auto filename = ( lastSlash == std::string::npos )
+                    ? newName
+                    : newName.substr( lastSlash+1 );
+
+            *m_name = filename;
+            if( m_ref )
+                return m_ref->setValue( filename );
+            else
+                return ParserResult::ok( ParseResultType::Matched );
+        }
+    };
+
+    class Arg : public ParserRefImpl<Arg> {
+    public:
+        using ParserRefImpl::ParserRefImpl;
+
+        auto parse( std::string const &, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            auto const &token = *remainingTokens;
+            if( token.type != TokenType::Argument )
+                return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+
+            assert( !m_ref->isFlag() );
+            auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+
+            auto result = valueRef->setValue( remainingTokens->token );
+            if( !result )
+                return InternalParseResult( result );
+            else
+                return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+        }
+    };
+
+    inline auto normaliseOpt( std::string const &optName ) -> std::string {
+#ifdef CATCH_PLATFORM_WINDOWS
+        if( optName[0] == '/' )
+            return "-" + optName.substr( 1 );
+        else
+#endif
+            return optName;
+    }
+
+    class Opt : public ParserRefImpl<Opt> {
+    protected:
+        std::vector<std::string> m_optNames;
+
+    public:
+        template<typename LambdaT>
+        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+
+        explicit Opt( bool &ref ) : ParserRefImpl( std::make_shared<BoundFlagRef>( ref ) ) {}
+
+        template<typename LambdaT>
+        Opt( LambdaT const &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        template<typename T>
+        Opt( T &ref, std::string const &hint ) : ParserRefImpl( ref, hint ) {}
+
+        auto operator[]( std::string const &optName ) -> Opt & {
+            m_optNames.push_back( optName );
+            return *this;
+        }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::ostringstream oss;
+            bool first = true;
+            for( auto const &opt : m_optNames ) {
+                if (first)
+                    first = false;
+                else
+                    oss << ", ";
+                oss << opt;
+            }
+            if( !m_hint.empty() )
+                oss << " <" << m_hint << ">";
+            return { { oss.str(), m_description } };
+        }
+
+        auto isMatch( std::string const &optToken ) const -> bool {
+            auto normalisedToken = normaliseOpt( optToken );
+            for( auto const &name : m_optNames ) {
+                if( normaliseOpt( name ) == normalisedToken )
+                    return true;
+            }
+            return false;
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const&, TokenStream const &tokens ) const -> InternalParseResult override {
+            auto validationResult = validate();
+            if( !validationResult )
+                return InternalParseResult( validationResult );
+
+            auto remainingTokens = tokens;
+            if( remainingTokens && remainingTokens->type == TokenType::Option ) {
+                auto const &token = *remainingTokens;
+                if( isMatch(token.token ) ) {
+                    if( m_ref->isFlag() ) {
+                        auto flagRef = static_cast<detail::BoundFlagRefBase*>( m_ref.get() );
+                        auto result = flagRef->setFlag( true );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    } else {
+                        auto valueRef = static_cast<detail::BoundValueRefBase*>( m_ref.get() );
+                        ++remainingTokens;
+                        if( !remainingTokens )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto const &argToken = *remainingTokens;
+                        if( argToken.type != TokenType::Argument )
+                            return InternalParseResult::runtimeError( "Expected argument following " + token.token );
+                        auto result = valueRef->setValue( argToken.token );
+                        if( !result )
+                            return InternalParseResult( result );
+                        if( result.value() == ParseResultType::ShortCircuitAll )
+                            return InternalParseResult::ok( ParseState( result.value(), remainingTokens ) );
+                    }
+                    return InternalParseResult::ok( ParseState( ParseResultType::Matched, ++remainingTokens ) );
+                }
+            }
+            return InternalParseResult::ok( ParseState( ParseResultType::NoMatch, remainingTokens ) );
+        }
+
+        auto validate() const -> Result override {
+            if( m_optNames.empty() )
+                return Result::logicError( "No options supplied to Opt" );
+            for( auto const &name : m_optNames ) {
+                if( name.empty() )
+                    return Result::logicError( "Option name cannot be empty" );
+#ifdef CATCH_PLATFORM_WINDOWS
+                if( name[0] != '-' && name[0] != '/' )
+                    return Result::logicError( "Option name must begin with '-' or '/'" );
+#else
+                if( name[0] != '-' )
+                    return Result::logicError( "Option name must begin with '-'" );
+#endif
+            }
+            return ParserRefImpl::validate();
+        }
+    };
+
+    struct Help : Opt {
+        Help( bool &showHelpFlag )
+        :   Opt([&]( bool flag ) {
+                showHelpFlag = flag;
+                return ParserResult::ok( ParseResultType::ShortCircuitAll );
+            })
+        {
+            static_cast<Opt &>( *this )
+                    ("display usage information")
+                    ["-?"]["-h"]["--help"]
+                    .optional();
+        }
+    };
+
+    struct Parser : ParserBase {
+
+        mutable ExeName m_exeName;
+        std::vector<Opt> m_options;
+        std::vector<Arg> m_args;
+
+        auto operator|=( ExeName const &exeName ) -> Parser & {
+            m_exeName = exeName;
+            return *this;
+        }
+
+        auto operator|=( Arg const &arg ) -> Parser & {
+            m_args.push_back(arg);
+            return *this;
+        }
+
+        auto operator|=( Opt const &opt ) -> Parser & {
+            m_options.push_back(opt);
+            return *this;
+        }
+
+        auto operator|=( Parser const &other ) -> Parser & {
+            m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
+            m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
+            return *this;
+        }
+
+        template<typename T>
+        auto operator|( T const &other ) const -> Parser {
+            return Parser( *this ) |= other;
+        }
+
+        // Forward deprecated interface with '+' instead of '|'
+        template<typename T>
+        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+        template<typename T>
+        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+
+        auto getHelpColumns() const -> std::vector<HelpColumns> {
+            std::vector<HelpColumns> cols;
+            for (auto const &o : m_options) {
+                auto childCols = o.getHelpColumns();
+                cols.insert( cols.end(), childCols.begin(), childCols.end() );
+            }
+            return cols;
+        }
+
+        void writeToStream( std::ostream &os ) const {
+            if (!m_exeName.name().empty()) {
+                os << "usage:\n" << "  " << m_exeName.name() << " ";
+                bool required = true, first = true;
+                for( auto const &arg : m_args ) {
+                    if (first)
+                        first = false;
+                    else
+                        os << " ";
+                    if( arg.isOptional() && required ) {
+                        os << "[";
+                        required = false;
+                    }
+                    os << "<" << arg.hint() << ">";
+                    if( arg.cardinality() == 0 )
+                        os << " ... ";
+                }
+                if( !required )
+                    os << "]";
+                if( !m_options.empty() )
+                    os << " options";
+                os << "\n\nwhere options are:" << std::endl;
+            }
+
+            auto rows = getHelpColumns();
+            size_t consoleWidth = CATCH_CLARA_CONFIG_CONSOLE_WIDTH;
+            size_t optWidth = 0;
+            for( auto const &cols : rows )
+                optWidth = (std::max)(optWidth, cols.left.size() + 2);
+
+            optWidth = (std::min)(optWidth, consoleWidth/2);
+
+            for( auto const &cols : rows ) {
+                auto row =
+                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
+                        TextFlow::Spacer(4) +
+                        TextFlow::Column( cols.right ).width( consoleWidth - 7 - optWidth );
+                os << row << std::endl;
+            }
+        }
+
+        friend auto operator<<( std::ostream &os, Parser const &parser ) -> std::ostream& {
+            parser.writeToStream( os );
+            return os;
+        }
+
+        auto validate() const -> Result override {
+            for( auto const &opt : m_options ) {
+                auto result = opt.validate();
+                if( !result )
+                    return result;
+            }
+            for( auto const &arg : m_args ) {
+                auto result = arg.validate();
+                if( !result )
+                    return result;
+            }
+            return Result::ok();
+        }
+
+        using ParserBase::parse;
+
+        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+
+            struct ParserInfo {
+                ParserBase const* parser = nullptr;
+                size_t count = 0;
+            };
+            const size_t totalParsers = m_options.size() + m_args.size();
+            assert( totalParsers < 512 );
+            // ParserInfo parseInfos[totalParsers]; // <-- this is what we really want to do
+            ParserInfo parseInfos[512];
+
+            {
+                size_t i = 0;
+                for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
+                for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+            }
+
+            m_exeName.set( exeName );
+
+            auto result = InternalParseResult::ok( ParseState( ParseResultType::NoMatch, tokens ) );
+            while( result.value().remainingTokens() ) {
+                bool tokenParsed = false;
+
+                for( size_t i = 0; i < totalParsers; ++i ) {
+                    auto&  parseInfo = parseInfos[i];
+                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+                        result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
+                        if (!result)
+                            return result;
+                        if (result.value().type() != ParseResultType::NoMatch) {
+                            tokenParsed = true;
+                            ++parseInfo.count;
+                            break;
+                        }
+                    }
+                }
+
+                if( result.value().type() == ParseResultType::ShortCircuitAll )
+                    return result;
+                if( !tokenParsed )
+                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+            }
+            // !TBD Check missing required options
+            return result;
+        }
+    };
+
+    template<typename DerivedT>
+    template<typename T>
+    auto ComposableParserImpl<DerivedT>::operator|( T const &other ) const -> Parser {
+        return Parser() | static_cast<DerivedT const &>( *this ) | other;
+    }
+} // namespace detail
+
+// A Combined parser
+using detail::Parser;
+
+// A parser for options
+using detail::Opt;
+
+// A parser for arguments
+using detail::Arg;
+
+// Wrapper for argc, argv from main()
+using detail::Args;
+
+// Specifies the name of the executable
+using detail::ExeName;
+
+// Convenience wrapper for option parser that specifies the help option
+using detail::Help;
+
+// enum of result types from a parse
+using detail::ParseResultType;
+
+// Result type for parser operation
+using detail::ParserResult;
+
+}} // namespace Catch::clara
+
+// end clara.hpp
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// Restore Clara's value for console width, if present
+#ifdef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#undef CATCH_TEMP_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
+
+// end catch_clara.h
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config );
+
+} // end namespace Catch
+
+// end catch_commandline.h
+#include <fstream>
+#include <ctime>
+
+namespace Catch {
+
+    clara::Parser makeCommandLineParser( ConfigData& config ) {
+
+        using namespace clara;
+
+        auto const setWarning = [&]( std::string const& warning ) {
+                auto warningSet = [&]() {
+                    if( warning == "NoAssertions" )
+                        return WarnAbout::NoAssertions;
+
+                    if ( warning == "NoTests" )
+                        return WarnAbout::NoTests;
+
+                    return WarnAbout::Nothing;
+                }();
+
+                if (warningSet == WarnAbout::Nothing)
+                    return ParserResult::runtimeError( "Unrecognised warning: '" + warning + "'" );
+                config.warnings = static_cast<WarnAbout::What>( config.warnings | warningSet );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+                std::ifstream f( filename.c_str() );
+                if( !f.is_open() )
+                    return ParserResult::runtimeError( "Unable to load input file: '" + filename + "'" );
+
+                std::string line;
+                while( std::getline( f, line ) ) {
+                    line = trim(line);
+                    if( !line.empty() && !startsWith( line, '#' ) ) {
+                        if( !startsWith( line, '"' ) )
+                            line = '"' + line + '"';
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
+                    }
+                }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setTestOrder = [&]( std::string const& order ) {
+                if( startsWith( "declared", order ) )
+                    config.runOrder = RunTests::InDeclarationOrder;
+                else if( startsWith( "lexical", order ) )
+                    config.runOrder = RunTests::InLexicographicalOrder;
+                else if( startsWith( "random", order ) )
+                    config.runOrder = RunTests::InRandomOrder;
+                else
+                    return clara::ParserResult::runtimeError( "Unrecognised ordering: '" + order + "'" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setRngSeed = [&]( std::string const& seed ) {
+                if( seed != "time" )
+                    return clara::detail::convertInto( seed, config.rngSeed );
+                config.rngSeed = static_cast<unsigned int>( std::time(nullptr) );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setColourUsage = [&]( std::string const& useColour ) {
+                    auto mode = toLower( useColour );
+
+                    if( mode == "yes" )
+                        config.useColour = UseColour::Yes;
+                    else if( mode == "no" )
+                        config.useColour = UseColour::No;
+                    else if( mode == "auto" )
+                        config.useColour = UseColour::Auto;
+                    else
+                        return ParserResult::runtimeError( "colour mode must be one of: auto, yes or no. '" + useColour + "' not recognised" );
+                return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+                auto keypressLc = toLower( keypress );
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStart;
+                else if( keypressLc == "exit" )
+                    config.waitForKeypress = WaitForKeypress::BeforeExit;
+                else if( keypressLc == "both" )
+                    config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+                else
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+            return ParserResult::ok( ParseResultType::Matched );
+            };
+        auto const setVerbosity = [&]( std::string const& verbosity ) {
+            auto lcVerbosity = toLower( verbosity );
+            if( lcVerbosity == "quiet" )
+                config.verbosity = Verbosity::Quiet;
+            else if( lcVerbosity == "normal" )
+                config.verbosity = Verbosity::Normal;
+            else if( lcVerbosity == "high" )
+                config.verbosity = Verbosity::High;
+            else
+                return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
+
+        auto cli
+            = ExeName( config.processName )
+            | Help( config.showHelp )
+            | Opt( config.listTests )
+                ["-l"]["--list-tests"]
+                ( "list all/matching test cases" )
+            | Opt( config.listTags )
+                ["-t"]["--list-tags"]
+                ( "list all/matching tags" )
+            | Opt( config.showSuccessfulTests )
+                ["-s"]["--success"]
+                ( "include successful tests in output" )
+            | Opt( config.shouldDebugBreak )
+                ["-b"]["--break"]
+                ( "break into debugger on failure" )
+            | Opt( config.noThrow )
+                ["-e"]["--nothrow"]
+                ( "skip exception tests" )
+            | Opt( config.showInvisibles )
+                ["-i"]["--invisibles"]
+                ( "show invisibles (tabs, newlines)" )
+            | Opt( config.outputFilename, "filename" )
+                ["-o"]["--out"]
+                ( "output filename" )
+            | Opt( setReporter, "name" )
+                ["-r"]["--reporter"]
+                ( "reporter to use (defaults to console)" )
+            | Opt( config.name, "name" )
+                ["-n"]["--name"]
+                ( "suite name" )
+            | Opt( [&]( bool ){ config.abortAfter = 1; } )
+                ["-a"]["--abort"]
+                ( "abort at first failure" )
+            | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+                ["-x"]["--abortx"]
+                ( "abort after x failures" )
+            | Opt( setWarning, "warning name" )
+                ["-w"]["--warn"]
+                ( "enable warnings" )
+            | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+                ["-d"]["--durations"]
+                ( "show test durations" )
+            | Opt( config.minDuration, "seconds" )
+                ["-D"]["--min-duration"]
+                ( "show test durations for tests taking at least the given number of seconds" )
+            | Opt( loadTestNamesFromFile, "filename" )
+                ["-f"]["--input-file"]
+                ( "load test names to run from a file" )
+            | Opt( config.filenamesAsTags )
+                ["-#"]["--filenames-as-tags"]
+                ( "adds a tag for the filename" )
+            | Opt( config.sectionsToRun, "section name" )
+                ["-c"]["--section"]
+                ( "specify section to run" )
+            | Opt( setVerbosity, "quiet|normal|high" )
+                ["-v"]["--verbosity"]
+                ( "set output verbosity" )
+            | Opt( config.listTestNamesOnly )
+                ["--list-test-names-only"]
+                ( "list all/matching test cases names only" )
+            | Opt( config.listReporters )
+                ["--list-reporters"]
+                ( "list all reporters" )
+            | Opt( setTestOrder, "decl|lex|rand" )
+                ["--order"]
+                ( "test case order (defaults to decl)" )
+            | Opt( setRngSeed, "'time'|number" )
+                ["--rng-seed"]
+                ( "set a specific seed for random numbers" )
+            | Opt( setColourUsage, "yes|no" )
+                ["--use-colour"]
+                ( "should output be colourised" )
+            | Opt( config.libIdentify )
+                ["--libidentify"]
+                ( "report name and version according to libidentify standard" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
+                ["--wait-for-keypress"]
+                ( "waits for a keypress before exiting" )
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+            | Arg( config.testsOrTags, "test name|pattern|tags" )
+                ( "which test or tests to use" );
+
+        return cli;
+    }
+
+} // end namespace Catch
+// end catch_commandline.cpp
+// start catch_common.cpp
+
+#include <cstring>
+#include <ostream>
+
+namespace Catch {
+
+    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+    }
+    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+    }
+
+    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+#ifndef __GNUG__
+        os << info.file << '(' << info.line << ')';
+#else
+        os << info.file << ':' << info.line;
+#endif
+        return os;
+    }
+
+    std::string StreamEndStop::operator+() const {
+        return std::string();
+    }
+
+    NonCopyable::NonCopyable() = default;
+    NonCopyable::~NonCopyable() = default;
+
+}
+// end catch_common.cpp
+// start catch_config.cpp
+
+namespace Catch {
+
+    Config::Config( ConfigData const& data )
+    :   m_data( data ),
+        m_stream( openStream() )
+    {
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
+        }
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
+            m_hasTestFilters = true;
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
+        }
+        m_testSpec = parser.testSpec();
+    }
+
+    std::string const& Config::getFilename() const {
+        return m_data.outputFilename ;
+    }
+
+    bool Config::listTests() const          { return m_data.listTests; }
+    bool Config::listTestNamesOnly() const  { return m_data.listTestNamesOnly; }
+    bool Config::listTags() const           { return m_data.listTags; }
+    bool Config::listReporters() const      { return m_data.listReporters; }
+
+    std::string Config::getProcessName() const { return m_data.processName; }
+    std::string const& Config::getReporterName() const { return m_data.reporterName; }
+
+    std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+    std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+
+    TestSpec const& Config::testSpec() const { return m_testSpec; }
+    bool Config::hasTestFilters() const { return m_hasTestFilters; }
+
+    bool Config::showHelp() const { return m_data.showHelp; }
+
+    // IConfig interface
+    bool Config::allowThrows() const                   { return !m_data.noThrow; }
+    std::ostream& Config::stream() const               { return m_stream->stream(); }
+    std::string Config::name() const                   { return m_data.name.empty() ? m_data.processName : m_data.name; }
+    bool Config::includeSuccessfulResults() const      { return m_data.showSuccessfulTests; }
+    bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
+    bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
+    ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    double Config::minDuration() const                 { return m_data.minDuration; }
+    RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
+    unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
+    UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
+    bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
+    int Config::abortAfter() const                     { return m_data.abortAfter; }
+    bool Config::showInvisibles() const                { return m_data.showInvisibles; }
+    Verbosity Config::verbosity() const                { return m_data.verbosity; }
+
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
+    IStream const* Config::openStream() {
+        return Catch::makeStream(m_data.outputFilename);
+    }
+
+} // end namespace Catch
+// end catch_config.cpp
+// start catch_console_colour.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+// start catch_errno_guard.h
+
+namespace Catch {
+
+    class ErrnoGuard {
+    public:
+        ErrnoGuard();
+        ~ErrnoGuard();
+    private:
+        int m_oldErrno;
+    };
+
+}
+
+// end catch_errno_guard.h
+// start catch_windows_h_proxy.h
+
+
+#if defined(CATCH_PLATFORM_WINDOWS)
+
+#if !defined(NOMINMAX) && !defined(CATCH_CONFIG_NO_NOMINMAX)
+#  define CATCH_DEFINED_NOMINMAX
 #  define NOMINMAX
 #endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#if !defined(WIN32_LEAN_AND_MEAN) && !defined(CATCH_CONFIG_NO_WIN32_LEAN_AND_MEAN)
+#  define CATCH_DEFINED_WIN32_LEAN_AND_MEAN
 #  define WIN32_LEAN_AND_MEAN
 #endif
 
@@ -6421,1496 +10066,28 @@ namespace Catch {
 #include <windows.h>
 #endif
 
-#ifdef CATCH_DEFINES_NOMINMAX
+#ifdef CATCH_DEFINED_NOMINMAX
 #  undef NOMINMAX
 #endif
-#ifdef CATCH_DEFINES_WIN32_LEAN_AND_MEAN
+#ifdef CATCH_DEFINED_WIN32_LEAN_AND_MEAN
 #  undef WIN32_LEAN_AND_MEAN
 #endif
 
+#endif // defined(CATCH_PLATFORM_WINDOWS)
 
-#  if !defined ( CATCH_CONFIG_WINDOWS_SEH )
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
-    };
-}
-
-#  else // CATCH_CONFIG_WINDOWS_SEH is defined
-
-namespace Catch {
-
-    struct SignalDefs { DWORD id; const char* name; };
-    extern SignalDefs signalDefs[];
-    // There is no 1-1 mapping between signals and windows exceptions.
-    // Windows can easily distinguish between SO and SigSegV,
-    // but SigInt, SigTerm, etc are handled differently.
-    SignalDefs signalDefs[] = {
-        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
-        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
-        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
-        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
-    };
-
-    struct FatalConditionHandler {
-
-        static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
-            for (int i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                if (ExceptionInfo->ExceptionRecord->ExceptionCode == signalDefs[i].id) {
-                    reportFatal(signalDefs[i].name);
-                }
-            }
-            // If its not an exception we care about, pass it along.
-            // This stops us from eating debugger breaks etc.
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-
-        FatalConditionHandler() {
-            isSet = true;
-            // 32k seems enough for Catch to handle stack overflow,
-            // but the value was found experimentally, so there is no strong guarantee
-            guaranteeSize = 32 * 1024;
-            exceptionHandlerHandle = CATCH_NULL;
-            // Register as first handler in current chain
-            exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
-            // Pass in guarantee size to be filled
-            SetThreadStackGuarantee(&guaranteeSize);
-        }
-
-        static void reset() {
-            if (isSet) {
-                // Unregister handler and restore the old guarantee
-                RemoveVectoredExceptionHandler(exceptionHandlerHandle);
-                SetThreadStackGuarantee(&guaranteeSize);
-                exceptionHandlerHandle = CATCH_NULL;
-                isSet = false;
-            }
-        }
-
-        ~FatalConditionHandler() {
-            reset();
-        }
-    private:
-        static bool isSet;
-        static ULONG guaranteeSize;
-        static PVOID exceptionHandlerHandle;
-    };
-
-    bool FatalConditionHandler::isSet = false;
-    ULONG FatalConditionHandler::guaranteeSize = 0;
-    PVOID FatalConditionHandler::exceptionHandlerHandle = CATCH_NULL;
-
-} // namespace Catch
-
-#  endif // CATCH_CONFIG_WINDOWS_SEH
-
-#else // Not Windows - assumed to be POSIX compatible //////////////////////////
-
-#  if !defined(CATCH_CONFIG_POSIX_SIGNALS)
-
-namespace Catch {
-    struct FatalConditionHandler {
-        void reset() {}
-    };
-}
-
-#  else // CATCH_CONFIG_POSIX_SIGNALS is defined
-
-#include <signal.h>
-
-namespace Catch {
-
-    struct SignalDefs {
-        int id;
-        const char* name;
-    };
-    extern SignalDefs signalDefs[];
-    SignalDefs signalDefs[] = {
-            { SIGINT,  "SIGINT - Terminal interrupt signal" },
-            { SIGILL,  "SIGILL - Illegal instruction signal" },
-            { SIGFPE,  "SIGFPE - Floating point error signal" },
-            { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
-            { SIGTERM, "SIGTERM - Termination request signal" },
-            { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
-    };
-
-    struct FatalConditionHandler {
-
-        static bool isSet;
-        static struct sigaction oldSigActions [sizeof(signalDefs)/sizeof(SignalDefs)];
-        static stack_t oldSigStack;
-        static char altStackMem[SIGSTKSZ];
-
-        static void handleSignal( int sig ) {
-            std::string name = "<unknown signal>";
-            for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
-                SignalDefs &def = signalDefs[i];
-                if (sig == def.id) {
-                    name = def.name;
-                    break;
-                }
-            }
-            reset();
-            reportFatal(name);
-            raise( sig );
-        }
-
-        FatalConditionHandler() {
-            isSet = true;
-            stack_t sigStack;
-            sigStack.ss_sp = altStackMem;
-            sigStack.ss_size = SIGSTKSZ;
-            sigStack.ss_flags = 0;
-            sigaltstack(&sigStack, &oldSigStack);
-            struct sigaction sa = { 0 };
-
-            sa.sa_handler = handleSignal;
-            sa.sa_flags = SA_ONSTACK;
-            for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
-                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
-            }
-        }
-
-        ~FatalConditionHandler() {
-            reset();
-        }
-        static void reset() {
-            if( isSet ) {
-                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
-                for( std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i ) {
-                    sigaction(signalDefs[i].id, &oldSigActions[i], CATCH_NULL);
-                }
-                // Return the old stack
-                sigaltstack(&oldSigStack, CATCH_NULL);
-                isSet = false;
-            }
-        }
-    };
-
-    bool FatalConditionHandler::isSet = false;
-    struct sigaction FatalConditionHandler::oldSigActions[sizeof(signalDefs)/sizeof(SignalDefs)] = {};
-    stack_t FatalConditionHandler::oldSigStack = {};
-    char FatalConditionHandler::altStackMem[SIGSTKSZ] = {};
-
-} // namespace Catch
-
-#  endif // CATCH_CONFIG_POSIX_SIGNALS
-
-#endif // not Windows
-
-#include <set>
-#include <string>
-
-namespace Catch {
-
-    class StreamRedirect {
-
-    public:
-        StreamRedirect( std::ostream& stream, std::string& targetString )
-        :   m_stream( stream ),
-            m_prevBuf( stream.rdbuf() ),
-            m_targetString( targetString )
-        {
-            stream.rdbuf( m_oss.rdbuf() );
-        }
-
-        ~StreamRedirect() {
-            m_targetString += m_oss.str();
-            m_stream.rdbuf( m_prevBuf );
-        }
-
-    private:
-        std::ostream& m_stream;
-        std::streambuf* m_prevBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
-
-    // StdErr has two constituent streams in C++, std::cerr and std::clog
-    // This means that we need to redirect 2 streams into 1 to keep proper
-    // order of writes and cannot use StreamRedirect on its own
-    class StdErrRedirect {
-    public:
-        StdErrRedirect(std::string& targetString)
-        :m_cerrBuf( cerr().rdbuf() ), m_clogBuf(clog().rdbuf()),
-        m_targetString(targetString){
-            cerr().rdbuf(m_oss.rdbuf());
-            clog().rdbuf(m_oss.rdbuf());
-        }
-        ~StdErrRedirect() {
-            m_targetString += m_oss.str();
-            cerr().rdbuf(m_cerrBuf);
-            clog().rdbuf(m_clogBuf);
-        }
-    private:
-        std::streambuf* m_cerrBuf;
-        std::streambuf* m_clogBuf;
-        std::ostringstream m_oss;
-        std::string& m_targetString;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class RunContext : public IResultCapture, public IRunner {
-
-        RunContext( RunContext const& );
-        void operator =( RunContext const& );
-
-    public:
-
-        explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
-        :   m_runInfo( _config->name() ),
-            m_context( getCurrentMutableContext() ),
-            m_activeTestCase( CATCH_NULL ),
-            m_config( _config ),
-            m_reporter( reporter ),
-            m_shouldReportUnexpected ( true )
-        {
-            m_context.setRunner( this );
-            m_context.setConfig( m_config );
-            m_context.setResultCapture( this );
-            m_reporter->testRunStarting( m_runInfo );
-        }
-
-        virtual ~RunContext() {
-            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
-        }
-
-        void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
-            m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
-        }
-        void testGroupEnded( std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount ) {
-            m_reporter->testGroupEnded( TestGroupStats( GroupInfo( testSpec, groupIndex, groupsCount ), totals, aborting() ) );
-        }
-
-        Totals runTest( TestCase const& testCase ) {
-            Totals prevTotals = m_totals;
-
-            std::string redirectedCout;
-            std::string redirectedCerr;
-
-            TestCaseInfo testInfo = testCase.getTestCaseInfo();
-
-            m_reporter->testCaseStarting( testInfo );
-
-            m_activeTestCase = &testCase;
-
-            do {
-                ITracker& rootTracker = m_trackerContext.startRun();
-                assert( rootTracker.isSectionTracker() );
-                static_cast<SectionTracker&>( rootTracker ).addInitialFilters( m_config->getSectionsToRun() );
-                do {
-                    m_trackerContext.startCycle();
-                    m_testCaseTracker = &SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( testInfo.name, testInfo.lineInfo ) );
-                    runCurrentTest( redirectedCout, redirectedCerr );
-                }
-                while( !m_testCaseTracker->isSuccessfullyCompleted() && !aborting() );
-            }
-            // !TBD: deprecated - this will be replaced by indexed trackers
-            while( getCurrentContext().advanceGeneratorsForCurrentTest() && !aborting() );
-
-            Totals deltaTotals = m_totals.delta( prevTotals );
-            if( testInfo.expectedToFail() && deltaTotals.testCases.passed > 0 ) {
-                deltaTotals.assertions.failed++;
-                deltaTotals.testCases.passed--;
-                deltaTotals.testCases.failed++;
-            }
-            m_totals.testCases += deltaTotals.testCases;
-            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
-                                                        deltaTotals,
-                                                        redirectedCout,
-                                                        redirectedCerr,
-                                                        aborting() ) );
-
-            m_activeTestCase = CATCH_NULL;
-            m_testCaseTracker = CATCH_NULL;
-
-            return deltaTotals;
-        }
-
-        Ptr<IConfig const> config() const {
-            return m_config;
-        }
-
-    private: // IResultCapture
-
-        virtual void assertionEnded( AssertionResult const& result ) {
-            if( result.getResultType() == ResultWas::Ok ) {
-                m_totals.assertions.passed++;
-            }
-            else if( !result.isOk() ) {
-                if( m_activeTestCase->getTestCaseInfo().okToFail() )
-                    m_totals.assertions.failedButOk++;
-                else
-                    m_totals.assertions.failed++;
-            }
-
-            // We have no use for the return value (whether messages should be cleared), because messages were made scoped
-            // and should be let to clear themselves out.
-            static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
-
-            // Reset working state
-            m_lastAssertionInfo = AssertionInfo( "", m_lastAssertionInfo.lineInfo, "{Unknown expression after the reported line}" , m_lastAssertionInfo.resultDisposition );
-            m_lastResult = result;
-        }
-
-        virtual bool lastAssertionPassed()
-        {
-            return m_totals.assertions.passed == (m_prevPassed + 1);
-        }
-
-        virtual void assertionPassed()
-        {
-            m_totals.assertions.passed++;
-            m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}";
-            m_lastAssertionInfo.macroName = "";
-        }
-
-        virtual void assertionRun()
-        {
-            m_prevPassed = m_totals.assertions.passed;
-        }
-
-        virtual bool sectionStarted (
-            SectionInfo const& sectionInfo,
-            Counts& assertions
-        )
-        {
-            ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, TestCaseTracking::NameAndLocation( sectionInfo.name, sectionInfo.lineInfo ) );
-            if( !sectionTracker.isOpen() )
-                return false;
-            m_activeSections.push_back( &sectionTracker );
-
-            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
-
-            m_reporter->sectionStarting( sectionInfo );
-
-            assertions = m_totals.assertions;
-
-            return true;
-        }
-        bool testForMissingAssertions( Counts& assertions ) {
-            if( assertions.total() != 0 )
-                return false;
-            if( !m_config->warnAboutMissingAssertions() )
-                return false;
-            if( m_trackerContext.currentTracker().hasChildren() )
-                return false;
-            m_totals.assertions.failed++;
-            assertions.failed++;
-            return true;
-        }
-
-        virtual void sectionEnded( SectionEndInfo const& endInfo ) {
-            Counts assertions = m_totals.assertions - endInfo.prevAssertions;
-            bool missingAssertions = testForMissingAssertions( assertions );
-
-            if( !m_activeSections.empty() ) {
-                m_activeSections.back()->close();
-                m_activeSections.pop_back();
-            }
-
-            m_reporter->sectionEnded( SectionStats( endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions ) );
-            m_messages.clear();
-        }
-
-        virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) {
-            if( m_unfinishedSections.empty() )
-                m_activeSections.back()->fail();
-            else
-                m_activeSections.back()->close();
-            m_activeSections.pop_back();
-
-            m_unfinishedSections.push_back( endInfo );
-        }
-
-        virtual void pushScopedMessage( MessageInfo const& message ) {
-            m_messages.push_back( message );
-        }
-
-        virtual void popScopedMessage( MessageInfo const& message ) {
-            m_messages.erase( std::remove( m_messages.begin(), m_messages.end(), message ), m_messages.end() );
-        }
-
-        virtual std::string getCurrentTestName() const {
-            return m_activeTestCase
-                ? m_activeTestCase->getTestCaseInfo().name
-                : std::string();
-        }
-
-        virtual const AssertionResult* getLastResult() const {
-            return &m_lastResult;
-        }
-
-        virtual void exceptionEarlyReported() {
-            m_shouldReportUnexpected = false;
-        }
-
-        virtual void handleFatalErrorCondition( std::string const& message ) {
-            // Don't rebuild the result -- the stringification itself can cause more fatal errors
-            // Instead, fake a result data.
-            AssertionResultData tempResult;
-            tempResult.resultType = ResultWas::FatalErrorCondition;
-            tempResult.message = message;
-            AssertionResult result(m_lastAssertionInfo, tempResult);
-
-            getResultCapture().assertionEnded(result);
-
-            handleUnfinishedSections();
-
-            // Recreate section for test case (as we will lose the one that was in scope)
-            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
-
-            Counts assertions;
-            assertions.failed = 1;
-            SectionStats testCaseSectionStats( testCaseSection, assertions, 0, false );
-            m_reporter->sectionEnded( testCaseSectionStats );
-
-            TestCaseInfo testInfo = m_activeTestCase->getTestCaseInfo();
-
-            Totals deltaTotals;
-            deltaTotals.testCases.failed = 1;
-            deltaTotals.assertions.failed = 1;
-            m_reporter->testCaseEnded( TestCaseStats(   testInfo,
-                                                        deltaTotals,
-                                                        std::string(),
-                                                        std::string(),
-                                                        false ) );
-            m_totals.testCases.failed++;
-            testGroupEnded( std::string(), m_totals, 1, 1 );
-            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, false ) );
-        }
-
-    public:
-        // !TBD We need to do this another way!
-        bool aborting() const {
-            return m_totals.assertions.failed == static_cast<std::size_t>( m_config->abortAfter() );
-        }
-
-    private:
-
-        void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr ) {
-            TestCaseInfo const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-            SectionInfo testCaseSection( testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description );
-            m_reporter->sectionStarting( testCaseSection );
-            Counts prevAssertions = m_totals.assertions;
-            double duration = 0;
-            m_shouldReportUnexpected = true;
-            try {
-                m_lastAssertionInfo = AssertionInfo( "TEST_CASE", testCaseInfo.lineInfo, "", ResultDisposition::Normal );
-
-                seedRng( *m_config );
-
-                Timer timer;
-                timer.start();
-                if( m_reporter->getPreferences().shouldRedirectStdOut ) {
-                    StreamRedirect coutRedir( Catch::cout(), redirectedCout );
-                    StdErrRedirect errRedir( redirectedCerr );
-                    invokeActiveTestCase();
-                }
-                else {
-                    invokeActiveTestCase();
-                }
-                duration = timer.getElapsedSeconds();
-            }
-            catch( TestFailureException& ) {
-                // This just means the test was aborted due to failure
-            }
-            catch(...) {
-                // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
-                // are reported without translation at the point of origin.
-                if (m_shouldReportUnexpected) {
-                    makeUnexpectedResultBuilder().useActiveException();
-                }
-            }
-            m_testCaseTracker->close();
-            handleUnfinishedSections();
-            m_messages.clear();
-
-            Counts assertions = m_totals.assertions - prevAssertions;
-            bool missingAssertions = testForMissingAssertions( assertions );
-
-            SectionStats testCaseSectionStats( testCaseSection, assertions, duration, missingAssertions );
-            m_reporter->sectionEnded( testCaseSectionStats );
-        }
-
-        void invokeActiveTestCase() {
-            FatalConditionHandler fatalConditionHandler; // Handle signals
-            m_activeTestCase->invoke();
-            fatalConditionHandler.reset();
-        }
-
-    private:
-
-        ResultBuilder makeUnexpectedResultBuilder() const {
-            return ResultBuilder(   m_lastAssertionInfo.macroName,
-                                    m_lastAssertionInfo.lineInfo,
-                                    m_lastAssertionInfo.capturedExpression,
-                                    m_lastAssertionInfo.resultDisposition );
-        }
-
-        void handleUnfinishedSections() {
-            // If sections ended prematurely due to an exception we stored their
-            // infos here so we can tear them down outside the unwind process.
-            for( std::vector<SectionEndInfo>::const_reverse_iterator it = m_unfinishedSections.rbegin(),
-                        itEnd = m_unfinishedSections.rend();
-                    it != itEnd;
-                    ++it )
-                sectionEnded( *it );
-            m_unfinishedSections.clear();
-        }
-
-        TestRunInfo m_runInfo;
-        IMutableContext& m_context;
-        TestCase const* m_activeTestCase;
-        ITracker* m_testCaseTracker;
-        ITracker* m_currentSectionTracker;
-        AssertionResult m_lastResult;
-
-        Ptr<IConfig const> m_config;
-        Totals m_totals;
-        Ptr<IStreamingReporter> m_reporter;
-        std::vector<MessageInfo> m_messages;
-        AssertionInfo m_lastAssertionInfo;
-        std::vector<SectionEndInfo> m_unfinishedSections;
-        std::vector<ITracker*> m_activeSections;
-        TrackerContext m_trackerContext;
-        size_t m_prevPassed;
-        bool m_shouldReportUnexpected;
-    };
-
-    IResultCapture& getResultCapture() {
-        if( IResultCapture* capture = getCurrentContext().getResultCapture() )
-            return *capture;
-        else
-            throw std::logic_error( "No result capture instance" );
-    }
-
-} // end namespace Catch
-
-// #included from: internal/catch_version.h
-#define TWOBLUECUBES_CATCH_VERSION_H_INCLUDED
-
-namespace Catch {
-
-    // Versioning information
-    struct Version {
-        Version(    unsigned int _majorVersion,
-                    unsigned int _minorVersion,
-                    unsigned int _patchNumber,
-                    char const * const _branchName,
-                    unsigned int _buildNumber );
-
-        unsigned int const majorVersion;
-        unsigned int const minorVersion;
-        unsigned int const patchNumber;
-
-        // buildNumber is only used if branchName is not null
-        char const * const branchName;
-        unsigned int const buildNumber;
-
-        friend std::ostream& operator << ( std::ostream& os, Version const& version );
-
-    private:
-        void operator=( Version const& );
-    };
-
-    inline Version libraryVersion();
-}
-
-#include <fstream>
-#include <stdlib.h>
-#include <limits>
-
-namespace Catch {
-
-    Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
-        Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );
-        if( !reporter ) {
-            std::ostringstream oss;
-            oss << "No reporter registered with name: '" << reporterName << "'";
-            throw std::domain_error( oss.str() );
-        }
-        return reporter;
-    }
-
-#if !defined(CATCH_CONFIG_DEFAULT_REPORTER)
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-
-    Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
-        std::vector<std::string> reporters = config->getReporterNames();
-        if( reporters.empty() )
-            reporters.push_back( CATCH_CONFIG_DEFAULT_REPORTER );
-
-        Ptr<IStreamingReporter> reporter;
-        for( std::vector<std::string>::const_iterator it = reporters.begin(), itEnd = reporters.end();
-                it != itEnd;
-                ++it )
-            reporter = addReporter( reporter, createReporter( *it, config ) );
-        return reporter;
-    }
-    Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
-        IReporterRegistry::Listeners listeners = getRegistryHub().getReporterRegistry().getListeners();
-        for( IReporterRegistry::Listeners::const_iterator it = listeners.begin(), itEnd = listeners.end();
-                it != itEnd;
-                ++it )
-            reporters = addReporter(reporters, (*it)->create( ReporterConfig( config ) ) );
-        return reporters;
-    }
-
-    Totals runTests( Ptr<Config> const& config ) {
-
-        Ptr<IConfig const> iconfig = config.get();
-
-        Ptr<IStreamingReporter> reporter = makeReporter( config );
-        reporter = addListeners( iconfig, reporter );
-
-        RunContext context( iconfig, reporter );
-
-        Totals totals;
-
-        context.testGroupStarting( config->name(), 1, 1 );
-
-        TestSpec testSpec = config->testSpec();
-        if( !testSpec.hasFilters() )
-            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "~[.]" ).testSpec(); // All not hidden tests
-
-        std::vector<TestCase> const& allTestCases = getAllTestCasesSorted( *iconfig );
-        for( std::vector<TestCase>::const_iterator it = allTestCases.begin(), itEnd = allTestCases.end();
-                it != itEnd;
-                ++it ) {
-            if( !context.aborting() && matchTest( *it, testSpec, *iconfig ) )
-                totals += context.runTest( *it );
-            else
-                reporter->skipTest( *it );
-        }
-
-        context.testGroupEnded( iconfig->name(), totals, 1, 1 );
-        return totals;
-    }
-
-    void applyFilenamesAsTags( IConfig const& config ) {
-        std::vector<TestCase> const& tests = getAllTestCasesSorted( config );
-        for(std::size_t i = 0; i < tests.size(); ++i ) {
-            TestCase& test = const_cast<TestCase&>( tests[i] );
-            std::set<std::string> tags = test.tags;
-
-            std::string filename = test.lineInfo.file;
-            std::string::size_type lastSlash = filename.find_last_of( "\\/" );
-            if( lastSlash != std::string::npos )
-                filename = filename.substr( lastSlash+1 );
-
-            std::string::size_type lastDot = filename.find_last_of( '.' );
-            if( lastDot != std::string::npos )
-                filename = filename.substr( 0, lastDot );
-
-            tags.insert( '#' + filename );
-            setTags( test, tags );
-        }
-    }
-
-    class Session : NonCopyable {
-        static bool alreadyInstantiated;
-
-    public:
-
-        struct OnUnusedOptions { enum DoWhat { Ignore, Fail }; };
-
-        Session()
-        : m_cli( makeCommandLineParser() ) {
-            if( alreadyInstantiated ) {
-                std::string msg = "Only one instance of Catch::Session can ever be used";
-                Catch::cerr() << msg << std::endl;
-                throw std::logic_error( msg );
-            }
-            alreadyInstantiated = true;
-        }
-        ~Session() {
-            Catch::cleanUp();
-        }
-
-        void showHelp( std::string const& processName ) {
-            Catch::cout() << "\nCatch v" << libraryVersion() << "\n";
-
-            m_cli.usage( Catch::cout(), processName );
-            Catch::cout() << "For more detail usage please see the project docs\n" << std::endl;
-        }
-        void libIdentify() {
-            Catch::cout()
-                    << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
-                    << std::left << std::setw(16) << "category: " << "testframework\n"
-                    << std::left << std::setw(16) << "framework: " << "Catch Test\n"
-                    << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
-        }
-
-        int applyCommandLine( int argc, char const* const* const argv, OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
-            try {
-                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
-                m_unusedTokens = m_cli.parseInto( Clara::argsToVector( argc, argv ), m_configData );
-                if( m_configData.showHelp )
-                    showHelp( m_configData.processName );
-                if( m_configData.libIdentify )
-                    libIdentify();
-                m_config.reset();
-            }
-            catch( std::exception& ex ) {
-                {
-                    Colour colourGuard( Colour::Red );
-                    Catch::cerr()
-                        << "\nError(s) in input:\n"
-                        << Text( ex.what(), TextAttributes().setIndent(2) )
-                        << "\n\n";
-                }
-                m_cli.usage( Catch::cout(), m_configData.processName );
-                return (std::numeric_limits<int>::max)();
-            }
-            return 0;
-        }
-
-        void useConfigData( ConfigData const& _configData ) {
-            m_configData = _configData;
-            m_config.reset();
-        }
-
-        int run( int argc, char const* const* const argv ) {
-
-            int returnCode = applyCommandLine( argc, argv );
-            if( returnCode == 0 )
-                returnCode = run();
-            return returnCode;
-        }
-
-    #if defined(WIN32) && defined(UNICODE)
-        int run( int argc, wchar_t const* const* const argv ) {
-
-            char **utf8Argv = new char *[ argc ];
-
-            for ( int i = 0; i < argc; ++i ) {
-                int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
-
-                utf8Argv[ i ] = new char[ bufSize ];
-
-                WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
-            }
-
-            int returnCode = applyCommandLine( argc, utf8Argv );
-            if( returnCode == 0 )
-                returnCode = run();
-
-            for ( int i = 0; i < argc; ++i )
-                delete [] utf8Argv[ i ];
-
-            delete [] utf8Argv;
-
-            return returnCode;
-        }
-    #endif
-
-        int run() {
-            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
-                Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
-                static_cast<void>(std::getchar());
-            }
-            int exitCode = runInternal();
-            if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
-                Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
-                static_cast<void>(std::getchar());
-            }
-            return exitCode;
-        }
-
-        Clara::CommandLine<ConfigData> const& cli() const {
-            return m_cli;
-        }
-        std::vector<Clara::Parser::Token> const& unusedTokens() const {
-            return m_unusedTokens;
-        }
-        ConfigData& configData() {
-            return m_configData;
-        }
-        Config& config() {
-            if( !m_config )
-                m_config = new Config( m_configData );
-            return *m_config;
-        }
-    private:
-
-        int runInternal() {
-            if( m_configData.showHelp || m_configData.libIdentify )
-                return 0;
-
-            try
-            {
-                config(); // Force config to be constructed
-
-                seedRng( *m_config );
-
-                if( m_configData.filenamesAsTags )
-                    applyFilenamesAsTags( *m_config );
-
-                // Handle list request
-                if( Option<std::size_t> listed = list( config() ) )
-                    return static_cast<int>( *listed );
-
-                return static_cast<int>( runTests( m_config ).assertions.failed );
-            }
-            catch( std::exception& ex ) {
-                Catch::cerr() << ex.what() << std::endl;
-                return (std::numeric_limits<int>::max)();
-            }
-        }
-
-        Clara::CommandLine<ConfigData> m_cli;
-        std::vector<Clara::Parser::Token> m_unusedTokens;
-        ConfigData m_configData;
-        Ptr<Config> m_config;
-    };
-
-    bool Session::alreadyInstantiated = false;
-
-} // end namespace Catch
-
-// #included from: catch_registry_hub.hpp
-#define TWOBLUECUBES_CATCH_REGISTRY_HUB_HPP_INCLUDED
-
-// #included from: catch_test_case_registry_impl.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
-
-#include <vector>
-#include <set>
+// end catch_windows_h_proxy.h
 #include <sstream>
-#include <algorithm>
-
-namespace Catch {
-
-    struct RandomNumberGenerator {
-        typedef unsigned int result_type;
-
-        result_type operator()( result_type n ) const { return std::rand() % n; }
-
-#ifdef CATCH_CONFIG_CPP11_SHUFFLE
-        static constexpr result_type (min)() { return 0; }
-        static constexpr result_type (max)() { return 1000000; }
-        result_type operator()() const { return std::rand() % (max)(); }
-#endif
-        template<typename V>
-        static void shuffle( V& vector ) {
-            RandomNumberGenerator rng;
-#ifdef CATCH_CONFIG_CPP11_SHUFFLE
-            std::shuffle( vector.begin(), vector.end(), rng );
-#else
-            std::random_shuffle( vector.begin(), vector.end(), rng );
-#endif
-        }
-    };
-
-    inline std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
-
-        std::vector<TestCase> sorted = unsortedTestCases;
-
-        switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                {
-                    seedRng( config );
-                    RandomNumberGenerator::shuffle( sorted );
-                }
-                break;
-            case RunTests::InDeclarationOrder:
-                // already in declaration order
-                break;
-        }
-        return sorted;
-    }
-    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
-    }
-
-    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
-        std::set<TestCase> seenFunctions;
-        for( std::vector<TestCase>::const_iterator it = functions.begin(), itEnd = functions.end();
-            it != itEnd;
-            ++it ) {
-            std::pair<std::set<TestCase>::const_iterator, bool> prev = seenFunctions.insert( *it );
-            if( !prev.second ) {
-                std::ostringstream ss;
-
-                ss  << Colour( Colour::Red )
-                    << "error: TEST_CASE( \"" << it->name << "\" ) already defined.\n"
-                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << '\n'
-                    << "\tRedefined at " << it->getTestCaseInfo().lineInfo << std::endl;
-
-                throw std::runtime_error(ss.str());
-            }
-        }
-    }
-
-    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
-        std::vector<TestCase> filtered;
-        filtered.reserve( testCases.size() );
-        for( std::vector<TestCase>::const_iterator it = testCases.begin(), itEnd = testCases.end();
-                it != itEnd;
-                ++it )
-            if( matchTest( *it, testSpec, config ) )
-                filtered.push_back( *it );
-        return filtered;
-    }
-    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
-        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
-    }
-
-    class TestRegistry : public ITestCaseRegistry {
-    public:
-        TestRegistry()
-        :   m_currentSortOrder( RunTests::InDeclarationOrder ),
-            m_unnamedCount( 0 )
-        {}
-        virtual ~TestRegistry();
-
-        virtual void registerTest( TestCase const& testCase ) {
-            std::string name = testCase.getTestCaseInfo().name;
-            if( name.empty() ) {
-                std::ostringstream oss;
-                oss << "Anonymous test case " << ++m_unnamedCount;
-                return registerTest( testCase.withName( oss.str() ) );
-            }
-            m_functions.push_back( testCase );
-        }
-
-        virtual std::vector<TestCase> const& getAllTests() const {
-            return m_functions;
-        }
-        virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const {
-            if( m_sortedFunctions.empty() )
-                enforceNoDuplicateTestCases( m_functions );
-
-            if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
-                m_sortedFunctions = sortTests( config, m_functions );
-                m_currentSortOrder = config.runOrder();
-            }
-            return m_sortedFunctions;
-        }
-
-    private:
-        std::vector<TestCase> m_functions;
-        mutable RunTests::InWhatOrder m_currentSortOrder;
-        mutable std::vector<TestCase> m_sortedFunctions;
-        size_t m_unnamedCount;
-        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class FreeFunctionTestCase : public SharedImpl<ITestCase> {
-    public:
-
-        FreeFunctionTestCase( TestFunction fun ) : m_fun( fun ) {}
-
-        virtual void invoke() const {
-            m_fun();
-        }
-
-    private:
-        virtual ~FreeFunctionTestCase();
-
-        TestFunction m_fun;
-    };
-
-    inline std::string extractClassName( std::string const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
-        if( startsWith( className, '&' ) )
-        {
-            std::size_t lastColons = className.rfind( "::" );
-            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
-            if( penultimateColons == std::string::npos )
-                penultimateColons = 1;
-            className = className.substr( penultimateColons, lastColons-penultimateColons );
-        }
-        return className;
-    }
-
-    void registerTestCase
-        (   ITestCase* testCase,
-            char const* classOrQualifiedMethodName,
-            NameAndDesc const& nameAndDesc,
-            SourceLineInfo const& lineInfo ) {
-
-        getMutableRegistryHub().registerTest
-            ( makeTestCase
-                (   testCase,
-                    extractClassName( classOrQualifiedMethodName ),
-                    nameAndDesc.name,
-                    nameAndDesc.description,
-                    lineInfo ) );
-    }
-    void registerTestCaseFunction
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc ) {
-        registerTestCase( new FreeFunctionTestCase( function ), "", nameAndDesc, lineInfo );
-    }
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    AutoReg::AutoReg
-        (   TestFunction function,
-            SourceLineInfo const& lineInfo,
-            NameAndDesc const& nameAndDesc ) {
-        registerTestCaseFunction( function, lineInfo, nameAndDesc );
-    }
-
-    AutoReg::~AutoReg() {}
-
-} // end namespace Catch
-
-// #included from: catch_reporter_registry.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRY_HPP_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class ReporterRegistry : public IReporterRegistry {
-
-    public:
-
-        virtual ~ReporterRegistry() CATCH_OVERRIDE {}
-
-        virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRIDE {
-            FactoryMap::const_iterator it =  m_factories.find( name );
-            if( it == m_factories.end() )
-                return CATCH_NULL;
-            return it->second->create( ReporterConfig( config ) );
-        }
-
-        void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) {
-            m_factories.insert( std::make_pair( name, factory ) );
-        }
-        void registerListener( Ptr<IReporterFactory> const& factory ) {
-            m_listeners.push_back( factory );
-        }
-
-        virtual FactoryMap const& getFactories() const CATCH_OVERRIDE {
-            return m_factories;
-        }
-        virtual Listeners const& getListeners() const CATCH_OVERRIDE {
-            return m_listeners;
-        }
-
-    private:
-        FactoryMap m_factories;
-        Listeners m_listeners;
-    };
-}
-
-// #included from: catch_exception_translator_registry.hpp
-#define TWOBLUECUBES_CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
-
-#ifdef __OBJC__
-#import "Foundation/Foundation.h"
-#endif
-
-namespace Catch {
-
-    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
-    public:
-        ~ExceptionTranslatorRegistry() {
-            deleteAll( m_translators );
-        }
-
-        virtual void registerTranslator( const IExceptionTranslator* translator ) {
-            m_translators.push_back( translator );
-        }
-
-        virtual std::string translateActiveException() const {
-            try {
-#ifdef __OBJC__
-                // In Objective-C try objective-c exceptions first
-                @try {
-                    return tryTranslators();
-                }
-                @catch (NSException *exception) {
-                    return Catch::toString( [exception description] );
-                }
-#else
-                return tryTranslators();
-#endif
-            }
-            catch( TestFailureException& ) {
-                throw;
-            }
-            catch( std::exception& ex ) {
-                return ex.what();
-            }
-            catch( std::string& msg ) {
-                return msg;
-            }
-            catch( const char* msg ) {
-                return msg;
-            }
-            catch(...) {
-                return "Unknown exception";
-            }
-        }
-
-        std::string tryTranslators() const {
-            if( m_translators.empty() )
-                throw;
-            else
-                return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
-        }
-
-    private:
-        std::vector<const IExceptionTranslator*> m_translators;
-    };
-}
-
-// #included from: catch_tag_alias_registry.h
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_H_INCLUDED
-
-#include <map>
-
-namespace Catch {
-
-    class TagAliasRegistry : public ITagAliasRegistry {
-    public:
-        virtual ~TagAliasRegistry();
-        virtual Option<TagAlias> find( std::string const& alias ) const;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const;
-        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
-
-    private:
-        std::map<std::string, TagAlias> m_registry;
-    };
-
-} // end namespace Catch
-
-namespace Catch {
-
-    namespace {
-
-        class RegistryHub : public IRegistryHub, public IMutableRegistryHub {
-
-            RegistryHub( RegistryHub const& );
-            void operator=( RegistryHub const& );
-
-        public: // IRegistryHub
-            RegistryHub() {
-            }
-            virtual IReporterRegistry const& getReporterRegistry() const CATCH_OVERRIDE {
-                return m_reporterRegistry;
-            }
-            virtual ITestCaseRegistry const& getTestCaseRegistry() const CATCH_OVERRIDE {
-                return m_testCaseRegistry;
-            }
-            virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() CATCH_OVERRIDE {
-                return m_exceptionTranslatorRegistry;
-            }
-            virtual ITagAliasRegistry const& getTagAliasRegistry() const CATCH_OVERRIDE {
-                return m_tagAliasRegistry;
-            }
-
-        public: // IMutableRegistryHub
-            virtual void registerReporter( std::string const& name, Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
-                m_reporterRegistry.registerReporter( name, factory );
-            }
-            virtual void registerListener( Ptr<IReporterFactory> const& factory ) CATCH_OVERRIDE {
-                m_reporterRegistry.registerListener( factory );
-            }
-            virtual void registerTest( TestCase const& testInfo ) CATCH_OVERRIDE {
-                m_testCaseRegistry.registerTest( testInfo );
-            }
-            virtual void registerTranslator( const IExceptionTranslator* translator ) CATCH_OVERRIDE {
-                m_exceptionTranslatorRegistry.registerTranslator( translator );
-            }
-            virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) CATCH_OVERRIDE {
-                m_tagAliasRegistry.add( alias, tag, lineInfo );
-            }
-
-        private:
-            TestRegistry m_testCaseRegistry;
-            ReporterRegistry m_reporterRegistry;
-            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
-            TagAliasRegistry m_tagAliasRegistry;
-        };
-
-        // Single, global, instance
-        inline RegistryHub*& getTheRegistryHub() {
-            static RegistryHub* theRegistryHub = CATCH_NULL;
-            if( !theRegistryHub )
-                theRegistryHub = new RegistryHub();
-            return theRegistryHub;
-        }
-    }
-
-    IRegistryHub& getRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    IMutableRegistryHub& getMutableRegistryHub() {
-        return *getTheRegistryHub();
-    }
-    void cleanUp() {
-        delete getTheRegistryHub();
-        getTheRegistryHub() = CATCH_NULL;
-        cleanUpContext();
-    }
-    std::string translateActiveException() {
-        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_notimplemented_exception.hpp
-#define TWOBLUECUBES_CATCH_NOTIMPLEMENTED_EXCEPTION_HPP_INCLUDED
-
-#include <sstream>
-
-namespace Catch {
-
-    NotImplementedException::NotImplementedException( SourceLineInfo const& lineInfo )
-    :   m_lineInfo( lineInfo ) {
-        std::ostringstream oss;
-        oss << lineInfo << ": function ";
-        oss << "not implemented";
-        m_what = oss.str();
-    }
-
-    const char* NotImplementedException::what() const CATCH_NOEXCEPT {
-        return m_what.c_str();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_context_impl.hpp
-#define TWOBLUECUBES_CATCH_CONTEXT_IMPL_HPP_INCLUDED
-
-// #included from: catch_stream.hpp
-#define TWOBLUECUBES_CATCH_STREAM_HPP_INCLUDED
-
-#include <stdexcept>
-#include <cstdio>
-#include <iostream>
-
-namespace Catch {
-
-    template<typename WriterF, size_t bufferSize=256>
-    class StreamBufImpl : public StreamBufBase {
-        char data[bufferSize];
-        WriterF m_writer;
-
-    public:
-        StreamBufImpl() {
-            setp( data, data + sizeof(data) );
-        }
-
-        ~StreamBufImpl() CATCH_NOEXCEPT {
-            sync();
-        }
-
-    private:
-        int overflow( int c ) {
-            sync();
-
-            if( c != EOF ) {
-                if( pbase() == epptr() )
-                    m_writer( std::string( 1, static_cast<char>( c ) ) );
-                else
-                    sputc( static_cast<char>( c ) );
-            }
-            return 0;
-        }
-
-        int sync() {
-            if( pbase() != pptr() ) {
-                m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
-                setp( pbase(), epptr() );
-            }
-            return 0;
-        }
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    FileStream::FileStream( std::string const& filename ) {
-        m_ofs.open( filename.c_str() );
-        if( m_ofs.fail() ) {
-            std::ostringstream oss;
-            oss << "Unable to open file: '" << filename << '\'';
-            throw std::domain_error( oss.str() );
-        }
-    }
-
-    std::ostream& FileStream::stream() const {
-        return m_ofs;
-    }
-
-    struct OutputDebugWriter {
-
-        void operator()( std::string const&str ) {
-            writeToDebugConsole( str );
-        }
-    };
-
-    DebugOutStream::DebugOutStream()
-    :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
-        m_os( m_streamBuf.get() )
-    {}
-
-    std::ostream& DebugOutStream::stream() const {
-        return m_os;
-    }
-
-    // Store the streambuf from cout up-front because
-    // cout may get redirected when running tests
-    CoutStream::CoutStream()
-    :   m_os( Catch::cout().rdbuf() )
-    {}
-
-    std::ostream& CoutStream::stream() const {
-        return m_os;
-    }
-
-#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
-    std::ostream& cout() {
-        return std::cout;
-    }
-    std::ostream& cerr() {
-        return std::cerr;
-    }
-    std::ostream& clog() {
-        return std::clog;
-    }
-#endif
-}
-
-namespace Catch {
-
-    class Context : public IMutableContext {
-
-        Context() : m_config( CATCH_NULL ), m_runner( CATCH_NULL ), m_resultCapture( CATCH_NULL ) {}
-        Context( Context const& );
-        void operator=( Context const& );
-
-    public:
-        virtual ~Context() {
-            deleteAllValues( m_generatorsByTestName );
-        }
-
-    public: // IContext
-        virtual IResultCapture* getResultCapture() {
-            return m_resultCapture;
-        }
-        virtual IRunner* getRunner() {
-            return m_runner;
-        }
-        virtual size_t getGeneratorIndex( std::string const& fileInfo, size_t totalSize ) {
-            return getGeneratorsForCurrentTest()
-            .getGeneratorInfo( fileInfo, totalSize )
-            .getCurrentIndex();
-        }
-        virtual bool advanceGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            return generators && generators->moveNext();
-        }
-
-        virtual Ptr<IConfig const> getConfig() const {
-            return m_config;
-        }
-
-    public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) {
-            m_resultCapture = resultCapture;
-        }
-        virtual void setRunner( IRunner* runner ) {
-            m_runner = runner;
-        }
-        virtual void setConfig( Ptr<IConfig const> const& config ) {
-            m_config = config;
-        }
-
-        friend IMutableContext& getCurrentMutableContext();
-
-    private:
-        IGeneratorsForTest* findGeneratorsForCurrentTest() {
-            std::string testName = getResultCapture()->getCurrentTestName();
-
-            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
-                m_generatorsByTestName.find( testName );
-            return it != m_generatorsByTestName.end()
-                ? it->second
-                : CATCH_NULL;
-        }
-
-        IGeneratorsForTest& getGeneratorsForCurrentTest() {
-            IGeneratorsForTest* generators = findGeneratorsForCurrentTest();
-            if( !generators ) {
-                std::string testName = getResultCapture()->getCurrentTestName();
-                generators = createGeneratorsForTest();
-                m_generatorsByTestName.insert( std::make_pair( testName, generators ) );
-            }
-            return *generators;
-        }
-
-    private:
-        Ptr<IConfig const> m_config;
-        IRunner* m_runner;
-        IResultCapture* m_resultCapture;
-        std::map<std::string, IGeneratorsForTest*> m_generatorsByTestName;
-    };
-
-    namespace {
-        Context* currentContext = CATCH_NULL;
-    }
-    IMutableContext& getCurrentMutableContext() {
-        if( !currentContext )
-            currentContext = new Context();
-        return *currentContext;
-    }
-    IContext& getCurrentContext() {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext() {
-        delete currentContext;
-        currentContext = CATCH_NULL;
-    }
-}
-
-// #included from: catch_console_colour_impl.hpp
-#define TWOBLUECUBES_CATCH_CONSOLE_COLOUR_IMPL_HPP_INCLUDED
-
-// #included from: catch_errno_guard.hpp
-#define TWOBLUECUBES_CATCH_ERRNO_GUARD_HPP_INCLUDED
-
-#include <cerrno>
-
-namespace Catch {
-
-    class ErrnoGuard {
-    public:
-        ErrnoGuard():m_oldErrno(errno){}
-        ~ErrnoGuard() { errno = m_oldErrno; }
-    private:
-        int m_oldErrno;
-    };
-
-}
 
 namespace Catch {
     namespace {
 
         struct IColourImpl {
-            virtual ~IColourImpl() {}
+            virtual ~IColourImpl() = default;
             virtual void use( Colour::Code _colourCode ) = 0;
         };
 
         struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
+            void use( Colour::Code ) override {}
 
             static IColourImpl* instance() {
                 static NoColourImpl s_instance;
@@ -7944,7 +10121,7 @@ namespace {
             originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
         }
 
-        virtual void use( Colour::Code _colourCode ) {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:      return setTextAttribute( originalForegroundAttributes );
                 case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
@@ -7959,8 +10136,12 @@ namespace {
                 case Colour::BrightRed:     return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
                 case Colour::BrightGreen:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
                 case Colour::BrightWhite:   return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+                case Colour::BrightYellow:  return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
 
-                case Colour::Bright: throw std::logic_error( "not a colour" );
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+
+                default:
+                    CATCH_ERROR( "Unknown colour requested" );
             }
         }
 
@@ -7976,14 +10157,12 @@ namespace {
     IColourImpl* platformColourInstance() {
         static Win32ColourImpl s_instance;
 
-        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        IConfigPtr config = getCurrentContext().getConfig();
         UseColour::YesOrNo colourMode = config
             ? config->useColour()
             : UseColour::Auto;
         if( colourMode == UseColour::Auto )
-            colourMode = !isDebuggerActive()
-                ? UseColour::Yes
-                : UseColour::No;
+            colourMode = UseColour::Yes;
         return colourMode == UseColour::Yes
             ? &s_instance
             : NoColourImpl::instance();
@@ -8005,7 +10184,7 @@ namespace {
     // https://github.com/philsquared/Catch/pull/131
     class PosixColourImpl : public IColourImpl {
     public:
-        virtual void use( Colour::Code _colourCode ) {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:
                 case Colour::White:     return setColour( "[0m" );
@@ -8020,8 +10199,10 @@ namespace {
                 case Colour::BrightRed:     return setColour( "[1;31m" );
                 case Colour::BrightGreen:   return setColour( "[1;32m" );
                 case Colour::BrightWhite:   return setColour( "[1;37m" );
+                case Colour::BrightYellow:  return setColour( "[1;33m" );
 
-                case Colour::Bright: throw std::logic_error( "not a colour" );
+                case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+                default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
             }
         }
         static IColourImpl* instance() {
@@ -8031,18 +10212,31 @@ namespace {
 
     private:
         void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
         }
     };
 
+    bool useColourOnPlatform() {
+        return
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+            !isDebuggerActive() &&
+#endif
+#if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
+            isatty(STDOUT_FILENO)
+#else
+            false
+#endif
+            ;
+    }
     IColourImpl* platformColourInstance() {
         ErrnoGuard guard;
-        Ptr<IConfig const> config = getCurrentContext().getConfig();
+        IConfigPtr config = getCurrentContext().getConfig();
         UseColour::YesOrNo colourMode = config
             ? config->useColour()
             : UseColour::Auto;
         if( colourMode == UseColour::Auto )
-            colourMode = (!isDebuggerActive() && isatty(STDOUT_FILENO) )
+            colourMode = useColourOnPlatform()
                 ? UseColour::Yes
                 : UseColour::No;
         return colourMode == UseColour::Yes
@@ -8065,813 +10259,168 @@ namespace Catch {
 
 namespace Catch {
 
-    Colour::Colour( Code _colourCode ) : m_moved( false ) { use( _colourCode ); }
-    Colour::Colour( Colour const& _other ) : m_moved( false ) { const_cast<Colour&>( _other ).m_moved = true; }
+    Colour::Colour( Code _colourCode ) { use( _colourCode ); }
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
+    }
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
+        return *this;
+    }
+
     Colour::~Colour(){ if( !m_moved ) use( None ); }
 
     void Colour::use( Code _colourCode ) {
         static IColourImpl* impl = platformColourInstance();
-        impl->use( _colourCode );
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, Colour const& ) {
+        return os;
     }
 
 } // end namespace Catch
 
-// #included from: catch_generators_impl.hpp
-#define TWOBLUECUBES_CATCH_GENERATORS_IMPL_HPP_INCLUDED
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+
+// end catch_console_colour.cpp
+// start catch_context.cpp
+
+namespace Catch {
+
+    class Context : public IMutableContext, NonCopyable {
+
+    public: // IContext
+        IResultCapture* getResultCapture() override {
+            return m_resultCapture;
+        }
+        IRunner* getRunner() override {
+            return m_runner;
+        }
+
+        IConfigPtr const& getConfig() const override {
+            return m_config;
+        }
+
+        ~Context() override;
+
+    public: // IMutableContext
+        void setResultCapture( IResultCapture* resultCapture ) override {
+            m_resultCapture = resultCapture;
+        }
+        void setRunner( IRunner* runner ) override {
+            m_runner = runner;
+        }
+        void setConfig( IConfigPtr const& config ) override {
+            m_config = config;
+        }
+
+        friend IMutableContext& getCurrentMutableContext();
+
+    private:
+        IConfigPtr m_config;
+        IRunner* m_runner = nullptr;
+        IResultCapture* m_resultCapture = nullptr;
+    };
+
+    IMutableContext *IMutableContext::currentContext = nullptr;
+
+    void IMutableContext::createContext()
+    {
+        currentContext = new Context();
+    }
+
+    void cleanUpContext() {
+        delete IMutableContext::currentContext;
+        IMutableContext::currentContext = nullptr;
+    }
+    IContext::~IContext() = default;
+    IMutableContext::~IMutableContext() = default;
+    Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
+}
+// end catch_context.cpp
+// start catch_debug_console.cpp
+
+// start catch_debug_console.h
 
-#include <vector>
 #include <string>
-#include <map>
 
 namespace Catch {
-
-    struct GeneratorInfo : IGeneratorInfo {
-
-        GeneratorInfo( std::size_t size )
-        :   m_size( size ),
-            m_currentIndex( 0 )
-        {}
-
-        bool moveNext() {
-            if( ++m_currentIndex == m_size ) {
-                m_currentIndex = 0;
-                return false;
-            }
-            return true;
-        }
-
-        std::size_t getCurrentIndex() const {
-            return m_currentIndex;
-        }
-
-        std::size_t m_size;
-        std::size_t m_currentIndex;
-    };
-
-    ///////////////////////////////////////////////////////////////////////////
-
-    class GeneratorsForTest : public IGeneratorsForTest {
-
-    public:
-        ~GeneratorsForTest() {
-            deleteAll( m_generatorsInOrder );
-        }
-
-        IGeneratorInfo& getGeneratorInfo( std::string const& fileInfo, std::size_t size ) {
-            std::map<std::string, IGeneratorInfo*>::const_iterator it = m_generatorsByName.find( fileInfo );
-            if( it == m_generatorsByName.end() ) {
-                IGeneratorInfo* info = new GeneratorInfo( size );
-                m_generatorsByName.insert( std::make_pair( fileInfo, info ) );
-                m_generatorsInOrder.push_back( info );
-                return *info;
-            }
-            return *it->second;
-        }
-
-        bool moveNext() {
-            std::vector<IGeneratorInfo*>::const_iterator it = m_generatorsInOrder.begin();
-            std::vector<IGeneratorInfo*>::const_iterator itEnd = m_generatorsInOrder.end();
-            for(; it != itEnd; ++it ) {
-                if( (*it)->moveNext() )
-                    return true;
-            }
-            return false;
-        }
-
-    private:
-        std::map<std::string, IGeneratorInfo*> m_generatorsByName;
-        std::vector<IGeneratorInfo*> m_generatorsInOrder;
-    };
-
-    IGeneratorsForTest* createGeneratorsForTest()
-    {
-        return new GeneratorsForTest();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_assertionresult.hpp
-#define TWOBLUECUBES_CATCH_ASSERTIONRESULT_HPP_INCLUDED
-
-namespace Catch {
-
-    AssertionInfo::AssertionInfo():macroName(""), capturedExpression(""), resultDisposition(ResultDisposition::Normal), secondArg(""){}
-
-    AssertionInfo::AssertionInfo(   char const * _macroName,
-                                    SourceLineInfo const& _lineInfo,
-                                    char const * _capturedExpression,
-                                    ResultDisposition::Flags _resultDisposition,
-                                    char const * _secondArg)
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        capturedExpression( _capturedExpression ),
-        resultDisposition( _resultDisposition ),
-        secondArg( _secondArg )
-    {}
-
-    AssertionResult::AssertionResult() {}
-
-    AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData const& data )
-    :   m_info( info ),
-        m_resultData( data )
-    {}
-
-    AssertionResult::~AssertionResult() {}
-
-    // Result was a success
-    bool AssertionResult::succeeded() const {
-        return Catch::isOk( m_resultData.resultType );
-    }
-
-    // Result was a success, or failure is suppressed
-    bool AssertionResult::isOk() const {
-        return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
-    }
-
-    ResultWas::OfType AssertionResult::getResultType() const {
-        return m_resultData.resultType;
-    }
-
-    bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
-    }
-
-    bool AssertionResult::hasMessage() const {
-        return !m_resultData.message.empty();
-    }
-
-    std::string capturedExpressionWithSecondArgument( char const * capturedExpression, char const * secondArg ) {
-        return (secondArg[0] == 0 || secondArg[0] == '"' && secondArg[1] == '"')
-            ? capturedExpression
-            : std::string(capturedExpression) + ", " + secondArg;
-    }
-
-    std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + ")";
-        else
-            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
-    }
-    std::string AssertionResult::getExpressionInMacro() const {
-        if( m_info.macroName[0] == 0 )
-            return capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg);
-        else
-            return std::string(m_info.macroName) + "( " + capturedExpressionWithSecondArgument(m_info.capturedExpression, m_info.secondArg) + " )";
-    }
-
-    bool AssertionResult::hasExpandedExpression() const {
-        return hasExpression() && getExpandedExpression() != getExpression();
-    }
-
-    std::string AssertionResult::getExpandedExpression() const {
-        return m_resultData.reconstructExpression();
-    }
-
-    std::string AssertionResult::getMessage() const {
-        return m_resultData.message;
-    }
-    SourceLineInfo AssertionResult::getSourceInfo() const {
-        return m_info.lineInfo;
-    }
-
-    std::string AssertionResult::getTestMacroName() const {
-        return m_info.macroName;
-    }
-
-    void AssertionResult::discardDecomposedExpression() const {
-        m_resultData.decomposedExpression = CATCH_NULL;
-    }
-
-    void AssertionResult::expandDecomposedExpression() const {
-        m_resultData.reconstructExpression();
-    }
-
-} // end namespace Catch
-
-// #included from: catch_test_case_info.hpp
-#define TWOBLUECUBES_CATCH_TEST_CASE_INFO_HPP_INCLUDED
-
-#include <cctype>
-
-namespace Catch {
-
-    inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( startsWith( tag, '.' ) ||
-            tag == "hide" ||
-            tag == "!hide" )
-            return TestCaseInfo::IsHidden;
-        else if( tag == "!throws" )
-            return TestCaseInfo::Throws;
-        else if( tag == "!shouldfail" )
-            return TestCaseInfo::ShouldFail;
-        else if( tag == "!mayfail" )
-            return TestCaseInfo::MayFail;
-        else if( tag == "!nonportable" )
-            return TestCaseInfo::NonPortable;
-        else
-            return TestCaseInfo::None;
-    }
-    inline bool isReservedTag( std::string const& tag ) {
-        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( tag[0] );
-    }
-    inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-        if( isReservedTag( tag ) ) {
-            std::ostringstream ss;
-            ss << Colour(Colour::Red)
-               << "Tag name [" << tag << "] not allowed.\n"
-               << "Tag names starting with non alpha-numeric characters are reserved\n"
-               << Colour(Colour::FileName)
-               << _lineInfo << '\n';
-            throw std::runtime_error(ss.str());
-        }
-    }
-
-    TestCase makeTestCase(  ITestCase* _testCase,
-                            std::string const& _className,
-                            std::string const& _name,
-                            std::string const& _descOrTags,
-                            SourceLineInfo const& _lineInfo )
-    {
-        bool isHidden( startsWith( _name, "./" ) ); // Legacy support
-
-        // Parse out tags
-        std::set<std::string> tags;
-        std::string desc, tag;
-        bool inTag = false;
-        for( std::size_t i = 0; i < _descOrTags.size(); ++i ) {
-            char c = _descOrTags[i];
-            if( !inTag ) {
-                if( c == '[' )
-                    inTag = true;
-                else
-                    desc += c;
-            }
-            else {
-                if( c == ']' ) {
-                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
-                    if( prop == TestCaseInfo::IsHidden )
-                        isHidden = true;
-                    else if( prop == TestCaseInfo::None )
-                        enforceNotReservedTag( tag, _lineInfo );
-
-                    tags.insert( tag );
-                    tag.clear();
-                    inTag = false;
-                }
-                else
-                    tag += c;
-            }
-        }
-        if( isHidden ) {
-            tags.insert( "hide" );
-            tags.insert( "." );
-        }
-
-        TestCaseInfo info( _name, _className, desc, tags, _lineInfo );
-        return TestCase( _testCase, info );
-    }
-
-    void setTags( TestCaseInfo& testCaseInfo, std::set<std::string> const& tags )
-    {
-        testCaseInfo.tags = tags;
-        testCaseInfo.lcaseTags.clear();
-
-        std::ostringstream oss;
-        for( std::set<std::string>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it ) {
-            oss << '[' << *it << ']';
-            std::string lcaseTag = toLower( *it );
-            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
-            testCaseInfo.lcaseTags.insert( lcaseTag );
-        }
-        testCaseInfo.tagsAsString = oss.str();
-    }
-
-    TestCaseInfo::TestCaseInfo( std::string const& _name,
-                                std::string const& _className,
-                                std::string const& _description,
-                                std::set<std::string> const& _tags,
-                                SourceLineInfo const& _lineInfo )
-    :   name( _name ),
-        className( _className ),
-        description( _description ),
-        lineInfo( _lineInfo ),
-        properties( None )
-    {
-        setTags( *this, _tags );
-    }
-
-    TestCaseInfo::TestCaseInfo( TestCaseInfo const& other )
-    :   name( other.name ),
-        className( other.className ),
-        description( other.description ),
-        tags( other.tags ),
-        lcaseTags( other.lcaseTags ),
-        tagsAsString( other.tagsAsString ),
-        lineInfo( other.lineInfo ),
-        properties( other.properties )
-    {}
-
-    bool TestCaseInfo::isHidden() const {
-        return ( properties & IsHidden ) != 0;
-    }
-    bool TestCaseInfo::throws() const {
-        return ( properties & Throws ) != 0;
-    }
-    bool TestCaseInfo::okToFail() const {
-        return ( properties & (ShouldFail | MayFail ) ) != 0;
-    }
-    bool TestCaseInfo::expectedToFail() const {
-        return ( properties & (ShouldFail ) ) != 0;
-    }
-
-    TestCase::TestCase( ITestCase* testCase, TestCaseInfo const& info ) : TestCaseInfo( info ), test( testCase ) {}
-
-    TestCase::TestCase( TestCase const& other )
-    :   TestCaseInfo( other ),
-        test( other.test )
-    {}
-
-    TestCase TestCase::withName( std::string const& _newName ) const {
-        TestCase other( *this );
-        other.name = _newName;
-        return other;
-    }
-
-    void TestCase::swap( TestCase& other ) {
-        test.swap( other.test );
-        name.swap( other.name );
-        className.swap( other.className );
-        description.swap( other.description );
-        tags.swap( other.tags );
-        lcaseTags.swap( other.lcaseTags );
-        tagsAsString.swap( other.tagsAsString );
-        std::swap( TestCaseInfo::properties, static_cast<TestCaseInfo&>( other ).properties );
-        std::swap( lineInfo, other.lineInfo );
-    }
-
-    void TestCase::invoke() const {
-        test->invoke();
-    }
-
-    bool TestCase::operator == ( TestCase const& other ) const {
-        return  test.get() == other.test.get() &&
-                name == other.name &&
-                className == other.className;
-    }
-
-    bool TestCase::operator < ( TestCase const& other ) const {
-        return name < other.name;
-    }
-    TestCase& TestCase::operator = ( TestCase const& other ) {
-        TestCase temp( other );
-        swap( temp );
-        return *this;
-    }
-
-    TestCaseInfo const& TestCase::getTestCaseInfo() const
-    {
-        return *this;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_version.hpp
-#define TWOBLUECUBES_CATCH_VERSION_HPP_INCLUDED
-
-namespace Catch {
-
-    Version::Version
-        (   unsigned int _majorVersion,
-            unsigned int _minorVersion,
-            unsigned int _patchNumber,
-            char const * const _branchName,
-            unsigned int _buildNumber )
-    :   majorVersion( _majorVersion ),
-        minorVersion( _minorVersion ),
-        patchNumber( _patchNumber ),
-        branchName( _branchName ),
-        buildNumber( _buildNumber )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, Version const& version ) {
-        os  << version.majorVersion << '.'
-            << version.minorVersion << '.'
-            << version.patchNumber;
-        // branchName is never null -> 0th char is \0 if it is empty
-        if (version.branchName[0]) {
-            os << '-' << version.branchName
-               << '.' << version.buildNumber;
-        }
-        return os;
-    }
-
-    inline Version libraryVersion() {
-        static Version version( 1, 12, 1, "", 0 );
-        return version;
-    }
-
+    void writeToDebugConsole( std::string const& text );
 }
 
-// #included from: catch_message.hpp
-#define TWOBLUECUBES_CATCH_MESSAGE_HPP_INCLUDED
+// end catch_debug_console.h
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
 
-namespace Catch {
-
-    MessageInfo::MessageInfo(   std::string const& _macroName,
-                                SourceLineInfo const& _lineInfo,
-                                ResultWas::OfType _type )
-    :   macroName( _macroName ),
-        lineInfo( _lineInfo ),
-        type( _type ),
-        sequence( ++globalCount )
-    {}
-
-    // This may need protecting if threading support is added
-    unsigned int MessageInfo::globalCount = 0;
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
-    {
-        m_info.message = builder.m_stream.str();
-        getResultCapture().pushScopedMessage( m_info );
-    }
-    ScopedMessage::ScopedMessage( ScopedMessage const& other )
-    : m_info( other.m_info )
-    {}
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
-#endif
-    ScopedMessage::~ScopedMessage() {
-        if ( !std::uncaught_exception() ){
-            getResultCapture().popScopedMessage(m_info);
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
         }
     }
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
 
-} // end namespace Catch
+#elif defined(CATCH_PLATFORM_WINDOWS)
 
-// #included from: catch_legacy_reporter_adapter.hpp
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_HPP_INCLUDED
-
-// #included from: catch_legacy_reporter_adapter.h
-#define TWOBLUECUBES_CATCH_LEGACY_REPORTER_ADAPTER_H_INCLUDED
-
-namespace Catch
-{
-    // Deprecated
-    struct IReporter : IShared {
-        virtual ~IReporter();
-
-        virtual bool shouldRedirectStdout() const = 0;
-
-        virtual void StartTesting() = 0;
-        virtual void EndTesting( Totals const& totals ) = 0;
-        virtual void StartGroup( std::string const& groupName ) = 0;
-        virtual void EndGroup( std::string const& groupName, Totals const& totals ) = 0;
-        virtual void StartTestCase( TestCaseInfo const& testInfo ) = 0;
-        virtual void EndTestCase( TestCaseInfo const& testInfo, Totals const& totals, std::string const& stdOut, std::string const& stdErr ) = 0;
-        virtual void StartSection( std::string const& sectionName, std::string const& description ) = 0;
-        virtual void EndSection( std::string const& sectionName, Counts const& assertions ) = 0;
-        virtual void NoAssertionsInSection( std::string const& sectionName ) = 0;
-        virtual void NoAssertionsInTestCase( std::string const& testName ) = 0;
-        virtual void Aborted() = 0;
-        virtual void Result( AssertionResult const& result ) = 0;
-    };
-
-    class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
-    {
-    public:
-        LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter );
-        virtual ~LegacyReporterAdapter();
-
-        virtual ReporterPreferences getPreferences() const;
-        virtual void noMatchingTestCases( std::string const& );
-        virtual void testRunStarting( TestRunInfo const& );
-        virtual void testGroupStarting( GroupInfo const& groupInfo );
-        virtual void testCaseStarting( TestCaseInfo const& testInfo );
-        virtual void sectionStarting( SectionInfo const& sectionInfo );
-        virtual void assertionStarting( AssertionInfo const& );
-        virtual bool assertionEnded( AssertionStats const& assertionStats );
-        virtual void sectionEnded( SectionStats const& sectionStats );
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats );
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats );
-        virtual void testRunEnded( TestRunStats const& testRunStats );
-        virtual void skipTest( TestCaseInfo const& );
-
-    private:
-        Ptr<IReporter> m_legacyReporter;
-    };
-}
-
-namespace Catch
-{
-    LegacyReporterAdapter::LegacyReporterAdapter( Ptr<IReporter> const& legacyReporter )
-    :   m_legacyReporter( legacyReporter )
-    {}
-    LegacyReporterAdapter::~LegacyReporterAdapter() {}
-
-    ReporterPreferences LegacyReporterAdapter::getPreferences() const {
-        ReporterPreferences prefs;
-        prefs.shouldRedirectStdOut = m_legacyReporter->shouldRedirectStdout();
-        return prefs;
-    }
-
-    void LegacyReporterAdapter::noMatchingTestCases( std::string const& ) {}
-    void LegacyReporterAdapter::testRunStarting( TestRunInfo const& ) {
-        m_legacyReporter->StartTesting();
-    }
-    void LegacyReporterAdapter::testGroupStarting( GroupInfo const& groupInfo ) {
-        m_legacyReporter->StartGroup( groupInfo.name );
-    }
-    void LegacyReporterAdapter::testCaseStarting( TestCaseInfo const& testInfo ) {
-        m_legacyReporter->StartTestCase( testInfo );
-    }
-    void LegacyReporterAdapter::sectionStarting( SectionInfo const& sectionInfo ) {
-        m_legacyReporter->StartSection( sectionInfo.name, sectionInfo.description );
-    }
-    void LegacyReporterAdapter::assertionStarting( AssertionInfo const& ) {
-        // Not on legacy interface
-    }
-
-    bool LegacyReporterAdapter::assertionEnded( AssertionStats const& assertionStats ) {
-        if( assertionStats.assertionResult.getResultType() != ResultWas::Ok ) {
-            for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                    it != itEnd;
-                    ++it ) {
-                if( it->type == ResultWas::Info ) {
-                    ResultBuilder rb( it->macroName.c_str(), it->lineInfo, "", ResultDisposition::Normal );
-                    rb << it->message;
-                    rb.setResultType( ResultWas::Info );
-                    AssertionResult result = rb.build();
-                    m_legacyReporter->Result( result );
-                }
-            }
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            ::OutputDebugStringA( text.c_str() );
         }
-        m_legacyReporter->Result( assertionStats.assertionResult );
-        return true;
     }
-    void LegacyReporterAdapter::sectionEnded( SectionStats const& sectionStats ) {
-        if( sectionStats.missingAssertions )
-            m_legacyReporter->NoAssertionsInSection( sectionStats.sectionInfo.name );
-        m_legacyReporter->EndSection( sectionStats.sectionInfo.name, sectionStats.assertions );
-    }
-    void LegacyReporterAdapter::testCaseEnded( TestCaseStats const& testCaseStats ) {
-        m_legacyReporter->EndTestCase
-            (   testCaseStats.testInfo,
-                testCaseStats.totals,
-                testCaseStats.stdOut,
-                testCaseStats.stdErr );
-    }
-    void LegacyReporterAdapter::testGroupEnded( TestGroupStats const& testGroupStats ) {
-        if( testGroupStats.aborting )
-            m_legacyReporter->Aborted();
-        m_legacyReporter->EndGroup( testGroupStats.groupInfo.name, testGroupStats.totals );
-    }
-    void LegacyReporterAdapter::testRunEnded( TestRunStats const& testRunStats ) {
-        m_legacyReporter->EndTesting( testRunStats.totals );
-    }
-    void LegacyReporterAdapter::skipTest( TestCaseInfo const& ) {
-    }
-}
-
-// #included from: catch_timer.hpp
-
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wc++11-long-long"
-#endif
-
-#ifdef CATCH_PLATFORM_WINDOWS
 
 #else
 
-#include <sys/time.h>
-
-#endif
-
-namespace Catch {
-
-    namespace {
-#ifdef CATCH_PLATFORM_WINDOWS
-        UInt64 getCurrentTicks() {
-            static UInt64 hz=0, hzo=0;
-            if (!hz) {
-                QueryPerformanceFrequency( reinterpret_cast<LARGE_INTEGER*>( &hz ) );
-                QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &hzo ) );
-            }
-            UInt64 t;
-            QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>( &t ) );
-            return ((t-hzo)*1000000)/hz;
-        }
-#else
-        UInt64 getCurrentTicks() {
-            timeval t;
-            gettimeofday(&t,CATCH_NULL);
-            return static_cast<UInt64>( t.tv_sec ) * 1000000ull + static_cast<UInt64>( t.tv_usec );
-        }
-#endif
-    }
-
-    void Timer::start() {
-        m_ticks = getCurrentTicks();
-    }
-    unsigned int Timer::getElapsedMicroseconds() const {
-        return static_cast<unsigned int>(getCurrentTicks() - m_ticks);
-    }
-    unsigned int Timer::getElapsedMilliseconds() const {
-        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
-    }
-    double Timer::getElapsedSeconds() const {
-        return getElapsedMicroseconds()/1000000.0;
-    }
-
-} // namespace Catch
-
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
-// #included from: catch_common.hpp
-#define TWOBLUECUBES_CATCH_COMMON_HPP_INCLUDED
-
-#include <cstring>
-#include <cctype>
-
-namespace Catch {
-
-    bool startsWith( std::string const& s, std::string const& prefix ) {
-        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
-    }
-    bool startsWith( std::string const& s, char prefix ) {
-        return !s.empty() && s[0] == prefix;
-    }
-    bool endsWith( std::string const& s, std::string const& suffix ) {
-        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
-    }
-    bool endsWith( std::string const& s, char suffix ) {
-        return !s.empty() && s[s.size()-1] == suffix;
-    }
-    bool contains( std::string const& s, std::string const& infix ) {
-        return s.find( infix ) != std::string::npos;
-    }
-    char toLowerCh(char c) {
-        return static_cast<char>( std::tolower( c ) );
-    }
-    void toLowerInPlace( std::string& s ) {
-        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
-    }
-    std::string toLower( std::string const& s ) {
-        std::string lc = s;
-        toLowerInPlace( lc );
-        return lc;
-    }
-    std::string trim( std::string const& str ) {
-        static char const* whitespaceChars = "\n\r\t ";
-        std::string::size_type start = str.find_first_not_of( whitespaceChars );
-        std::string::size_type end = str.find_last_not_of( whitespaceChars );
-
-        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
-    }
-
-    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
-        bool replaced = false;
-        std::size_t i = str.find( replaceThis );
-        while( i != std::string::npos ) {
-            replaced = true;
-            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
-            if( i < str.size()-withThis.size() )
-                i = str.find( replaceThis, i+withThis.size() );
-            else
-                i = std::string::npos;
-        }
-        return replaced;
-    }
-
-    pluralise::pluralise( std::size_t count, std::string const& label )
-    :   m_count( count ),
-        m_label( label )
-    {}
-
-    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
-        os << pluraliser.m_count << ' ' << pluraliser.m_label;
-        if( pluraliser.m_count != 1 )
-            os << 's';
-        return os;
-    }
-
-    SourceLineInfo::SourceLineInfo() : file(""), line( 0 ){}
-    SourceLineInfo::SourceLineInfo( char const* _file, std::size_t _line )
-    :   file( _file ),
-        line( _line )
-    {}
-    bool SourceLineInfo::empty() const {
-        return file[0] == '\0';
-    }
-    bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const {
-        return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
-    }
-    bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const {
-        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
-    }
-
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 )
-            std::srand( config.rngSeed() );
-    }
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
-    }
-
-    std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
-#ifndef __GNUG__
-        os << info.file << '(' << info.line << ')';
-#else
-        os << info.file << ':' << info.line;
-#endif
-        return os;
-    }
-
-    void throwLogicError( std::string const& message, SourceLineInfo const& locationInfo ) {
-        std::ostringstream oss;
-        oss << locationInfo << ": Internal Catch error: '" << message << '\'';
-        if( alwaysTrue() )
-            throw std::logic_error( oss.str() );
-    }
-}
-
-// #included from: catch_section.hpp
-#define TWOBLUECUBES_CATCH_SECTION_HPP_INCLUDED
-
-namespace Catch {
-
-    SectionInfo::SectionInfo
-        (   SourceLineInfo const& _lineInfo,
-            std::string const& _name,
-            std::string const& _description )
-    :   name( _name ),
-        description( _description ),
-        lineInfo( _lineInfo )
-    {}
-
-    Section::Section( SectionInfo const& info )
-    :   m_info( info ),
-        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
-    {
-        m_timer.start();
-    }
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4996) // std::uncaught_exception is deprecated in C++17
-#endif
-    Section::~Section() {
-        if( m_sectionIncluded ) {
-            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
-            if( std::uncaught_exception() )
-                getResultCapture().sectionEndedEarly( endInfo );
-            else
-                getResultCapture().sectionEnded( endInfo );
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            // !TBD: Need a version for Mac/ XCode and other IDEs
+            Catch::cout() << text;
         }
     }
-#if defined(_MSC_VER)
-#pragma warning(pop)
+
+#endif // Platform
+// end catch_debug_console.cpp
+// start catch_debugger.cpp
+
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+
+#  include <cassert>
+#  include <sys/types.h>
+#  include <unistd.h>
+#  include <cstddef>
+#  include <ostream>
+
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
 #endif
 
-    // This indicates whether the section should be executed or not
-    Section::operator bool() const {
-        return m_sectionIncluded;
-    }
-
-} // end namespace Catch
-
-// #included from: catch_debugger.hpp
-#define TWOBLUECUBES_CATCH_DEBUGGER_HPP_INCLUDED
-
-#ifdef CATCH_PLATFORM_MAC
-
-    #include <assert.h>
-    #include <stdbool.h>
-    #include <sys/types.h>
-    #include <unistd.h>
-    #include <sys/sysctl.h>
-
-    namespace Catch{
-
+    namespace Catch {
+        #ifdef __apple_build_version__
         // The following function is taken directly from the following technical note:
-        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
 
         // Returns true if the current process is being debugged (either
         // running under the debugger or has a debugger attached post facto).
         bool isDebuggerActive(){
-
             int                 mib[4];
             struct kinfo_proc   info;
-            size_t              size;
+            std::size_t         size;
 
             // Initialize the flags so that, if sysctl fails for some bizarre
             // reason, we get a predictable result.
@@ -8889,7 +10438,7 @@ namespace Catch {
             // Call sysctl.
 
             size = sizeof(info);
-            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, CATCH_NULL, 0) != 0 ) {
+            if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
                 Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n" << std::endl;
                 return false;
             }
@@ -8898,6 +10447,12 @@ namespace Catch {
 
             return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
         }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
     } // namespace Catch
 
 #elif defined(CATCH_PLATFORM_LINUX)
@@ -8946,449 +10501,1209 @@ namespace Catch {
     }
 #else
     namespace Catch {
-       inline bool isDebuggerActive() { return false; }
+       bool isDebuggerActive() { return false; }
     }
 #endif // Platform
-
-#ifdef CATCH_PLATFORM_WINDOWS
-
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            ::OutputDebugStringA( text.c_str() );
-        }
-    }
-#else
-    namespace Catch {
-        void writeToDebugConsole( std::string const& text ) {
-            // !TBD: Need a version for Mac/ XCode and other IDEs
-            Catch::cout() << text;
-        }
-    }
-#endif // Platform
-
-// #included from: catch_tostring.hpp
-#define TWOBLUECUBES_CATCH_TOSTRING_HPP_INCLUDED
+// end catch_debugger.cpp
+// start catch_decomposer.cpp
 
 namespace Catch {
 
-namespace Detail {
+    ITransientExpression::~ITransientExpression() = default;
 
-    const std::string unprintableString = "{?}";
+    void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+        if( lhs.size() + rhs.size() < 40 &&
+                lhs.find('\n') == std::string::npos &&
+                rhs.find('\n') == std::string::npos )
+            os << lhs << " " << op << " " << rhs;
+        else
+            os << lhs << "\n" << op << "\n" << rhs;
+    }
+}
+// end catch_decomposer.cpp
+// start catch_enforce.cpp
 
-    namespace {
-        const int hexThreshold = 255;
+#include <stdexcept>
 
-        struct Endianness {
-            enum Arch { Big, Little };
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
 
-            static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
 
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
-            }
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
         };
-    }
 
-    std::string rawMemoryToString( const void *object, std::size_t size )
-    {
-        // Reverse order for little endian architectures
-        int i = 0, end = static_cast<int>( size ), inc = 1;
-        if( Endianness::which() == Endianness::Little ) {
-            i = end-1;
-            end = inc = -1;
-        }
+        std::vector<StringRef> parseEnums( StringRef enums );
 
-        unsigned char const *bytes = static_cast<unsigned char const *>(object);
-        std::ostringstream os;
-        os << "0x" << std::setfill('0') << std::hex;
-        for( ; i != end; i += inc )
-             os << std::setw(2) << static_cast<unsigned>(bytes[i]);
-       return os.str();
-    }
-}
+    } // Detail
 
-std::string toString( std::string const& value ) {
-    std::string s = value;
-    if( getCurrentContext().getConfig()->showInvisibles() ) {
-        for(size_t i = 0; i < s.size(); ++i ) {
-            std::string subs;
-            switch( s[i] ) {
-            case '\n': subs = "\\n"; break;
-            case '\t': subs = "\\t"; break;
-            default: break;
-            }
-            if( !subs.empty() ) {
-                s = s.substr( 0, i ) + subs + s.substr( i+1 );
-                ++i;
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurrence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
             }
         }
-    }
-    return '"' + s + '"';
-}
-std::string toString( std::wstring const& value ) {
 
-    std::string s;
-    s.reserve( value.size() );
-    for(size_t i = 0; i < value.size(); ++i )
-        s += value[i] <= 0xff ? static_cast<char>( value[i] ) : '?';
-    return Catch::toString( s );
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
+// start catch_errno_guard.cpp
+
+#include <cerrno>
+
+namespace Catch {
+        ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+        ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+}
+// end catch_errno_guard.cpp
+// start catch_exception_translator_registry.cpp
+
+// start catch_exception_translator_registry.h
+
+#include <vector>
+#include <string>
+#include <memory>
+
+namespace Catch {
+
+    class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+    public:
+        ~ExceptionTranslatorRegistry();
+        virtual void registerTranslator( const IExceptionTranslator* translator );
+        std::string translateActiveException() const override;
+        std::string tryTranslators() const;
+
+    private:
+        std::vector<std::unique_ptr<IExceptionTranslator const>> m_translators;
+    };
 }
 
-std::string toString( const char* const value ) {
-    return value ? Catch::toString( std::string( value ) ) : std::string( "{null string}" );
-}
-
-std::string toString( char* const value ) {
-    return Catch::toString( static_cast<const char*>( value ) );
-}
-
-std::string toString( const wchar_t* const value )
-{
-    return value ? Catch::toString( std::wstring(value) ) : std::string( "{null string}" );
-}
-
-std::string toString( wchar_t* const value )
-{
-    return Catch::toString( static_cast<const wchar_t*>( value ) );
-}
-
-std::string toString( int value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-
-std::string toString( unsigned long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-
-std::string toString( unsigned int value ) {
-    return Catch::toString( static_cast<unsigned long>( value ) );
-}
-
-template<typename T>
-std::string fpToString( T value, int precision ) {
-    std::ostringstream oss;
-    oss << std::setprecision( precision )
-        << std::fixed
-        << value;
-    std::string d = oss.str();
-    std::size_t i = d.find_last_not_of( '0' );
-    if( i != std::string::npos && i != d.size()-1 ) {
-        if( d[i] == '.' )
-            i++;
-        d = d.substr( 0, i+1 );
-    }
-    return d;
-}
-
-std::string toString( const double value ) {
-    return fpToString( value, 10 );
-}
-std::string toString( const float value ) {
-    return fpToString( value, 5 ) + 'f';
-}
-
-std::string toString( bool value ) {
-    return value ? "true" : "false";
-}
-
-std::string toString( char value ) {
-    if ( value == '\r' )
-        return "'\\r'";
-    if ( value == '\f' )
-        return "'\\f'";
-    if ( value == '\n' )
-        return "'\\n'";
-    if ( value == '\t' )
-        return "'\\t'";
-    if ( '\0' <= value && value < ' ' )
-        return toString( static_cast<unsigned int>( value ) );
-    char chstr[] = "' '";
-    chstr[1] = value;
-    return chstr;
-}
-
-std::string toString( signed char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-std::string toString( unsigned char value ) {
-    return toString( static_cast<char>( value ) );
-}
-
-#ifdef CATCH_CONFIG_CPP11_LONG_LONG
-std::string toString( long long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-std::string toString( unsigned long long value ) {
-    std::ostringstream oss;
-    oss << value;
-    if( value > Detail::hexThreshold )
-        oss << " (0x" << std::hex << value << ')';
-    return oss.str();
-}
-#endif
-
-#ifdef CATCH_CONFIG_CPP11_NULLPTR
-std::string toString( std::nullptr_t ) {
-    return "nullptr";
-}
-#endif
-
+// end catch_exception_translator_registry.h
 #ifdef __OBJC__
-    std::string toString( NSString const * const& nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
+#import "Foundation/Foundation.h"
+#endif
+
+namespace Catch {
+
+    ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() {
     }
-    std::string toString( NSString * CATCH_ARC_STRONG & nsstring ) {
-        if( !nsstring )
-            return "nil";
-        return "@" + toString([nsstring UTF8String]);
+
+    void ExceptionTranslatorRegistry::registerTranslator( const IExceptionTranslator* translator ) {
+        m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
     }
-    std::string toString( NSObject* const& nsObject ) {
-        return toString( [nsObject description] );
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        try {
+#ifdef __OBJC__
+            // In Objective-C try objective-c exceptions first
+            @try {
+                return tryTranslators();
+            }
+            @catch (NSException *exception) {
+                return Catch::Detail::stringify( [exception description] );
+            }
+#else
+            // Compiling a mixed mode project with MSVC means that CLR
+            // exceptions will be caught in (...) as well. However, these
+            // do not fill-in std::current_exception and thus lead to crash
+            // when attempting rethrow.
+            // /EHa switch also causes structured exceptions to be caught
+            // here, but they fill-in current_exception properly, so
+            // at worst the output should be a little weird, instead of
+            // causing a crash.
+            if (std::current_exception() == nullptr) {
+                return "Non C++ exception. Possibly a CLR exception.";
+            }
+            return tryTranslators();
+#endif
+        }
+        catch( TestFailureException& ) {
+            std::rethrow_exception(std::current_exception());
+        }
+        catch( std::exception& ex ) {
+            return ex.what();
+        }
+        catch( std::string& msg ) {
+            return msg;
+        }
+        catch( const char* msg ) {
+            return msg;
+        }
+        catch(...) {
+            return "Unknown exception";
+        }
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        if (m_translators.empty()) {
+            std::rethrow_exception(std::current_exception());
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
     }
 #endif
 
+}
+// end catch_exception_translator_registry.cpp
+// start catch_fatal_condition.cpp
+
+#include <algorithm>
+
+#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace Catch {
+
+    // If neither SEH nor signal handling is required, the handler impls
+    // do not have to do anything, and can be empty.
+    void FatalConditionHandler::engage_platform() {}
+    void FatalConditionHandler::disengage_platform() {}
+    FatalConditionHandler::FatalConditionHandler() = default;
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
 } // end namespace Catch
 
-// #included from: catch_result_builder.hpp
-#define TWOBLUECUBES_CATCH_RESULT_BUILDER_HPP_INCLUDED
+#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
+#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
+#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+namespace {
+    //! Signals fatal error message to the run context
+    void reportFatal( char const * const message ) {
+        Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+    }
+
+    //! Minimal size Catch2 needs for its own fatal error handling.
+    //! Picked anecdotally, so it might not be sufficient on all
+    //! platforms, and for all configurations.
+    constexpr std::size_t minStackSizeForErrors = 32 * 1024;
+} // end unnamed namespace
+
+#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
+
+#if defined( CATCH_CONFIG_WINDOWS_SEH )
 
 namespace Catch {
 
-    ResultBuilder::ResultBuilder(   char const* macroName,
-                                    SourceLineInfo const& lineInfo,
-                                    char const* capturedExpression,
-                                    ResultDisposition::Flags resultDisposition,
-                                    char const* secondArg )
-    :   m_assertionInfo( macroName, lineInfo, capturedExpression, resultDisposition, secondArg ),
-        m_shouldDebugBreak( false ),
-        m_shouldThrow( false ),
-        m_guardException( false ),
-        m_usedStream( false )
+    struct SignalDefs { DWORD id; const char* name; };
+
+    // There is no 1-1 mapping between signals and windows exceptions.
+    // Windows can easily distinguish between SO and SigSegV,
+    // but SigInt, SigTerm, etc are handled differently.
+    static SignalDefs signalDefs[] = {
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
+    };
+
+    static LONG CALLBACK handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
+        for (auto const& def : signalDefs) {
+            if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+                reportFatal(def.name);
+            }
+        }
+        // If its not an exception we care about, pass it along.
+        // This stops us from eating debugger breaks etc.
+        return EXCEPTION_CONTINUE_SEARCH;
+    }
+
+    // Since we do not support multiple instantiations, we put these
+    // into global variables and rely on cleaning them up in outlined
+    // constructors/destructors
+    static PVOID exceptionHandlerHandle = nullptr;
+
+    // For MSVC, we reserve part of the stack memory for handling
+    // memory overflow structured exception.
+    FatalConditionHandler::FatalConditionHandler() {
+        ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
+        if (!SetThreadStackGuarantee(&guaranteeSize)) {
+            // We do not want to fully error out, because needing
+            // the stack reserve should be rare enough anyway.
+            Catch::cerr()
+                << "Failed to reserve piece of stack."
+                << " Stack overflows will not be reported successfully.";
+        }
+    }
+
+    // We do not attempt to unset the stack guarantee, because
+    // Windows does not support lowering the stack size guarantee.
+    FatalConditionHandler::~FatalConditionHandler() = default;
+
+    void FatalConditionHandler::engage_platform() {
+        // Register as first handler in current chain
+        exceptionHandlerHandle = AddVectoredExceptionHandler(1, handleVectoredException);
+        if (!exceptionHandlerHandle) {
+            CATCH_RUNTIME_ERROR("Could not register vectored exception handler");
+        }
+    }
+
+    void FatalConditionHandler::disengage_platform() {
+        if (!RemoveVectoredExceptionHandler(exceptionHandlerHandle)) {
+            CATCH_RUNTIME_ERROR("Could not unregister vectored exception handler");
+        }
+        exceptionHandlerHandle = nullptr;
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_WINDOWS_SEH
+
+#if defined( CATCH_CONFIG_POSIX_SIGNALS )
+
+#include <signal.h>
+
+namespace Catch {
+
+    struct SignalDefs {
+        int id;
+        const char* name;
+    };
+
+    static SignalDefs signalDefs[] = {
+        { SIGINT,  "SIGINT - Terminal interrupt signal" },
+        { SIGILL,  "SIGILL - Illegal instruction signal" },
+        { SIGFPE,  "SIGFPE - Floating point error signal" },
+        { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+        { SIGTERM, "SIGTERM - Termination request signal" },
+        { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+    };
+
+// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+// which is zero initialization, but not explicit. We want to avoid
+// that.
+#if defined(__GNUC__)
+#    pragma GCC diagnostic push
+#    pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#endif
+
+    static char* altStackMem = nullptr;
+    static std::size_t altStackSize = 0;
+    static stack_t oldSigStack{};
+    static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
+
+    static void restorePreviousSignalHandlers() {
+        // We set signal handlers back to the previous ones. Hopefully
+        // nobody overwrote them in the meantime, and doesn't expect
+        // their signal handlers to live past ours given that they
+        // installed them after ours..
+        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+        }
+        // Return the old stack
+        sigaltstack(&oldSigStack, nullptr);
+    }
+
+    static void handleSignal( int sig ) {
+        char const * name = "<unknown signal>";
+        for (auto const& def : signalDefs) {
+            if (sig == def.id) {
+                name = def.name;
+                break;
+            }
+        }
+        // We need to restore previous signal handlers and let them do
+        // their thing, so that the users can have the debugger break
+        // when a signal is raised, and so on.
+        restorePreviousSignalHandlers();
+        reportFatal( name );
+        raise( sig );
+    }
+
+    FatalConditionHandler::FatalConditionHandler() {
+        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+        if (altStackSize == 0) {
+            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
+        }
+        altStackMem = new char[altStackSize]();
+    }
+
+    FatalConditionHandler::~FatalConditionHandler() {
+        delete[] altStackMem;
+        // We signal that another instance can be constructed by zeroing
+        // out the pointer.
+        altStackMem = nullptr;
+    }
+
+    void FatalConditionHandler::engage_platform() {
+        stack_t sigStack;
+        sigStack.ss_sp = altStackMem;
+        sigStack.ss_size = altStackSize;
+        sigStack.ss_flags = 0;
+        sigaltstack(&sigStack, &oldSigStack);
+        struct sigaction sa = { };
+
+        sa.sa_handler = handleSignal;
+        sa.sa_flags = SA_ONSTACK;
+        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+        }
+    }
+
+#if defined(__GNUC__)
+#    pragma GCC diagnostic pop
+#endif
+
+    void FatalConditionHandler::disengage_platform() {
+        restorePreviousSignalHandlers();
+    }
+
+} // end namespace Catch
+
+#endif // CATCH_CONFIG_POSIX_SIGNALS
+// end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
+// start catch_interfaces_capture.cpp
+
+namespace Catch {
+    IResultCapture::~IResultCapture() = default;
+}
+// end catch_interfaces_capture.cpp
+// start catch_interfaces_config.cpp
+
+namespace Catch {
+    IConfig::~IConfig() = default;
+}
+// end catch_interfaces_config.cpp
+// start catch_interfaces_exception.cpp
+
+namespace Catch {
+    IExceptionTranslator::~IExceptionTranslator() = default;
+    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+}
+// end catch_interfaces_exception.cpp
+// start catch_interfaces_registry_hub.cpp
+
+namespace Catch {
+    IRegistryHub::~IRegistryHub() = default;
+    IMutableRegistryHub::~IMutableRegistryHub() = default;
+}
+// end catch_interfaces_registry_hub.cpp
+// start catch_interfaces_reporter.cpp
+
+// start catch_reporter_listening.h
+
+namespace Catch {
+
+    class ListeningReporter : public IStreamingReporter {
+        using Reporters = std::vector<IStreamingReporterPtr>;
+        Reporters m_listeners;
+        IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
+
+    public:
+        ListeningReporter();
+
+        void addListener( IStreamingReporterPtr&& listener );
+        void addReporter( IStreamingReporterPtr&& reporter );
+
+    public: // IStreamingReporter
+
+        ReporterPreferences getPreferences() const override;
+
+        void noMatchingTestCases( std::string const& spec ) override;
+
+        void reportInvalidArguments(std::string const&arg) override;
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        void testRunStarting( TestRunInfo const& testRunInfo ) override;
+        void testGroupStarting( GroupInfo const& groupInfo ) override;
+        void testCaseStarting( TestCaseInfo const& testInfo ) override;
+        void sectionStarting( SectionInfo const& sectionInfo ) override;
+        void assertionStarting( AssertionInfo const& assertionInfo ) override;
+
+        // The return value indicates if the messages buffer should be cleared:
+        bool assertionEnded( AssertionStats const& assertionStats ) override;
+        void sectionEnded( SectionStats const& sectionStats ) override;
+        void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+        void testGroupEnded( TestGroupStats const& testGroupStats ) override;
+        void testRunEnded( TestRunStats const& testRunStats ) override;
+
+        void skipTest( TestCaseInfo const& testInfo ) override;
+        bool isMulti() const override;
+
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_listening.h
+namespace Catch {
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig )
+    :   m_stream( &_fullConfig->stream() ), m_fullConfig( _fullConfig ) {}
+
+    ReporterConfig::ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream )
+    :   m_stream( &_stream ), m_fullConfig( _fullConfig ) {}
+
+    std::ostream& ReporterConfig::stream() const { return *m_stream; }
+    IConfigPtr ReporterConfig::fullConfig() const { return m_fullConfig; }
+
+    TestRunInfo::TestRunInfo( std::string const& _name ) : name( _name ) {}
+
+    GroupInfo::GroupInfo(  std::string const& _name,
+                           std::size_t _groupIndex,
+                           std::size_t _groupsCount )
+    :   name( _name ),
+        groupIndex( _groupIndex ),
+        groupsCounts( _groupsCount )
     {}
 
-    ResultBuilder::~ResultBuilder() {
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-        if ( m_guardException ) {
-            stream().oss << "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
-            captureResult( ResultWas::ThrewException );
-            getCurrentContext().getResultCapture()->exceptionEarlyReported();
-        }
-#endif
-    }
-
-    ResultBuilder& ResultBuilder::setResultType( ResultWas::OfType result ) {
-        m_data.resultType = result;
-        return *this;
-    }
-    ResultBuilder& ResultBuilder::setResultType( bool result ) {
-        m_data.resultType = result ? ResultWas::Ok : ResultWas::ExpressionFailed;
-        return *this;
-    }
-
-    void ResultBuilder::endExpression( DecomposedExpression const& expr ) {
-        // Flip bool results if FalseTest flag is set
-        if( isFalseTest( m_assertionInfo.resultDisposition ) ) {
-            m_data.negate( expr.isBinaryExpression() );
-        }
-
-        getResultCapture().assertionRun();
-
-        if(getCurrentContext().getConfig()->includeSuccessfulResults() || m_data.resultType != ResultWas::Ok)
-        {
-            AssertionResult result = build( expr );
-            handleResult( result );
-        }
-        else
-            getResultCapture().assertionPassed();
-    }
-
-    void ResultBuilder::useActiveException( ResultDisposition::Flags resultDisposition ) {
-        m_assertionInfo.resultDisposition = resultDisposition;
-        stream().oss << Catch::translateActiveException();
-        captureResult( ResultWas::ThrewException );
-    }
-
-    void ResultBuilder::captureResult( ResultWas::OfType resultType ) {
-        setResultType( resultType );
-        captureExpression();
-    }
-
-    void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
-        if( expectedMessage.empty() )
-            captureExpectedException( Matchers::Impl::MatchAllOf<std::string>() );
-        else
-            captureExpectedException( Matchers::Equals( expectedMessage ) );
-    }
-
-    void ResultBuilder::captureExpectedException( Matchers::Impl::MatcherBase<std::string> const& matcher ) {
-
-        assert( !isFalseTest( m_assertionInfo.resultDisposition ) );
-        AssertionResultData data = m_data;
-        data.resultType = ResultWas::Ok;
-        data.reconstructedExpression = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
-
-        std::string actualMessage = Catch::translateActiveException();
-        if( !matcher.match( actualMessage ) ) {
-            data.resultType = ResultWas::ExpressionFailed;
-            data.reconstructedExpression = actualMessage;
-        }
-        AssertionResult result( m_assertionInfo, data );
-        handleResult( result );
-    }
-
-    void ResultBuilder::captureExpression() {
-        AssertionResult result = build();
-        handleResult( result );
-    }
-
-    void ResultBuilder::handleResult( AssertionResult const& result )
+     AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+                                     std::vector<MessageInfo> const& _infoMessages,
+                                     Totals const& _totals )
+    :   assertionResult( _assertionResult ),
+        infoMessages( _infoMessages ),
+        totals( _totals )
     {
-        getResultCapture().assertionEnded( result );
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = _assertionResult.m_resultData.lazyExpression.m_transientExpression;
 
-        if( !result.isOk() ) {
-            if( getCurrentContext().getConfig()->shouldDebugBreak() )
-                m_shouldDebugBreak = true;
-            if( getCurrentContext().getRunner()->aborting() || (m_assertionInfo.resultDisposition & ResultDisposition::Normal) )
-                m_shouldThrow = true;
+        if( assertionResult.hasMessage() ) {
+            // Copy message into messages list.
+            // !TBD This should have been done earlier, somewhere
+            MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+            builder << assertionResult.getMessage();
+            builder.m_info.message = builder.m_stream.str();
+
+            infoMessages.push_back( builder.m_info );
         }
     }
 
-    void ResultBuilder::react() {
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-        if (m_shouldDebugBreak) {
-            ///////////////////////////////////////////////////////////////////
-            // To inspect the state during test, you need to go one level up the callstack
-            // To go back to the test and change execution, jump over the throw statement
-            ///////////////////////////////////////////////////////////////////
-            CATCH_BREAK_INTO_DEBUGGER();
-        }
-#endif
-        if( m_shouldThrow )
-            throw Catch::TestFailureException();
-    }
+     AssertionStats::~AssertionStats() = default;
 
-    bool ResultBuilder::shouldDebugBreak() const { return m_shouldDebugBreak; }
-    bool ResultBuilder::allowThrows() const { return getCurrentContext().getConfig()->allowThrows(); }
+    SectionStats::SectionStats(  SectionInfo const& _sectionInfo,
+                                 Counts const& _assertions,
+                                 double _durationInSeconds,
+                                 bool _missingAssertions )
+    :   sectionInfo( _sectionInfo ),
+        assertions( _assertions ),
+        durationInSeconds( _durationInSeconds ),
+        missingAssertions( _missingAssertions )
+    {}
 
-    AssertionResult ResultBuilder::build() const
-    {
-        return build( *this );
-    }
+    SectionStats::~SectionStats() = default;
 
-    // CAVEAT: The returned AssertionResult stores a pointer to the argument expr,
-    //         a temporary DecomposedExpression, which in turn holds references to
-    //         operands, possibly temporary as well.
-    //         It should immediately be passed to handleResult; if the expression
-    //         needs to be reported, its string expansion must be composed before
-    //         the temporaries are destroyed.
-    AssertionResult ResultBuilder::build( DecomposedExpression const& expr ) const
-    {
-        assert( m_data.resultType != ResultWas::Unknown );
-        AssertionResultData data = m_data;
+    TestCaseStats::TestCaseStats(  TestCaseInfo const& _testInfo,
+                                   Totals const& _totals,
+                                   std::string const& _stdOut,
+                                   std::string const& _stdErr,
+                                   bool _aborting )
+    : testInfo( _testInfo ),
+        totals( _totals ),
+        stdOut( _stdOut ),
+        stdErr( _stdErr ),
+        aborting( _aborting )
+    {}
 
-        if(m_usedStream)
-            data.message = m_stream().oss.str();
-        data.decomposedExpression = &expr; // for lazy reconstruction
-        return AssertionResult( m_assertionInfo, data );
-    }
+    TestCaseStats::~TestCaseStats() = default;
 
-    void ResultBuilder::reconstructExpression( std::string& dest ) const {
-        dest = capturedExpressionWithSecondArgument(m_assertionInfo.capturedExpression, m_assertionInfo.secondArg);
-    }
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo,
+                                    Totals const& _totals,
+                                    bool _aborting )
+    :   groupInfo( _groupInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
 
-    void ResultBuilder::setExceptionGuard() {
-        m_guardException = true;
-    }
-    void ResultBuilder::unsetExceptionGuard() {
-        m_guardException = false;
-    }
+    TestGroupStats::TestGroupStats( GroupInfo const& _groupInfo )
+    :   groupInfo( _groupInfo ),
+        aborting( false )
+    {}
+
+    TestGroupStats::~TestGroupStats() = default;
+
+    TestRunStats::TestRunStats(   TestRunInfo const& _runInfo,
+                    Totals const& _totals,
+                    bool _aborting )
+    :   runInfo( _runInfo ),
+        totals( _totals ),
+        aborting( _aborting )
+    {}
+
+    TestRunStats::~TestRunStats() = default;
+
+    void IStreamingReporter::fatalErrorEncountered( StringRef ) {}
+    bool IStreamingReporter::isMulti() const { return false; }
+
+    IReporterFactory::~IReporterFactory() = default;
+    IReporterRegistry::~IReporterRegistry() = default;
 
 } // end namespace Catch
+// end catch_interfaces_reporter.cpp
+// start catch_interfaces_runner.cpp
 
-// #included from: catch_tag_alias_registry.hpp
-#define TWOBLUECUBES_CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+namespace Catch {
+    IRunner::~IRunner() = default;
+}
+// end catch_interfaces_runner.cpp
+// start catch_interfaces_testcase.cpp
+
+namespace Catch {
+    ITestInvoker::~ITestInvoker() = default;
+    ITestCaseRegistry::~ITestCaseRegistry() = default;
+}
+// end catch_interfaces_testcase.cpp
+// start catch_leak_detector.cpp
+
+#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+#include <crtdbg.h>
 
 namespace Catch {
 
-    TagAliasRegistry::~TagAliasRegistry() {}
-
-    Option<TagAlias> TagAliasRegistry::find( std::string const& alias ) const {
-        std::map<std::string, TagAlias>::const_iterator it = m_registry.find( alias );
-        if( it != m_registry.end() )
-            return it->second;
-        else
-            return Option<TagAlias>();
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
     }
+}
 
-    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
-        std::string expandedTestSpec = unexpandedTestSpec;
-        for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
-                it != itEnd;
-                ++it ) {
-            std::size_t pos = expandedTestSpec.find( it->first );
-            if( pos != std::string::npos ) {
-                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
-                                    it->second.tag +
-                                    expandedTestSpec.substr( pos + it->first.size() );
-            }
-        }
-        return expandedTestSpec;
-    }
+#else
 
-    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+    Catch::LeakDetector::LeakDetector() {}
 
-        if( !startsWith( alias, "[@" ) || !endsWith( alias, ']' ) ) {
-            std::ostringstream oss;
-            oss << Colour( Colour::Red )
-                << "error: tag alias, \"" << alias << "\" is not of the form [@alias name].\n"
-                << Colour( Colour::FileName )
-                << lineInfo << '\n';
-            throw std::domain_error( oss.str().c_str() );
-        }
-        if( !m_registry.insert( std::make_pair( alias, TagAlias( tag, lineInfo ) ) ).second ) {
-            std::ostringstream oss;
-            oss << Colour( Colour::Red )
-                << "error: tag alias, \"" << alias << "\" already registered.\n"
-                << "\tFirst seen at "
-                << Colour( Colour::Red ) << find(alias)->lineInfo << '\n'
-                << Colour( Colour::Red ) << "\tRedefined at "
-                << Colour( Colour::FileName) << lineInfo << '\n';
-            throw std::domain_error( oss.str().c_str() );
-        }
-    }
+#endif
 
-    ITagAliasRegistry::~ITagAliasRegistry() {}
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
+// end catch_leak_detector.cpp
+// start catch_list.cpp
 
-    ITagAliasRegistry const& ITagAliasRegistry::get() {
-        return getRegistryHub().getTagAliasRegistry();
-    }
+// start catch_list.h
 
-    RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
-        getMutableRegistryHub().registerTagAlias( alias, tag, lineInfo );
-    }
+#include <set>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config );
+
+    std::size_t listTestsNamesOnly( Config const& config );
+
+    struct TagInfo {
+        void add( std::string const& spelling );
+        std::string all() const;
+
+        std::set<std::string> spellings;
+        std::size_t count = 0;
+    };
+
+    std::size_t listTags( Config const& config );
+
+    std::size_t listReporters();
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
 
 } // end namespace Catch
 
-// #included from: catch_matchers_string.hpp
+// end catch_list.h
+// start catch_text.h
+
+namespace Catch {
+    using namespace clara::TextFlow;
+}
+
+// end catch_text.h
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+namespace Catch {
+
+    std::size_t listTests( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Matching test cases:\n";
+        else {
+            Catch::cout() << "All available test cases:\n";
+        }
+
+        auto matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            Colour::Code colour = testCaseInfo.isHidden()
+                ? Colour::SecondaryText
+                : Colour::None;
+            Colour colourGuard( colour );
+
+            Catch::cout() << Column( testCaseInfo.name ).initialIndent( 2 ).indent( 4 ) << "\n";
+            if( config.verbosity() >= Verbosity::High ) {
+                Catch::cout() << Column( Catch::Detail::stringify( testCaseInfo.lineInfo ) ).indent(4) << std::endl;
+                std::string description = testCaseInfo.description;
+                if( description.empty() )
+                    description = "(NO DESCRIPTION)";
+                Catch::cout() << Column( description ).indent(4) << std::endl;
+            }
+            if( !testCaseInfo.tags.empty() )
+                Catch::cout() << Column( testCaseInfo.tagsAsString() ).indent( 6 ) << "\n";
+        }
+
+        if( !config.hasTestFilters() )
+            Catch::cout() << pluralise( matchedTestCases.size(), "test case" ) << '\n' << std::endl;
+        else
+            Catch::cout() << pluralise( matchedTestCases.size(), "matching test case" ) << '\n' << std::endl;
+        return matchedTestCases.size();
+    }
+
+    std::size_t listTestsNamesOnly( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        std::size_t matchedTests = 0;
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCaseInfo : matchedTestCases ) {
+            matchedTests++;
+            if( startsWith( testCaseInfo.name, '#' ) )
+               Catch::cout() << '"' << testCaseInfo.name << '"';
+            else
+               Catch::cout() << testCaseInfo.name;
+            if ( config.verbosity() >= Verbosity::High )
+                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
+            Catch::cout() << std::endl;
+        }
+        return matchedTests;
+    }
+
+    void TagInfo::add( std::string const& spelling ) {
+        ++count;
+        spellings.insert( spelling );
+    }
+
+    std::string TagInfo::all() const {
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
+        return out;
+    }
+
+    std::size_t listTags( Config const& config ) {
+        TestSpec const& testSpec = config.testSpec();
+        if( config.hasTestFilters() )
+            Catch::cout() << "Tags for matching test cases:\n";
+        else {
+            Catch::cout() << "All available tags:\n";
+        }
+
+        std::map<std::string, TagInfo> tagCounts;
+
+        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
+        for( auto const& testCase : matchedTestCases ) {
+            for( auto const& tagName : testCase.getTestCaseInfo().tags ) {
+                std::string lcaseTagName = toLower( tagName );
+                auto countIt = tagCounts.find( lcaseTagName );
+                if( countIt == tagCounts.end() )
+                    countIt = tagCounts.insert( std::make_pair( lcaseTagName, TagInfo() ) ).first;
+                countIt->second.add( tagName );
+            }
+        }
+
+        for( auto const& tagCount : tagCounts ) {
+            ReusableStringStream rss;
+            rss << "  " << std::setw(2) << tagCount.second.count << "  ";
+            auto str = rss.str();
+            auto wrapper = Column( tagCount.second.all() )
+                                                    .initialIndent( 0 )
+                                                    .indent( str.size() )
+                                                    .width( CATCH_CONFIG_CONSOLE_WIDTH-10 );
+            Catch::cout() << str << wrapper << '\n';
+        }
+        Catch::cout() << pluralise( tagCounts.size(), "tag" ) << '\n' << std::endl;
+        return tagCounts.size();
+    }
+
+    std::size_t listReporters() {
+        Catch::cout() << "Available reporters:\n";
+        IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+        std::size_t maxNameLen = 0;
+        for( auto const& factoryKvp : factories )
+            maxNameLen = (std::max)( maxNameLen, factoryKvp.first.size() );
+
+        for( auto const& factoryKvp : factories ) {
+            Catch::cout()
+                    << Column( factoryKvp.first + ":" )
+                            .indent(2)
+                            .width( 5+maxNameLen )
+                    +  Column( factoryKvp.second->getDescription() )
+                            .initialIndent(0)
+                            .indent(2)
+                            .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen-8 )
+                    << "\n";
+        }
+        Catch::cout() << std::endl;
+        return factories.size();
+    }
+
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
+        Option<std::size_t> listedCount;
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
+        return listedCount;
+    }
+
+} // end namespace Catch
+// end catch_list.cpp
+// start catch_matchers.cpp
+
+namespace Catch {
+namespace Matchers {
+    namespace Impl {
+
+        std::string MatcherUntypedBase::toString() const {
+            if( m_cachedToString.empty() )
+                m_cachedToString = describe();
+            return m_cachedToString;
+        }
+
+        MatcherUntypedBase::~MatcherUntypedBase() = default;
+
+    } // namespace Impl
+} // namespace Matchers
+
+using namespace Matchers;
+using Matchers::Impl::MatcherBase;
+
+} // namespace Catch
+// end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
+// start catch_matchers_floating.cpp
+
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
+// start catch_to_string.hpp
+
+#include <string>
+
+namespace Catch {
+    template <typename T>
+    std::string to_string(T const& t) {
+#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+        return std::to_string(t);
+#else
+        ReusableStringStream rss;
+        rss << t;
+        return rss.str();
+#endif
+    }
+} // end namespace Catch
+
+// end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
+#include <cstdlib>
+#include <cstdint>
+#include <cstring>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
+
+namespace Catch {
+namespace {
+
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
+        std::memcpy(&i, &f, sizeof(f));
+        return i;
+    }
+
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
+        std::memcpy(&i, &d, sizeof(d));
+        return i;
+    }
+
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
+
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        // static cast as a workaround for IBM XLC
+        auto ulpDiff = std::abs(static_cast<FP>(lc - rc));
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
+    }
+
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
+    }
+
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+}
+
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
+}
+
+} // end anonymous namespace
+
+namespace Matchers {
+namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
+    WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+        :m_target{ target }, m_margin{ margin } {
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
+    }
+
+    // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+    // But without the subtraction to allow for INFINITY in comparison
+    bool WithinAbsMatcher::match(double const& matchee) const {
+        return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+    }
+
+    std::string WithinAbsMatcher::describe() const {
+        return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+    }
+
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
+        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
+    bool WithinUlpsMatcher::match(double const& matchee) const {
+        switch (m_type) {
+        case FloatingPointKind::Float:
+            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+        case FloatingPointKind::Double:
+            return almostEqualUlps<double>(matchee, m_target, m_ulps);
+        default:
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
+        }
+    }
+
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+    std::string WithinUlpsMatcher::describe() const {
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
+    }
+
+}// namespace Floating
+
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
+}
+
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+    return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
+}
+
+Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
+    return Floating::WithinAbsMatcher(target, margin);
+}
+
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_floating.cpp
+// start catch_matchers_generic.cpp
+
+std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
+    if (desc.empty()) {
+        return "matches undescribed predicate";
+    } else {
+        return "matches predicate: \"" + desc + '"';
+    }
+}
+// end catch_matchers_generic.cpp
+// start catch_matchers_string.cpp
+
+#include <regex>
 
 namespace Catch {
 namespace Matchers {
@@ -9451,6 +11766,21 @@ namespace Matchers {
             return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
         }
 
+        RegexMatcher::RegexMatcher(std::string regex, CaseSensitive::Choice caseSensitivity): m_regex(std::move(regex)), m_caseSensitivity(caseSensitivity) {}
+
+        bool RegexMatcher::match(std::string const& matchee) const {
+            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+            if (m_caseSensitivity == CaseSensitive::Choice::No) {
+                flags |= std::regex::icase;
+            }
+            auto reg = std::regex(m_regex, flags);
+            return std::regex_match(matchee, reg);
+        }
+
+        std::string RegexMatcher::describe() const {
+            return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Choice::Yes)? " case sensitively" : " case insensitively");
+        }
+
     } // namespace StdString
 
     StdString::EqualsMatcher Equals( std::string const& str, CaseSensitive::Choice caseSensitivity ) {
@@ -9466,1664 +11796,4283 @@ namespace Matchers {
         return StdString::StartsWithMatcher( StdString::CasedString( str, caseSensitivity) );
     }
 
+    StdString::RegexMatcher Matches(std::string const& regex, CaseSensitive::Choice caseSensitivity) {
+        return StdString::RegexMatcher(regex, caseSensitivity);
+    }
+
 } // namespace Matchers
 } // namespace Catch
-// #included from: ../reporters/catch_reporter_multi.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_MULTI_HPP_INCLUDED
+// end catch_matchers_string.cpp
+// start catch_message.cpp
+
+// start catch_uncaught_exceptions.h
+
+namespace Catch {
+    bool uncaught_exceptions();
+} // end namespace Catch
+
+// end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
 
 namespace Catch {
 
-class MultipleReporters : public SharedImpl<IStreamingReporter> {
-    typedef std::vector<Ptr<IStreamingReporter> > Reporters;
-    Reporters m_reporters;
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
+                                SourceLineInfo const& _lineInfo,
+                                ResultWas::OfType _type )
+    :   macroName( _macroName ),
+        lineInfo( _lineInfo ),
+        type( _type ),
+        sequence( ++globalCount )
+    {}
 
-public:
-    void add( Ptr<IStreamingReporter> const& reporter ) {
-        m_reporters.push_back( reporter );
+    bool MessageInfo::operator==( MessageInfo const& other ) const {
+        return sequence == other.sequence;
     }
 
-public: // IStreamingReporter
-
-    virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-        return m_reporters[0]->getPreferences();
+    bool MessageInfo::operator<( MessageInfo const& other ) const {
+        return sequence < other.sequence;
     }
 
-    virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->noMatchingTestCases( spec );
+    // This may need protecting if threading support is added
+    unsigned int MessageInfo::globalCount = 0;
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
+                                           SourceLineInfo const& lineInfo,
+                                           ResultWas::OfType type )
+        :m_info(macroName, lineInfo, type) {}
+
+    ////////////////////////////////////////////////////////////////////////////
+
+    ScopedMessage::ScopedMessage( MessageBuilder const& builder )
+    : m_info( builder.m_info ), m_moved()
+    {
+        m_info.message = builder.m_stream.str();
+        getResultCapture().pushScopedMessage( m_info );
     }
 
-    virtual void testRunStarting( TestRunInfo const& testRunInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testRunStarting( testRunInfo );
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
     }
 
-    virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testGroupStarting( groupInfo );
-    }
-
-    virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testCaseStarting( testInfo );
-    }
-
-    virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->sectionStarting( sectionInfo );
-    }
-
-    virtual void assertionStarting( AssertionInfo const& assertionInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->assertionStarting( assertionInfo );
-    }
-
-    // The return value indicates if the messages buffer should be cleared:
-    virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-        bool clearBuffer = false;
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            clearBuffer |= (*it)->assertionEnded( assertionStats );
-        return clearBuffer;
-    }
-
-    virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->sectionEnded( sectionStats );
-    }
-
-    virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testCaseEnded( testCaseStats );
-    }
-
-    virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testGroupEnded( testGroupStats );
-    }
-
-    virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->testRunEnded( testRunStats );
-    }
-
-    virtual void skipTest( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-        for( Reporters::const_iterator it = m_reporters.begin(), itEnd = m_reporters.end();
-                it != itEnd;
-                ++it )
-            (*it)->skipTest( testInfo );
-    }
-
-    virtual MultipleReporters* tryAsMulti() CATCH_OVERRIDE {
-        return this;
-    }
-
-};
-
-Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
-    Ptr<IStreamingReporter> resultingReporter;
-
-    if( existingReporter ) {
-        MultipleReporters* multi = existingReporter->tryAsMulti();
-        if( !multi ) {
-            multi = new MultipleReporters;
-            resultingReporter = Ptr<IStreamingReporter>( multi );
-            if( existingReporter )
-                multi->add( existingReporter );
+    ScopedMessage::~ScopedMessage() {
+        if ( !uncaught_exceptions() && !m_moved ){
+            getResultCapture().popScopedMessage(m_info);
         }
-        else
-            resultingReporter = existingReporter;
-        multi->add( additionalReporter );
     }
-    else
-        resultingReporter = additionalReporter;
 
-    return resultingReporter;
-}
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
+} // end namespace Catch
+// end catch_message.cpp
+// start catch_output_redirect.cpp
+
+// start catch_output_redirect.h
+#ifndef TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+#define TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+
+#include <cstdio>
+#include <iosfwd>
+#include <string>
+
+namespace Catch {
+
+    class RedirectedStream {
+        std::ostream& m_originalStream;
+        std::ostream& m_redirectionStream;
+        std::streambuf* m_prevBuf;
+
+    public:
+        RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+        ~RedirectedStream();
+    };
+
+    class RedirectedStdOut {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cout;
+    public:
+        RedirectedStdOut();
+        auto str() const -> std::string;
+    };
+
+    // StdErr has two constituent streams in C++, std::cerr and std::clog
+    // This means that we need to redirect 2 streams into 1 to keep proper
+    // order of writes
+    class RedirectedStdErr {
+        ReusableStringStream m_rss;
+        RedirectedStream m_cerr;
+        RedirectedStream m_clog;
+    public:
+        RedirectedStdErr();
+        auto str() const -> std::string;
+    };
+
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+    // Windows's implementation of std::tmpfile is terrible (it tries
+    // to create a file inside system folder, thus requiring elevated
+    // privileges for the binary), so we have to use tmpnam(_s) and
+    // create the file ourselves there.
+    class TempFile {
+    public:
+        TempFile(TempFile const&) = delete;
+        TempFile& operator=(TempFile const&) = delete;
+        TempFile(TempFile&&) = delete;
+        TempFile& operator=(TempFile&&) = delete;
+
+        TempFile();
+        ~TempFile();
+
+        std::FILE* getFile();
+        std::string getContents();
+
+    private:
+        std::FILE* m_file = nullptr;
+    #if defined(_MSC_VER)
+        char m_buffer[L_tmpnam] = { 0 };
+    #endif
+    };
+
+    class OutputRedirect {
+    public:
+        OutputRedirect(OutputRedirect const&) = delete;
+        OutputRedirect& operator=(OutputRedirect const&) = delete;
+        OutputRedirect(OutputRedirect&&) = delete;
+        OutputRedirect& operator=(OutputRedirect&&) = delete;
+
+        OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+        ~OutputRedirect();
+
+    private:
+        int m_originalStdout = -1;
+        int m_originalStderr = -1;
+        TempFile m_stdoutFile;
+        TempFile m_stderrFile;
+        std::string& m_stdoutDest;
+        std::string& m_stderrDest;
+    };
+
+#endif
 
 } // end namespace Catch
 
-// #included from: ../reporters/catch_reporter_xml.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_XML_HPP_INCLUDED
-
-// #included from: catch_reporter_bases.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_BASES_HPP_INCLUDED
-
-#include <cstring>
-#include <cfloat>
+#endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
+// end catch_output_redirect.h
 #include <cstdio>
-#include <assert.h>
+#include <cstring>
+#include <fstream>
+#include <sstream>
+#include <stdexcept>
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
+#endif
+
+namespace Catch {
+
+    RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+    :   m_originalStream( originalStream ),
+        m_redirectionStream( redirectionStream ),
+        m_prevBuf( m_originalStream.rdbuf() )
+    {
+        m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+    }
+
+    RedirectedStream::~RedirectedStream() {
+        m_originalStream.rdbuf( m_prevBuf );
+    }
+
+    RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+    auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStdErr::RedirectedStdErr()
+    :   m_cerr( Catch::cerr(), m_rss.get() ),
+        m_clog( Catch::clog(), m_rss.get() )
+    {}
+    auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
+#if defined(_MSC_VER)
+    TempFile::TempFile() {
+        if (tmpnam_s(m_buffer)) {
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
+        }
+        if (fopen_s(&m_file, m_buffer, "w+")) {
+            char buffer[100];
+            if (strerror_s(buffer, errno)) {
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+            }
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+        }
+    }
+#else
+    TempFile::TempFile() {
+        m_file = std::tmpfile();
+        if (!m_file) {
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
+        }
+    }
+
+#endif
+
+    TempFile::~TempFile() {
+         // TBD: What to do about errors here?
+         std::fclose(m_file);
+         // We manually create the file on Windows only, on Linux
+         // it will be autodeleted
+#if defined(_MSC_VER)
+         std::remove(m_buffer);
+#endif
+    }
+
+    FILE* TempFile::getFile() {
+        return m_file;
+    }
+
+    std::string TempFile::getContents() {
+        std::stringstream sstr;
+        char buffer[100] = {};
+        std::rewind(m_file);
+        while (std::fgets(buffer, sizeof(buffer), m_file)) {
+            sstr << buffer;
+        }
+        return sstr.str();
+    }
+
+    OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+        m_originalStdout(dup(1)),
+        m_originalStderr(dup(2)),
+        m_stdoutDest(stdout_dest),
+        m_stderrDest(stderr_dest) {
+        dup2(fileno(m_stdoutFile.getFile()), 1);
+        dup2(fileno(m_stderrFile.getFile()), 2);
+    }
+
+    OutputRedirect::~OutputRedirect() {
+        Catch::cout() << std::flush;
+        fflush(stdout);
+        // Since we support overriding these streams, we flush cerr
+        // even though std::cerr is unbuffered
+        Catch::cerr() << std::flush;
+        Catch::clog() << std::flush;
+        fflush(stderr);
+
+        dup2(m_originalStdout, 1);
+        dup2(m_originalStderr, 2);
+
+        m_stdoutDest += m_stdoutFile.getContents();
+        m_stderrDest += m_stderrFile.getContents();
+    }
+
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
+} // namespace Catch
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
+#endif
+// end catch_output_redirect.cpp
+// start catch_polyfills.cpp
+
+#include <cmath>
+
+namespace Catch {
+
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
+
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
+
+namespace Catch {
+
+namespace {
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}
+
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
+
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
+    }
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
+    }
+
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
+    }
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
+    }
+
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
+}
+// end catch_random_number_generator.cpp
+// start catch_registry_hub.cpp
+
+// start catch_test_case_registry_impl.h
+
+#include <vector>
+#include <set>
+#include <algorithm>
+#include <ios>
+
+namespace Catch {
+
+    class TestCase;
+    struct IConfig;
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
+
+    class TestRegistry : public ITestCaseRegistry {
+    public:
+        virtual ~TestRegistry() = default;
+
+        virtual void registerTest( TestCase const& testCase );
+
+        std::vector<TestCase> const& getAllTests() const override;
+        std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const override;
+
+    private:
+        std::vector<TestCase> m_functions;
+        mutable RunTests::InWhatOrder m_currentSortOrder = RunTests::InDeclarationOrder;
+        mutable std::vector<TestCase> m_sortedFunctions;
+        std::size_t m_unnamedCount = 0;
+        std::ios_base::Init m_ostreamInit; // Forces cout/ cerr to be initialised
+    };
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    class TestInvokerAsFunction : public ITestInvoker {
+        void(*m_testAsFunction)();
+    public:
+        TestInvokerAsFunction( void(*testAsFunction)() ) noexcept;
+
+        void invoke() const override;
+    };
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName );
+
+    ///////////////////////////////////////////////////////////////////////////
+
+} // end namespace Catch
+
+// end catch_test_case_registry_impl.h
+// start catch_reporter_registry.h
+
+#include <map>
+
+namespace Catch {
+
+    class ReporterRegistry : public IReporterRegistry {
+
+    public:
+
+        ~ReporterRegistry() override;
+
+        IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const override;
+
+        void registerReporter( std::string const& name, IReporterFactoryPtr const& factory );
+        void registerListener( IReporterFactoryPtr const& factory );
+
+        FactoryMap const& getFactories() const override;
+        Listeners const& getListeners() const override;
+
+    private:
+        FactoryMap m_factories;
+        Listeners m_listeners;
+    };
+}
+
+// end catch_reporter_registry.h
+// start catch_tag_alias_registry.h
+
+// start catch_tag_alias.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias {
+        TagAlias(std::string const& _tag, SourceLineInfo _lineInfo);
+
+        std::string tag;
+        SourceLineInfo lineInfo;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias.h
+#include <map>
+
+namespace Catch {
+
+    class TagAliasRegistry : public ITagAliasRegistry {
+    public:
+        ~TagAliasRegistry() override;
+        TagAlias const* find( std::string const& alias ) const override;
+        std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+        void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+
+    private:
+        std::map<std::string, TagAlias> m_registry;
+    };
+
+} // end namespace Catch
+
+// end catch_tag_alias_registry.h
+// start catch_startup_exception_registry.h
+
+#include <vector>
+#include <exception>
+
+namespace Catch {
+
+    class StartupExceptionRegistry {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    public:
+        void add(std::exception_ptr const& exception) noexcept;
+        std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+    private:
+        std::vector<std::exception_ptr> m_exceptions;
+#endif
+    };
+
+} // end namespace Catch
+
+// end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
+namespace Catch {
+
+    namespace {
+
+        class RegistryHub : public IRegistryHub, public IMutableRegistryHub,
+                            private NonCopyable {
+
+        public: // IRegistryHub
+            RegistryHub() = default;
+            IReporterRegistry const& getReporterRegistry() const override {
+                return m_reporterRegistry;
+            }
+            ITestCaseRegistry const& getTestCaseRegistry() const override {
+                return m_testCaseRegistry;
+            }
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+                return m_exceptionTranslatorRegistry;
+            }
+            ITagAliasRegistry const& getTagAliasRegistry() const override {
+                return m_tagAliasRegistry;
+            }
+            StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+                return m_exceptionRegistry;
+            }
+
+        public: // IMutableRegistryHub
+            void registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerReporter( name, factory );
+            }
+            void registerListener( IReporterFactoryPtr const& factory ) override {
+                m_reporterRegistry.registerListener( factory );
+            }
+            void registerTest( TestCase const& testInfo ) override {
+                m_testCaseRegistry.registerTest( testInfo );
+            }
+            void registerTranslator( const IExceptionTranslator* translator ) override {
+                m_exceptionTranslatorRegistry.registerTranslator( translator );
+            }
+            void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+                m_tagAliasRegistry.add( alias, tag, lineInfo );
+            }
+            void registerStartupException() noexcept override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                m_exceptionRegistry.add(std::current_exception());
+#else
+                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+#endif
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
+            }
+
+        private:
+            TestRegistry m_testCaseRegistry;
+            ReporterRegistry m_reporterRegistry;
+            ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+            TagAliasRegistry m_tagAliasRegistry;
+            StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
+        };
+    }
+
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
+    }
+    IMutableRegistryHub& getMutableRegistryHub() {
+        return RegistryHubSingleton::getMutable();
+    }
+    void cleanUp() {
+        cleanupSingletons();
+        cleanUpContext();
+    }
+    std::string translateActiveException() {
+        return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+    }
+
+} // end namespace Catch
+// end catch_registry_hub.cpp
+// start catch_reporter_registry.cpp
+
+namespace Catch {
+
+    ReporterRegistry::~ReporterRegistry() = default;
+
+    IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
+        auto it =  m_factories.find( name );
+        if( it == m_factories.end() )
+            return nullptr;
+        return it->second->create( ReporterConfig( config ) );
+    }
+
+    void ReporterRegistry::registerReporter( std::string const& name, IReporterFactoryPtr const& factory ) {
+        m_factories.emplace(name, factory);
+    }
+    void ReporterRegistry::registerListener( IReporterFactoryPtr const& factory ) {
+        m_listeners.push_back( factory );
+    }
+
+    IReporterRegistry::FactoryMap const& ReporterRegistry::getFactories() const {
+        return m_factories;
+    }
+    IReporterRegistry::Listeners const& ReporterRegistry::getListeners() const {
+        return m_listeners;
+    }
+
+}
+// end catch_reporter_registry.cpp
+// start catch_result_type.cpp
+
+namespace Catch {
+
+    bool isOk( ResultWas::OfType resultType ) {
+        return ( resultType & ResultWas::FailureBit ) == 0;
+    }
+    bool isJustInfo( int flags ) {
+        return flags == ResultWas::Info;
+    }
+
+    ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+        return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+    }
+
+    bool shouldContinueOnFailure( int flags )    { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+    bool shouldSuppressFailure( int flags )      { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+
+} // end namespace Catch
+// end catch_result_type.cpp
+// start catch_run_context.cpp
+
+#include <cassert>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                // Under specific circumstances, the generator we want
+                // to acquire is also the current tracker. If this is
+                // the case, we have to avoid looking through current
+                // tracker's children, and instead return the current
+                // tracker.
+                // A case where this check is important is e.g.
+                //     for (int i = 0; i < 5; ++i) {
+                //         int n = GENERATE(1, 2);
+                //     }
+                //
+                // without it, the code above creates 5 nested generators.
+                if (currentTracker.nameAndLocation() == nameAndLocation) {
+                    auto thisTracker = currentTracker.parent().findChild(nameAndLocation);
+                    assert(thisTracker);
+                    assert(thisTracker->isGeneratorTracker());
+                    tracker = std::static_pointer_cast<GeneratorTracker>(thisTracker);
+                } else if ( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                } else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // If a generator has a child (it is followed by a section)
+                // and none of its children have started, then we must wait
+                // until later to start consuming its values.
+                // This catches cases where `GENERATE` is placed between two
+                // `SECTION`s.
+                // **The check for m_children.empty cannot be removed**.
+                // doing so would break `GENERATE` _not_ followed by `SECTION`s.
+                const bool should_wait_for_child = [&]() {
+                    // No children -> nobody to wait for
+                    if ( m_children.empty() ) {
+                        return false;
+                    }
+                    // If at least one child started executing, don't wait
+                    if ( std::find_if(
+                             m_children.begin(),
+                             m_children.end(),
+                             []( TestCaseTracking::ITrackerPtr tracker ) {
+                                 return tracker->hasStarted();
+                             } ) != m_children.end() ) {
+                        return false;
+                    }
+
+                    // No children have started. We need to check if they _can_
+                    // start, and thus we should wait for them, or they cannot
+                    // start (due to filters), and we shouldn't wait for them
+                    auto* parent = m_parent;
+                    // This is safe: there is always at least one section
+                    // tracker in a test case tracking tree
+                    while ( !parent->isSectionTracker() ) {
+                        parent = &( parent->parent() );
+                    }
+                    assert( parent &&
+                            "Missing root (test case) level section" );
+
+                    auto const& parentSection =
+                        static_cast<SectionTracker&>( *parent );
+                    auto const& filters = parentSection.getFilters();
+                    // No filters -> no restrictions on running sections
+                    if ( filters.empty() ) {
+                        return true;
+                    }
+
+                    for ( auto const& child : m_children ) {
+                        if ( child->isSectionTracker() &&
+                             std::find( filters.begin(),
+                                        filters.end(),
+                                        static_cast<SectionTracker&>( *child )
+                                            .trimmedName() ) !=
+                                 filters.end() ) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }();
+
+                // This check is a bit tricky, because m_generator->next()
+                // has a side-effect, where it consumes generator's current
+                // value, but we do not want to invoke the side-effect if
+                // this generator is still waiting for any child to start.
+                if ( should_wait_for_child ||
+                     ( m_runState == CompletedSuccessfully &&
+                       m_generator->next() ) ) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
+    RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
+    :   m_runInfo(_config->name()),
+        m_context(getCurrentMutableContext()),
+        m_config(_config),
+        m_reporter(std::move(reporter)),
+        m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+    {
+        m_context.setRunner(this);
+        m_context.setConfig(m_config);
+        m_context.setResultCapture(this);
+        m_reporter->testRunStarting(m_runInfo);
+    }
+
+    RunContext::~RunContext() {
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+    }
+
+    void RunContext::testGroupStarting(std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupStarting(GroupInfo(testSpec, groupIndex, groupsCount));
+    }
+
+    void RunContext::testGroupEnded(std::string const& testSpec, Totals const& totals, std::size_t groupIndex, std::size_t groupsCount) {
+        m_reporter->testGroupEnded(TestGroupStats(GroupInfo(testSpec, groupIndex, groupsCount), totals, aborting()));
+    }
+
+    Totals RunContext::runTest(TestCase const& testCase) {
+        Totals prevTotals = m_totals;
+
+        std::string redirectedCout;
+        std::string redirectedCerr;
+
+        auto const& testInfo = testCase.getTestCaseInfo();
+
+        m_reporter->testCaseStarting(testInfo);
+
+        m_activeTestCase = &testCase;
+
+        ITracker& rootTracker = m_trackerContext.startRun();
+        assert(rootTracker.isSectionTracker());
+        static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+        do {
+            m_trackerContext.startCycle();
+            m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(testInfo.name, testInfo.lineInfo));
+            runCurrentTest(redirectedCout, redirectedCerr);
+        } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+
+        Totals deltaTotals = m_totals.delta(prevTotals);
+        if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+            deltaTotals.assertions.failed++;
+            deltaTotals.testCases.passed--;
+            deltaTotals.testCases.failed++;
+        }
+        m_totals.testCases += deltaTotals.testCases;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  redirectedCout,
+                                  redirectedCerr,
+                                  aborting()));
+
+        m_activeTestCase = nullptr;
+        m_testCaseTracker = nullptr;
+
+        return deltaTotals;
+    }
+
+    IConfigPtr RunContext::config() const {
+        return m_config;
+    }
+
+    IStreamingReporter& RunContext::reporter() const {
+        return *m_reporter;
+    }
+
+    void RunContext::assertionEnded(AssertionResult const & result) {
+        if (result.getResultType() == ResultWas::Ok) {
+            m_totals.assertions.passed++;
+            m_lastAssertionPassed = true;
+        } else if (!result.isOk()) {
+            m_lastAssertionPassed = false;
+            if( m_activeTestCase->getTestCaseInfo().okToFail() )
+                m_totals.assertions.failedButOk++;
+            else
+                m_totals.assertions.failed++;
+        }
+        else {
+            m_lastAssertionPassed = true;
+        }
+
+        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
+        // and should be let to clear themselves out.
+        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
+
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
+        // Reset working state
+        resetAssertionInfo();
+        m_lastResult = result;
+    }
+    void RunContext::resetAssertionInfo() {
+        m_lastAssertionInfo.macroName = StringRef();
+        m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+    }
+
+    bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
+        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
+        if (!sectionTracker.isOpen())
+            return false;
+        m_activeSections.push_back(&sectionTracker);
+
+        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+
+        m_reporter->sectionStarting(sectionInfo);
+
+        assertions = m_totals.assertions;
+
+        return true;
+    }
+    auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
+                                                              TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
+
+    bool RunContext::testForMissingAssertions(Counts& assertions) {
+        if (assertions.total() != 0)
+            return false;
+        if (!m_config->warnAboutMissingAssertions())
+            return false;
+        if (m_trackerContext.currentTracker().hasChildren())
+            return false;
+        m_totals.assertions.failed++;
+        assertions.failed++;
+        return true;
+    }
+
+    void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
+        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        if (!m_activeSections.empty()) {
+            m_activeSections.back()->close();
+            m_activeSections.pop_back();
+        }
+
+        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
+        m_messages.clear();
+        m_messageScopes.clear();
+    }
+
+    void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
+        if (m_unfinishedSections.empty())
+            m_activeSections.back()->fail();
+        else
+            m_activeSections.back()->close();
+        m_activeSections.pop_back();
+
+        m_unfinishedSections.push_back(endInfo);
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+        m_reporter->benchmarkPreparing(name);
+    }
+    void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+        m_reporter->benchmarkStarting( info );
+    }
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+        m_reporter->benchmarkEnded( stats );
+    }
+    void RunContext::benchmarkFailed(std::string const & error) {
+        m_reporter->benchmarkFailed(error);
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void RunContext::pushScopedMessage(MessageInfo const & message) {
+        m_messages.push_back(message);
+    }
+
+    void RunContext::popScopedMessage(MessageInfo const & message) {
+        m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+    }
+
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
+    std::string RunContext::getCurrentTestName() const {
+        return m_activeTestCase
+            ? m_activeTestCase->getTestCaseInfo().name
+            : std::string();
+    }
+
+    const AssertionResult * RunContext::getLastResult() const {
+        return &(*m_lastResult);
+    }
+
+    void RunContext::exceptionEarlyReported() {
+        m_shouldReportUnexpected = false;
+    }
+
+    void RunContext::handleFatalErrorCondition( StringRef message ) {
+        // First notify reporter that bad things happened
+        m_reporter->fatalErrorEncountered(message);
+
+        // Don't rebuild the result -- the stringification itself can cause more fatal errors
+        // Instead, fake a result data.
+        AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+        tempResult.message = static_cast<std::string>(message);
+        AssertionResult result(m_lastAssertionInfo, tempResult);
+
+        assertionEnded(result);
+
+        handleUnfinishedSections();
+
+        // Recreate section for test case (as we will lose the one that was in scope)
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+
+        Counts assertions;
+        assertions.failed = 1;
+        SectionStats testCaseSectionStats(testCaseSection, assertions, 0, false);
+        m_reporter->sectionEnded(testCaseSectionStats);
+
+        auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+
+        Totals deltaTotals;
+        deltaTotals.testCases.failed = 1;
+        deltaTotals.assertions.failed = 1;
+        m_reporter->testCaseEnded(TestCaseStats(testInfo,
+                                  deltaTotals,
+                                  std::string(),
+                                  std::string(),
+                                  false));
+        m_totals.testCases.failed++;
+        testGroupEnded(std::string(), m_totals, 1, 1);
+        m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+    }
+
+    bool RunContext::lastAssertionPassed() {
+         return m_lastAssertionPassed;
+    }
+
+    void RunContext::assertionPassed() {
+        m_lastAssertionPassed = true;
+        ++m_totals.assertions.passed;
+        resetAssertionInfo();
+        m_messageScopes.clear();
+    }
+
+    bool RunContext::aborting() const {
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+    }
+
+    void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+        auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+        m_reporter->sectionStarting(testCaseSection);
+        Counts prevAssertions = m_totals.assertions;
+        double duration = 0;
+        m_shouldReportUnexpected = true;
+        m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+
+        seedRng(*m_config);
+
+        Timer timer;
+        CATCH_TRY {
+            if (m_reporter->getPreferences().shouldRedirectStdOut) {
+#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+
+                timer.start();
+                invokeActiveTestCase();
+#else
+                OutputRedirect r(redirectedCout, redirectedCerr);
+                timer.start();
+                invokeActiveTestCase();
+#endif
+            } else {
+                timer.start();
+                invokeActiveTestCase();
+            }
+            duration = timer.getElapsedSeconds();
+        } CATCH_CATCH_ANON (TestFailureException&) {
+            // This just means the test was aborted due to failure
+        } CATCH_CATCH_ALL {
+            // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+            // are reported without translation at the point of origin.
+            if( m_shouldReportUnexpected ) {
+                AssertionReaction dummyReaction;
+                handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+            }
+        }
+        Counts assertions = m_totals.assertions - prevAssertions;
+        bool missingAssertions = testForMissingAssertions(assertions);
+
+        m_testCaseTracker->close();
+        handleUnfinishedSections();
+        m_messages.clear();
+        m_messageScopes.clear();
+
+        SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
+        m_reporter->sectionEnded(testCaseSectionStats);
+    }
+
+    void RunContext::invokeActiveTestCase() {
+        FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+        m_activeTestCase->invoke();
+    }
+
+    void RunContext::handleUnfinishedSections() {
+        // If sections ended prematurely due to an exception we stored their
+        // infos here so we can tear them down outside the unwind process.
+        for (auto it = m_unfinishedSections.rbegin(),
+             itEnd = m_unfinishedSections.rend();
+             it != itEnd;
+             ++it)
+            sectionEnded(*it);
+        m_unfinishedSections.clear();
+    }
+
+    void RunContext::handleExpr(
+        AssertionInfo const& info,
+        ITransientExpression const& expr,
+        AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        bool negated = isFalseTest( info.resultDisposition );
+        bool result = expr.getResult() != negated;
+
+        if( result ) {
+            if (!m_includeSuccessfulResults) {
+                assertionPassed();
+            }
+            else {
+                reportExpr(info, ResultWas::Ok, &expr, negated);
+            }
+        }
+        else {
+            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+            populateReaction( reaction );
+        }
+    }
+    void RunContext::reportExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            ITransientExpression const *expr,
+            bool negated ) {
+
+        m_lastAssertionInfo = info;
+        AssertionResultData data( resultType, LazyExpression( negated ) );
+
+        AssertionResult assertionResult{ info, data };
+        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+
+        assertionEnded( assertionResult );
+    }
+
+    void RunContext::handleMessage(
+            AssertionInfo const& info,
+            ResultWas::OfType resultType,
+            StringRef const& message,
+            AssertionReaction& reaction
+    ) {
+        m_reporter->assertionStarting( info );
+
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        data.message = static_cast<std::string>(message);
+        AssertionResult assertionResult{ m_lastAssertionInfo, data };
+        assertionEnded( assertionResult );
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+    void RunContext::handleUnexpectedExceptionNotThrown(
+            AssertionInfo const& info,
+            AssertionReaction& reaction
+    ) {
+        handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+    }
+
+    void RunContext::handleUnexpectedInflightException(
+            AssertionInfo const& info,
+            std::string const& message,
+            AssertionReaction& reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = message;
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+        populateReaction( reaction );
+    }
+
+    void RunContext::populateReaction( AssertionReaction& reaction ) {
+        reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+        reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+    }
+
+    void RunContext::handleIncomplete(
+            AssertionInfo const& info
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+    }
+    void RunContext::handleNonExpr(
+            AssertionInfo const &info,
+            ResultWas::OfType resultType,
+            AssertionReaction &reaction
+    ) {
+        m_lastAssertionInfo = info;
+
+        AssertionResultData data( resultType, LazyExpression( false ) );
+        AssertionResult assertionResult{ info, data };
+        assertionEnded( assertionResult );
+
+        if( !assertionResult.isOk() )
+            populateReaction( reaction );
+    }
+
+    IResultCapture& getResultCapture() {
+        if (auto* capture = getCurrentContext().getResultCapture())
+            return *capture;
+        else
+            CATCH_INTERNAL_ERROR("No result capture instance");
+    }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
+}
+// end catch_run_context.cpp
+// start catch_section.cpp
+
+namespace Catch {
+
+    Section::Section( SectionInfo const& info )
+    :   m_info( info ),
+        m_sectionIncluded( getResultCapture().sectionStarted( m_info, m_assertions ) )
+    {
+        m_timer.start();
+    }
+
+    Section::~Section() {
+        if( m_sectionIncluded ) {
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
+            if( uncaught_exceptions() )
+                getResultCapture().sectionEndedEarly( endInfo );
+            else
+                getResultCapture().sectionEnded( endInfo );
+        }
+    }
+
+    // This indicates whether the section should be executed or not
+    Section::operator bool() const {
+        return m_sectionIncluded;
+    }
+
+} // end namespace Catch
+// end catch_section.cpp
+// start catch_section_info.cpp
+
+namespace Catch {
+
+    SectionInfo::SectionInfo
+        (   SourceLineInfo const& _lineInfo,
+            std::string const& _name )
+    :   name( _name ),
+        lineInfo( _lineInfo )
+    {}
+
+} // end namespace Catch
+// end catch_section_info.cpp
+// start catch_session.cpp
+
+// start catch_session.h
+
+#include <memory>
+
+namespace Catch {
+
+    class Session : NonCopyable {
+    public:
+
+        Session();
+        ~Session() override;
+
+        void showHelp() const;
+        void libIdentify();
+
+        int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
+
+        void useConfigData( ConfigData const& configData );
+
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
+        int run();
+
+        clara::Parser const& cli() const;
+        void cli( clara::Parser const& newParser );
+        ConfigData& configData();
+        Config& config();
+    private:
+        int runInternal();
+
+        clara::Parser m_cli;
+        ConfigData m_configData;
+        std::shared_ptr<Config> m_config;
+        bool m_startupExceptions = false;
+    };
+
+} // end namespace Catch
+
+// end catch_session.h
+// start catch_version.h
+
+#include <iosfwd>
+
+namespace Catch {
+
+    // Versioning information
+    struct Version {
+        Version( Version const& ) = delete;
+        Version& operator=( Version const& ) = delete;
+        Version(    unsigned int _majorVersion,
+                    unsigned int _minorVersion,
+                    unsigned int _patchNumber,
+                    char const * const _branchName,
+                    unsigned int _buildNumber );
+
+        unsigned int const majorVersion;
+        unsigned int const minorVersion;
+        unsigned int const patchNumber;
+
+        // buildNumber is only used if branchName is not null
+        char const * const branchName;
+        unsigned int const buildNumber;
+
+        friend std::ostream& operator << ( std::ostream& os, Version const& version );
+    };
+
+    Version const& libraryVersion();
+}
+
+// end catch_version.h
+#include <cstdlib>
+#include <iomanip>
+#include <set>
+#include <iterator>
 
 namespace Catch {
 
     namespace {
-        // Because formatting using c++ streams is stateful, drop down to C is required
-        // Alternatively we could use stringstream, but its performance is... not good.
-        std::string getFormattedDuration( double duration ) {
-            // Max exponent + 1 is required to represent the whole part
-            // + 1 for decimal point
-            // + 3 for the 3 decimal places
-            // + 1 for null terminator
-            const size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
-            char buffer[maxDoubleSize];
+        const int MaxExitCode = 255;
 
-            // Save previous errno, to prevent sprintf from overwriting it
-            ErrnoGuard guard;
-#ifdef _MSC_VER
-            sprintf_s(buffer, "%.3f", duration);
-#else
-            sprintf(buffer, "%.3f", duration);
-#endif
-            return std::string(buffer);
-        }
-    }
+        IStreamingReporterPtr createReporter(std::string const& reporterName, IConfigPtr const& config) {
+            auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, config);
+            CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << "'");
 
-    struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
-
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
+            return reporter;
         }
 
-        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-            return m_reporterPrefs;
-        }
-
-        virtual ~StreamingReporterBase() CATCH_OVERRIDE;
-
-        virtual void noMatchingTestCases( std::string const& ) CATCH_OVERRIDE {}
-
-        virtual void testRunStarting( TestRunInfo const& _testRunInfo ) CATCH_OVERRIDE {
-            currentTestRunInfo = _testRunInfo;
-        }
-        virtual void testGroupStarting( GroupInfo const& _groupInfo ) CATCH_OVERRIDE {
-            currentGroupInfo = _groupInfo;
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& _testInfo ) CATCH_OVERRIDE {
-            currentTestCaseInfo = _testInfo;
-        }
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
-            m_sectionStack.push_back( _sectionInfo );
-        }
-
-        virtual void sectionEnded( SectionStats const& /* _sectionStats */ ) CATCH_OVERRIDE {
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& /* _testCaseStats */ ) CATCH_OVERRIDE {
-            currentTestCaseInfo.reset();
-        }
-        virtual void testGroupEnded( TestGroupStats const& /* _testGroupStats */ ) CATCH_OVERRIDE {
-            currentGroupInfo.reset();
-        }
-        virtual void testRunEnded( TestRunStats const& /* _testRunStats */ ) CATCH_OVERRIDE {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
-
-        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
-
-        Ptr<IConfig const> m_config;
-        std::ostream& stream;
-
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
-
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
-
-    struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
-        template<typename T, typename ChildNodeT>
-        struct Node : SharedImpl<> {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
-
-            typedef std::vector<Ptr<ChildNodeT> > ChildNodes;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode : SharedImpl<> {
-            explicit SectionNode( SectionStats const& _stats ) : stats( _stats ) {}
-            virtual ~SectionNode();
-
-            bool operator == ( SectionNode const& other ) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == ( Ptr<SectionNode> const& other ) const {
-                return operator==( *other );
+        IStreamingReporterPtr makeReporter(std::shared_ptr<Config> const& config) {
+            if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()) {
+                return createReporter(config->getReporterName(), config);
             }
 
-            SectionStats stats;
-            typedef std::vector<Ptr<SectionNode> > ChildSections;
-            typedef std::vector<AssertionStats> Assertions;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
-
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() ( Ptr<SectionNode> const& node ) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
+            auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+            for (auto const& listener : listeners) {
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
             }
-        private:
-            void operator=( BySectionInfo const& );
-            SectionInfo const& m_other;
-        };
-
-        typedef Node<TestCaseStats, SectionNode> TestCaseNode;
-        typedef Node<TestGroupStats, TestCaseNode> TestGroupNode;
-        typedef Node<TestRunStats, TestGroupNode> TestRunNode;
-
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-        }
-        ~CumulativeReporterBase();
-
-        virtual ReporterPreferences getPreferences() const CATCH_OVERRIDE {
-            return m_reporterPrefs;
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
         }
 
-        virtual void testRunStarting( TestRunInfo const& ) CATCH_OVERRIDE {}
-        virtual void testGroupStarting( GroupInfo const& ) CATCH_OVERRIDE {}
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
 
-        virtual void testCaseStarting( TestCaseInfo const& ) CATCH_OVERRIDE {}
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            Ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = new SectionNode( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                SectionNode::ChildSections::const_iterator it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = new SectionNode( incompleteStats );
-                    parentNode.childSections.push_back( node );
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
                 }
-                else
-                    node = *it;
             }
-            m_sectionStack.push_back( node );
-            m_deepestSection = node;
+
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
+
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
+                }
+
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
+            }
+
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
+
+        void applyFilenamesAsTags(Catch::IConfig const& config) {
+            auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
+            for (auto& testCase : tests) {
+                auto tags = testCase.tags;
+
+                std::string filename = testCase.lineInfo.file;
+                auto lastSlash = filename.find_last_of("\\/");
+                if (lastSlash != std::string::npos) {
+                    filename.erase(0, lastSlash);
+                    filename[0] = '#';
+                }
+
+                auto lastDot = filename.find_last_of('.');
+                if (lastDot != std::string::npos) {
+                    filename.erase(lastDot);
+                }
+
+                tags.push_back(std::move(filename));
+                setTags(testCase, tags);
+            }
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
+    } // anon namespace
 
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-            assert( !m_sectionStack.empty() );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back( assertionStats );
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression( sectionNode.assertions.back().assertionResult );
-            return true;
-        }
-        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
-            assert( !m_sectionStack.empty() );
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-            Ptr<TestCaseNode> node = new TestCaseNode( testCaseStats );
-            assert( m_sectionStack.size() == 0 );
-            node->children.push_back( m_rootSection );
-            m_testCases.push_back( node );
-            m_rootSection.reset();
-
-            assert( m_deepestSection );
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
-        }
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-            Ptr<TestGroupNode> node = new TestGroupNode( testGroupStats );
-            node->children.swap( m_testCases );
-            m_testGroups.push_back( node );
-        }
-        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
-            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
-            node->children.swap( m_testGroups );
-            m_testRuns.push_back( node );
-            testRunEndedCumulative();
-        }
-        virtual void testRunEndedCumulative() = 0;
-
-        virtual void skipTest( TestCaseInfo const& ) CATCH_OVERRIDE {}
-
-        virtual void prepareExpandedExpression( AssertionResult& result ) const {
-            if( result.isOk() )
-                result.discardDecomposedExpression();
-            else
-                result.expandDecomposedExpression();
+    Session::Session() {
+        static bool alreadyInstantiated = false;
+        if( alreadyInstantiated ) {
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
         }
 
-        Ptr<IConfig const> m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<Ptr<SectionNode> > > m_sections;
-        std::vector<Ptr<TestCaseNode> > m_testCases;
-        std::vector<Ptr<TestGroupNode> > m_testGroups;
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+        if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
 
-        std::vector<Ptr<TestRunNode> > m_testRuns;
-
-        Ptr<SectionNode> m_rootSection;
-        Ptr<SectionNode> m_deepestSection;
-        std::vector<Ptr<SectionNode> > m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-
-    };
-
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+            m_startupExceptions = true;
+            Colour colourGuard( Colour::Red );
+            Catch::cerr() << "Errors occurred during startup!" << '\n';
+            // iterate over all exceptions and notify user
+            for ( const auto& ex_ptr : exceptions ) {
+                try {
+                    std::rethrow_exception(ex_ptr);
+                } catch ( std::exception const& ex ) {
+                    Catch::cerr() << Column( ex.what() ).indent(2) << '\n';
+                }
+            }
         }
-        return line;
+#endif
+
+        alreadyInstantiated = true;
+        m_cli = makeCommandLineParser( m_configData );
+    }
+    Session::~Session() {
+        Catch::cleanUp();
     }
 
-    struct TestEventListenerBase : StreamingReporterBase {
-        TestEventListenerBase( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config )
-        {}
+    void Session::showHelp() const {
+        Catch::cout()
+                << "\nCatch v" << libraryVersion() << "\n"
+                << m_cli << std::endl
+                << "For more detailed usage please see the project docs\n" << std::endl;
+    }
+    void Session::libIdentify() {
+        Catch::cout()
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+                << std::left << std::setw(16) << "category: " << "testframework\n"
+                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
+                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
+    }
 
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {}
-        virtual bool assertionEnded( AssertionStats const& ) CATCH_OVERRIDE {
-            return false;
+    int Session::applyCommandLine( int argc, char const * const * argv ) {
+        if( m_startupExceptions )
+            return 1;
+
+        auto result = m_cli.parse( clara::Args( argc, argv ) );
+        if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+            Catch::cerr()
+                << Colour( Colour::Red )
+                << "\nError(s) in input:\n"
+                << Column( result.errorMessage() ).indent( 2 )
+                << "\n\n";
+            Catch::cerr() << "Run with -? for usage\n" << std::endl;
+            return MaxExitCode;
         }
-    };
+
+        if( m_configData.showHelp )
+            showHelp();
+        if( m_configData.libIdentify )
+            libIdentify();
+        m_config.reset();
+        return 0;
+    }
+
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+
+        char **utf8Argv = new char *[ argc ];
+
+        for ( int i = 0; i < argc; ++i ) {
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+
+            utf8Argv[ i ] = new char[ bufSize ];
+
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+        }
+
+        int returnCode = applyCommandLine( argc, utf8Argv );
+
+        for ( int i = 0; i < argc; ++i )
+            delete [] utf8Argv[ i ];
+
+        delete [] utf8Argv;
+
+        return returnCode;
+    }
+#endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
+    int Session::run() {
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        int exitCode = runInternal();
+        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
+            static_cast<void>(std::getchar());
+        }
+        return exitCode;
+    }
+
+    clara::Parser const& Session::cli() const {
+        return m_cli;
+    }
+    void Session::cli( clara::Parser const& newParser ) {
+        m_cli = newParser;
+    }
+    ConfigData& Session::configData() {
+        return m_configData;
+    }
+    Config& Session::config() {
+        if( !m_config )
+            m_config = std::make_shared<Config>( m_configData );
+        return *m_config;
+    }
+
+    int Session::runInternal() {
+        if( m_startupExceptions )
+            return 1;
+
+        if (m_configData.showHelp || m_configData.libIdentify) {
+            return 0;
+        }
+
+        CATCH_TRY {
+            config(); // Force config to be constructed
+
+            seedRng( *m_config );
+
+            if( m_configData.filenamesAsTags )
+                applyFilenamesAsTags( *m_config );
+
+            // Handle list request
+            if( Option<std::size_t> listed = list( m_config ) )
+                return static_cast<int>( *listed );
+
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
+            // Note that on unices only the lower 8 bits are usually used, clamping
+            // the return value to 255 prevents false negative when some multiple
+            // of 256 tests has failed
+            return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
+        }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        catch( std::exception& ex ) {
+            Catch::cerr() << ex.what() << std::endl;
+            return MaxExitCode;
+        }
+#endif
+    }
 
 } // end namespace Catch
+// end catch_session.cpp
+// start catch_singletons.cpp
 
-// #included from: ../internal/catch_reporter_registrars.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+#include <vector>
 
 namespace Catch {
 
-    template<typename T>
-    class LegacyReporterRegistrar {
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
 
-        class ReporterFactory : public IReporterFactory {
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new LegacyReporterAdapter( new T( config ) );
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
+// start catch_startup_exception_registry.cpp
+
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+namespace Catch {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
+            m_exceptions.push_back(exception);
+        } CATCH_CATCH_ALL {
+            // If we run out of memory during start-up there's really not a lot more we can do about it
+            std::terminate();
+        }
+    }
+
+    std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+        return m_exceptions;
+    }
+
+} // end namespace Catch
+#endif
+// end catch_startup_exception_registry.cpp
+// start catch_stream.cpp
+
+#include <cstdio>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    Catch::IStream::~IStream() = default;
+
+    namespace Detail { namespace {
+        template<typename WriterF, std::size_t bufferSize=256>
+        class StreamBufImpl : public std::streambuf {
+            char data[bufferSize];
+            WriterF m_writer;
+
+        public:
+            StreamBufImpl() {
+                setp( data, data + sizeof(data) );
             }
 
-            virtual std::string getDescription() const {
-                return T::getDescription();
+            ~StreamBufImpl() noexcept {
+                StreamBufImpl::sync();
+            }
+
+        private:
+            int overflow( int c ) override {
+                sync();
+
+                if( c != EOF ) {
+                    if( pbase() == epptr() )
+                        m_writer( std::string( 1, static_cast<char>( c ) ) );
+                    else
+                        sputc( static_cast<char>( c ) );
+                }
+                return 0;
+            }
+
+            int sync() override {
+                if( pbase() != pptr() ) {
+                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+                    setp( pbase(), epptr() );
+                }
+                return 0;
             }
         };
 
-    public:
+        ///////////////////////////////////////////////////////////////////////////
 
-        LegacyReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
+        struct OutputDebugWriter {
 
-    template<typename T>
-    class ReporterRegistrar {
-
-        class ReporterFactory : public SharedImpl<IReporterFactory> {
-
-            // *** Please Note ***:
-            // - If you end up here looking at a compiler error because it's trying to register
-            // your custom reporter class be aware that the native reporter interface has changed
-            // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
-            // an adapter. Just use REGISTER_LEGACY_REPORTER to take advantage of the adapter.
-            // However please consider updating to the new interface as the old one is now
-            // deprecated and will probably be removed quite soon!
-            // Please contact me via github if you have any questions at all about this.
-            // In fact, ideally, please contact me anyway to let me know you've hit this - as I have
-            // no idea who is actually using custom reporters at all (possibly no-one!).
-            // The new interface is designed to minimise exposure to interface changes in the future.
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new T( config );
-            }
-
-            virtual std::string getDescription() const {
-                return T::getDescription();
+            void operator()( std::string const&str ) {
+                writeToDebugConsole( str );
             }
         };
 
-    public:
+        ///////////////////////////////////////////////////////////////////////////
 
-        ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, new ReporterFactory() );
-        }
-    };
-
-    template<typename T>
-    class ListenerRegistrar {
-
-        class ListenerFactory : public SharedImpl<IReporterFactory> {
-
-            virtual IStreamingReporter* create( ReporterConfig const& config ) const {
-                return new T( config );
+        class FileStream : public IStream {
+            mutable std::ofstream m_ofs;
+        public:
+            FileStream( StringRef filename ) {
+                m_ofs.open( filename.c_str() );
+                CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << "'" );
             }
-            virtual std::string getDescription() const {
-                return std::string();
+            ~FileStream() override = default;
+        public: // IStream
+            std::ostream& stream() const override {
+                return m_ofs;
             }
         };
 
-    public:
+        ///////////////////////////////////////////////////////////////////////////
 
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( new ListenerFactory() );
+        class CoutStream : public IStream {
+            mutable std::ostream m_os;
+        public:
+            // Store the streambuf from cout up-front because
+            // cout may get redirected when running tests
+            CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+            ~CoutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+        ///////////////////////////////////////////////////////////////////////////
+
+        class DebugOutStream : public IStream {
+            std::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+            mutable std::ostream m_os;
+        public:
+            DebugOutStream()
+            :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
+                m_os( m_streamBuf.get() )
+            {}
+
+            ~DebugOutStream() override = default;
+
+        public: // IStream
+            std::ostream& stream() const override { return m_os; }
+        };
+
+    }} // namespace anon::detail
+
+    ///////////////////////////////////////////////////////////////////////////
+
+    auto makeStream( StringRef const &filename ) -> IStream const* {
+        if( filename.empty() )
+            return new Detail::CoutStream();
+        else if( filename[0] == '%' ) {
+            if( filename == "%debug" )
+                return new Detail::DebugOutStream();
+            else
+                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
+        }
+        else
+            return new Detail::FileStream( filename );
+    }
+
+    // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+    struct StringStreams {
+        std::vector<std::unique_ptr<std::ostringstream>> m_streams;
+        std::vector<std::size_t> m_unused;
+        std::ostringstream m_referenceStream; // Used for copy state/ flags from
+
+        auto add() -> std::size_t {
+            if( m_unused.empty() ) {
+                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
+                return m_streams.size()-1;
+            }
+            else {
+                auto index = m_unused.back();
+                m_unused.pop_back();
+                return index;
+            }
+        }
+
+        void release( std::size_t index ) {
+            m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+            m_unused.push_back(index);
         }
     };
+
+    ReusableStringStream::ReusableStringStream()
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+    {}
+
+    ReusableStringStream::~ReusableStringStream() {
+        static_cast<std::ostringstream*>( m_oss )->str("");
+        m_oss->clear();
+        Singleton<StringStreams>::getMutable().release( m_index );
+    }
+
+    auto ReusableStringStream::str() const -> std::string {
+        return static_cast<std::ostringstream*>( m_oss )->str();
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+
+#ifndef CATCH_CONFIG_NOSTDOUT // If you #define this you must implement these functions
+    std::ostream& cout() { return std::cout; }
+    std::ostream& cerr() { return std::cerr; }
+    std::ostream& clog() { return std::clog; }
+#endif
 }
+// end catch_stream.cpp
+// start catch_string_manip.cpp
 
-#define INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) \
-    namespace{ Catch::LegacyReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cctype>
+#include <vector>
 
-#define INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType ) \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); }
+namespace Catch {
 
-// Deprecated - use the form without INTERNAL_
-#define INTERNAL_CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( static_cast<unsigned char>(c) ) );
+        }
+    }
 
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; }
+    bool startsWith( std::string const& s, std::string const& prefix ) {
+        return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+    }
+    bool startsWith( std::string const& s, char prefix ) {
+        return !s.empty() && s[0] == prefix;
+    }
+    bool endsWith( std::string const& s, std::string const& suffix ) {
+        return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+    }
+    bool endsWith( std::string const& s, char suffix ) {
+        return !s.empty() && s[s.size()-1] == suffix;
+    }
+    bool contains( std::string const& s, std::string const& infix ) {
+        return s.find( infix ) != std::string::npos;
+    }
+    void toLowerInPlace( std::string& s ) {
+        std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
+    }
+    std::string toLower( std::string const& s ) {
+        std::string lc = s;
+        toLowerInPlace( lc );
+        return lc;
+    }
+    std::string trim( std::string const& str ) {
+        static char const* whitespaceChars = "\n\r\t ";
+        std::string::size_type start = str.find_first_not_of( whitespaceChars );
+        std::string::size_type end = str.find_last_not_of( whitespaceChars );
 
-// #included from: ../internal/catch_xmlwriter.hpp
-#define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
+        return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+    }
+
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
+    bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+        bool replaced = false;
+        std::size_t i = str.find( replaceThis );
+        while( i != std::string::npos ) {
+            replaced = true;
+            str = str.substr( 0, i ) + withThis + str.substr( i+replaceThis.size() );
+            if( i < str.size()-withThis.size() )
+                i = str.find( replaceThis, i+withThis.size() );
+            else
+                i = std::string::npos;
+        }
+        return replaced;
+    }
+
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
+    pluralise::pluralise( std::size_t count, std::string const& label )
+    :   m_count( count ),
+        m_label( label )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+        os << pluraliser.m_count << ' ' << pluraliser.m_label;
+        if( pluraliser.m_count != 1 )
+            os << 's';
+        return os;
+    }
+
+}
+// end catch_string_manip.cpp
+// start catch_stringref.cpp
+
+#include <algorithm>
+#include <ostream>
+#include <cstring>
+#include <cstdint>
+
+namespace Catch {
+    StringRef::StringRef( char const* rawChars ) noexcept
+    : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
+    {}
+
+    auto StringRef::c_str() const -> char const* {
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
+        return m_start;
+    }
+    auto StringRef::data() const noexcept -> char const* {
+        return m_start;
+    }
+
+    auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
+            return StringRef();
+        }
+    }
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+    }
+
+    auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
+        return os.write(str.data(), str.size());
+    }
+
+    auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
+        lhs.append(rhs.data(), rhs.size());
+        return lhs;
+    }
+
+} // namespace Catch
+// end catch_stringref.cpp
+// start catch_tag_alias.cpp
+
+namespace Catch {
+    TagAlias::TagAlias(std::string const & _tag, SourceLineInfo _lineInfo): tag(_tag), lineInfo(_lineInfo) {}
+}
+// end catch_tag_alias.cpp
+// start catch_tag_alias_autoregistrar.cpp
+
+namespace Catch {
+
+    RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+        CATCH_TRY {
+            getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+}
+// end catch_tag_alias_autoregistrar.cpp
+// start catch_tag_alias_registry.cpp
 
 #include <sstream>
+
+namespace Catch {
+
+    TagAliasRegistry::~TagAliasRegistry() {}
+
+    TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+        auto it = m_registry.find( alias );
+        if( it != m_registry.end() )
+            return &(it->second);
+        else
+            return nullptr;
+    }
+
+    std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+        std::string expandedTestSpec = unexpandedTestSpec;
+        for( auto const& registryKvp : m_registry ) {
+            std::size_t pos = expandedTestSpec.find( registryKvp.first );
+            if( pos != std::string::npos ) {
+                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
+                                    registryKvp.second.tag +
+                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
+            }
+        }
+        return expandedTestSpec;
+    }
+
+    void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+        CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+                      "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+
+        CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+                      "error: tag alias, '" << alias << "' already registered.\n"
+                      << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+                      << "\tRedefined at: " << lineInfo );
+    }
+
+    ITagAliasRegistry::~ITagAliasRegistry() {}
+
+    ITagAliasRegistry const& ITagAliasRegistry::get() {
+        return getRegistryHub().getTagAliasRegistry();
+    }
+
+} // end namespace Catch
+// end catch_tag_alias_registry.cpp
+// start catch_test_case_info.cpp
+
+#include <cctype>
+#include <exception>
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
+    }
+
+    TestCase makeTestCase(  ITestInvoker* _testCase,
+                            std::string const& _className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& _lineInfo )
+    {
+        bool isHidden = false;
+
+        // Parse out tags
+        std::vector<std::string> tags;
+        std::string desc, tag;
+        bool inTag = false;
+        for (char c : nameAndTags.tags) {
+            if( !inTag ) {
+                if( c == '[' )
+                    inTag = true;
+                else
+                    desc += c;
+            }
+            else {
+                if( c == ']' ) {
+                    TestCaseInfo::SpecialProperties prop = parseSpecialTag( tag );
+                    if( ( prop & TestCaseInfo::IsHidden ) != 0 )
+                        isHidden = true;
+                    else if( prop == TestCaseInfo::None )
+                        enforceNotReservedTag( tag, _lineInfo );
+
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
+                    tags.push_back( tag );
+                    tag.clear();
+                    inTag = false;
+                }
+                else
+                    tag += c;
+            }
+        }
+        if( isHidden ) {
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
+        }
+
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
+        return TestCase( _testCase, std::move(info) );
+    }
+
+    void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
+        std::sort(begin(tags), end(tags));
+        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
+        testCaseInfo.lcaseTags.clear();
+
+        for( auto const& tag : tags ) {
+            std::string lcaseTag = toLower( tag );
+            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
+            testCaseInfo.lcaseTags.push_back( lcaseTag );
+        }
+        testCaseInfo.tags = std::move(tags);
+    }
+
+    TestCaseInfo::TestCaseInfo( std::string const& _name,
+                                std::string const& _className,
+                                std::string const& _description,
+                                std::vector<std::string> const& _tags,
+                                SourceLineInfo const& _lineInfo )
+    :   name( _name ),
+        className( _className ),
+        description( _description ),
+        lineInfo( _lineInfo ),
+        properties( None )
+    {
+        setTags( *this, _tags );
+    }
+
+    bool TestCaseInfo::isHidden() const {
+        return ( properties & IsHidden ) != 0;
+    }
+    bool TestCaseInfo::throws() const {
+        return ( properties & Throws ) != 0;
+    }
+    bool TestCaseInfo::okToFail() const {
+        return ( properties & (ShouldFail | MayFail ) ) != 0;
+    }
+    bool TestCaseInfo::expectedToFail() const {
+        return ( properties & (ShouldFail ) ) != 0;
+    }
+
+    std::string TestCaseInfo::tagsAsString() const {
+        std::string ret;
+        // '[' and ']' per tag
+        std::size_t full_size = 2 * tags.size();
+        for (const auto& tag : tags) {
+            full_size += tag.size();
+        }
+        ret.reserve(full_size);
+        for (const auto& tag : tags) {
+            ret.push_back('[');
+            ret.append(tag);
+            ret.push_back(']');
+        }
+
+        return ret;
+    }
+
+    TestCase::TestCase( ITestInvoker* testCase, TestCaseInfo&& info ) : TestCaseInfo( std::move(info) ), test( testCase ) {}
+
+    TestCase TestCase::withName( std::string const& _newName ) const {
+        TestCase other( *this );
+        other.name = _newName;
+        return other;
+    }
+
+    void TestCase::invoke() const {
+        test->invoke();
+    }
+
+    bool TestCase::operator == ( TestCase const& other ) const {
+        return  test.get() == other.test.get() &&
+                name == other.name &&
+                className == other.className;
+    }
+
+    bool TestCase::operator < ( TestCase const& other ) const {
+        return name < other.name;
+    }
+
+    TestCaseInfo const& TestCase::getTestCaseInfo() const
+    {
+        return *this;
+    }
+
+} // end namespace Catch
+// end catch_test_case_info.cpp
+// start catch_test_case_registry_impl.cpp
+
+#include <algorithm>
+#include <sstream>
+
+namespace Catch {
+
+    namespace {
+        struct TestHasher {
+            using hash_t = uint64_t;
+
+            explicit TestHasher( hash_t hashSuffix ):
+                m_hashSuffix{ hashSuffix } {}
+
+            uint32_t operator()( TestCase const& t ) const {
+                // FNV-1a hash with multiplication fold.
+                const hash_t prime = 1099511628211u;
+                hash_t hash = 14695981039346656037u;
+                for ( const char c : t.name ) {
+                    hash ^= c;
+                    hash *= prime;
+                }
+                hash ^= m_hashSuffix;
+                hash *= prime;
+                const uint32_t low{ static_cast<uint32_t>( hash ) };
+                const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+                return low * high;
+            }
+
+        private:
+            hash_t m_hashSuffix;
+        };
+    } // end unnamed namespace
+
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+        switch( config.runOrder() ) {
+            case RunTests::InDeclarationOrder:
+                // already in declaration order
+                break;
+
+            case RunTests::InLexicographicalOrder: {
+                std::vector<TestCase> sorted = unsortedTestCases;
+                std::sort( sorted.begin(), sorted.end() );
+                return sorted;
+            }
+
+            case RunTests::InRandomOrder: {
+                seedRng( config );
+                TestHasher h{ config.rngSeed() };
+
+                using hashedTest = std::pair<TestHasher::hash_t, TestCase const*>;
+                std::vector<hashedTest> indexed_tests;
+                indexed_tests.reserve( unsortedTestCases.size() );
+
+                for (auto const& testCase : unsortedTestCases) {
+                    indexed_tests.emplace_back(h(testCase), &testCase);
+                }
+
+                std::sort(indexed_tests.begin(), indexed_tests.end(),
+                          [](hashedTest const& lhs, hashedTest const& rhs) {
+                          if (lhs.first == rhs.first) {
+                              return lhs.second->name < rhs.second->name;
+                          }
+                          return lhs.first < rhs.first;
+                });
+
+                std::vector<TestCase> sorted;
+                sorted.reserve( indexed_tests.size() );
+
+                for (auto const& hashed : indexed_tests) {
+                    sorted.emplace_back(*hashed.second);
+                }
+
+                return sorted;
+            }
+        }
+        return unsortedTestCases;
+    }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
+    bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
+    }
+
+    void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
+        std::set<TestCase> seenFunctions;
+        for( auto const& function : functions ) {
+            auto prev = seenFunctions.insert( function );
+            CATCH_ENFORCE( prev.second,
+                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
+                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
+                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
+        }
+    }
+
+    std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+        std::vector<TestCase> filtered;
+        filtered.reserve( testCases.size() );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
+        return filtered;
+    }
+    std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
+        return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+    }
+
+    void TestRegistry::registerTest( TestCase const& testCase ) {
+        std::string name = testCase.getTestCaseInfo().name;
+        if( name.empty() ) {
+            ReusableStringStream rss;
+            rss << "Anonymous test case " << ++m_unnamedCount;
+            return registerTest( testCase.withName( rss.str() ) );
+        }
+        m_functions.push_back( testCase );
+    }
+
+    std::vector<TestCase> const& TestRegistry::getAllTests() const {
+        return m_functions;
+    }
+    std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+        if( m_sortedFunctions.empty() )
+            enforceNoDuplicateTestCases( m_functions );
+
+        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+            m_sortedFunctions = sortTests( config, m_functions );
+            m_currentSortOrder = config.runOrder();
+        }
+        return m_sortedFunctions;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    TestInvokerAsFunction::TestInvokerAsFunction( void(*testAsFunction)() ) noexcept : m_testAsFunction( testAsFunction ) {}
+
+    void TestInvokerAsFunction::invoke() const {
+        m_testAsFunction();
+    }
+
+    std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
+        std::string className(classOrQualifiedMethodName);
+        if( startsWith( className, '&' ) )
+        {
+            std::size_t lastColons = className.rfind( "::" );
+            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
+            if( penultimateColons == std::string::npos )
+                penultimateColons = 1;
+            className = className.substr( penultimateColons, lastColons-penultimateColons );
+        }
+        return className;
+    }
+
+} // end namespace Catch
+// end catch_test_case_registry_impl.cpp
+// start catch_test_case_tracker.cpp
+
+#include <algorithm>
+#include <cassert>
+#include <stdexcept>
+#include <memory>
+#include <sstream>
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#endif
+
+namespace Catch {
+namespace TestCaseTracking {
+
+    NameAndLocation::NameAndLocation( std::string const& _name, SourceLineInfo const& _location )
+    :   name( _name ),
+        location( _location )
+    {}
+
+    ITracker::~ITracker() = default;
+
+    ITracker& TrackerContext::startRun() {
+        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
+        m_currentTracker = nullptr;
+        m_runState = Executing;
+        return *m_rootTracker;
+    }
+
+    void TrackerContext::endRun() {
+        m_rootTracker.reset();
+        m_currentTracker = nullptr;
+        m_runState = NotStarted;
+    }
+
+    void TrackerContext::startCycle() {
+        m_currentTracker = m_rootTracker.get();
+        m_runState = Executing;
+    }
+    void TrackerContext::completeCycle() {
+        m_runState = CompletedCycle;
+    }
+
+    bool TrackerContext::completedCycle() const {
+        return m_runState == CompletedCycle;
+    }
+    ITracker& TrackerContext::currentTracker() {
+        return *m_currentTracker;
+    }
+    void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+        m_currentTracker = tracker;
+    }
+
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+        ITracker(nameAndLocation),
+        m_ctx( ctx ),
+        m_parent( parent )
+    {}
+
+    bool TrackerBase::isComplete() const {
+        return m_runState == CompletedSuccessfully || m_runState == Failed;
+    }
+    bool TrackerBase::isSuccessfullyCompleted() const {
+        return m_runState == CompletedSuccessfully;
+    }
+    bool TrackerBase::isOpen() const {
+        return m_runState != NotStarted && !isComplete();
+    }
+    bool TrackerBase::hasChildren() const {
+        return !m_children.empty();
+    }
+
+    void TrackerBase::addChild( ITrackerPtr const& child ) {
+        m_children.push_back( child );
+    }
+
+    ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
+        return( it != m_children.end() )
+            ? *it
+            : nullptr;
+    }
+    ITracker& TrackerBase::parent() {
+        assert( m_parent ); // Should always be non-null except for root
+        return *m_parent;
+    }
+
+    void TrackerBase::openChild() {
+        if( m_runState != ExecutingChildren ) {
+            m_runState = ExecutingChildren;
+            if( m_parent )
+                m_parent->openChild();
+        }
+    }
+
+    bool TrackerBase::isSectionTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
+
+    void TrackerBase::open() {
+        m_runState = Executing;
+        moveToThis();
+        if( m_parent )
+            m_parent->openChild();
+    }
+
+    void TrackerBase::close() {
+
+        // Close any still open children (e.g. generators)
+        while( &m_ctx.currentTracker() != this )
+            m_ctx.currentTracker().close();
+
+        switch( m_runState ) {
+            case NeedsAnotherRun:
+                break;
+
+            case Executing:
+                m_runState = CompletedSuccessfully;
+                break;
+            case ExecutingChildren:
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+                    m_runState = CompletedSuccessfully;
+                break;
+
+            case NotStarted:
+            case CompletedSuccessfully:
+            case Failed:
+                CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+        }
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::fail() {
+        m_runState = Failed;
+        if( m_parent )
+            m_parent->markAsNeedingAnotherRun();
+        moveToParent();
+        m_ctx.completeCycle();
+    }
+    void TrackerBase::markAsNeedingAnotherRun() {
+        m_runState = NeedsAnotherRun;
+    }
+
+    void TrackerBase::moveToParent() {
+        assert( m_parent );
+        m_ctx.setCurrentTracker( m_parent );
+    }
+    void TrackerBase::moveToThis() {
+        m_ctx.setCurrentTracker( this );
+    }
+
+    SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
+    {
+        if( parent ) {
+            while( !parent->isSectionTracker() )
+                parent = &parent->parent();
+
+            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+            addNextFilters( parentSection.m_filters );
+        }
+    }
+
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if (m_filters.empty()
+            || m_filters[0] == ""
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
+    bool SectionTracker::isSectionTracker() const { return true; }
+
+    SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
+        std::shared_ptr<SectionTracker> section;
+
+        ITracker& currentTracker = ctx.currentTracker();
+        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+            assert( childTracker );
+            assert( childTracker->isSectionTracker() );
+            section = std::static_pointer_cast<SectionTracker>( childTracker );
+        }
+        else {
+            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
+            currentTracker.addChild( section );
+        }
+        if( !ctx.completedCycle() )
+            section->tryOpen();
+        return *section;
+    }
+
+    void SectionTracker::tryOpen() {
+        if( !isComplete() )
+            open();
+    }
+
+    void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+        if( !filters.empty() ) {
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
+            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+        }
+    }
+    void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
+        if( filters.size() > 1 )
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+    }
+
+    std::vector<std::string> const& SectionTracker::getFilters() const {
+        return m_filters;
+    }
+
+    std::string const& SectionTracker::trimmedName() const {
+        return m_trimmed_name;
+    }
+
+} // namespace TestCaseTracking
+
+using TestCaseTracking::ITracker;
+using TestCaseTracking::TrackerContext;
+using TestCaseTracking::SectionTracker;
+
+} // namespace Catch
+
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
+// end catch_test_case_tracker.cpp
+// start catch_test_registry.cpp
+
+namespace Catch {
+
+    auto makeTestInvoker( void(*testAsFunction)() ) noexcept -> ITestInvoker* {
+        return new(std::nothrow) TestInvokerAsFunction( testAsFunction );
+    }
+
+    NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
+
+    AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+        CATCH_TRY {
+            getMutableRegistryHub()
+                    .registerTest(
+                        makeTestCase(
+                            invoker,
+                            extractClassName( classOrMethod ),
+                            nameAndTags,
+                            lineInfo));
+        } CATCH_CATCH_ALL {
+            // Do not throw when constructing global objects, instead register the exception to be processed later
+            getMutableRegistryHub().registerStartupException();
+        }
+    }
+
+    AutoReg::~AutoReg() = default;
+}
+// end catch_test_registry.cpp
+// start catch_test_spec.cpp
+
+#include <algorithm>
 #include <string>
 #include <vector>
+#include <memory>
+
+namespace Catch {
+
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
+    TestSpec::Pattern::~Pattern() = default;
+
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    {}
+
+    bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+        return m_wildcardPattern.matches( testCase.name );
+    }
+
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
+    bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+        return std::find(begin(testCase.lcaseTags),
+                         end(testCase.lcaseTags),
+                         m_tag) != end(testCase.lcaseTags);
+    }
+
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
+
+    bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
+    }
+
+    bool TestSpec::hasFilters() const {
+        return !m_filters.empty();
+    }
+
+    bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
+    }
+
+}
+// end catch_test_spec.cpp
+// start catch_test_spec_parser.cpp
+
+namespace Catch {
+
+    TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+
+    TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+        m_mode = None;
+        m_exclusion = false;
+        m_arg = m_tagAliases->expandAliases( arg );
+        m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
+        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
+        return *this;
+    }
+    TestSpec TestSpecParser::testSpec() {
+        addFilter();
+        return m_testSpec;
+    }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
+
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
+        }
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
+        }
+    }
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
+        m_mode = mode;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
+    }
+    void TestSpecParser::escape() {
+        saveLastMode();
+        m_mode = EscapedName;
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
+    }
+
+    void TestSpecParser::addFilter() {
+        if( !m_currentFilter.m_patterns.empty() ) {
+            m_testSpec.m_filters.push_back( m_currentFilter );
+            m_currentFilter = TestSpec::Filter();
+        }
+    }
+
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         m_realPatternPos = 0;
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+        m_realPatternPos = 0;
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    TestSpec parseTestSpec( std::string const& arg ) {
+        return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
+    }
+
+} // namespace Catch
+// end catch_test_spec_parser.cpp
+// start catch_timer.cpp
+
+#include <chrono>
+
+static const uint64_t nanosecondsInSecond = 1000000000;
+
+namespace Catch {
+
+    auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+        return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
+    }
+
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
+
+            auto startTime = getCurrentNanosecondsSinceEpoch();
+
+            for( std::size_t i = 0; i < iterations; ++i ) {
+
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
+
+                auto delta = ticks - baseTicks;
+                sum += delta;
+
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
+            }
+
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
+    }
+    auto getEstimatedClockResolution() -> uint64_t {
+        static auto s_resolution = estimateClockResolution();
+        return s_resolution;
+    }
+
+    void Timer::start() {
+       m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+    }
+    auto Timer::getElapsedNanoseconds() const -> uint64_t {
+        return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+    }
+    auto Timer::getElapsedMicroseconds() const -> uint64_t {
+        return getElapsedNanoseconds()/1000;
+    }
+    auto Timer::getElapsedMilliseconds() const -> unsigned int {
+        return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+    }
+    auto Timer::getElapsedSeconds() const -> double {
+        return getElapsedMicroseconds()/1000000.0;
+    }
+
+} // namespace Catch
+// end catch_timer.cpp
+// start catch_tostring.cpp
+
+#if defined(__clang__)
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wexit-time-destructors"
+#    pragma clang diagnostic ignored "-Wglobal-constructors"
+#endif
+
+// Enable specific decls locally
+#if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#endif
+
+#include <cmath>
 #include <iomanip>
 
 namespace Catch {
 
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
+namespace Detail {
 
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes )
-        :   m_str( str ),
-            m_forWhat( forWhat )
-        {}
-
-        void encodeTo( std::ostream& os ) const {
-
-            // Apostrophe escaping not necessary if we always use " to write attributes
-            // (see: http://www.w3.org/TR/xml/#syntax)
-
-            for( std::size_t i = 0; i < m_str.size(); ++ i ) {
-                char c = m_str[i];
-                switch( c ) {
-                    case '<':   os << "&lt;"; break;
-                    case '&':   os << "&amp;"; break;
-
-                    case '>':
-                        // See: http://www.w3.org/TR/xml/#syntax
-                        if( i > 2 && m_str[i-1] == ']' && m_str[i-2] == ']' )
-                            os << "&gt;";
-                        else
-                            os << c;
-                        break;
-
-                    case '\"':
-                        if( m_forWhat == ForAttributes )
-                            os << "&quot;";
-                        else
-                            os << c;
-                        break;
-
-                    default:
-                        // Escape control chars - based on contribution by @espenalb in PR #465 and
-                        // by @mrpi PR #588
-                        if ( ( c >= 0 && c < '\x09' ) || ( c > '\x0D' && c < '\x20') || c=='\x7F' ) {
-                            // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
-                            os << "\\x" << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
-                               << static_cast<int>( c );
-                        }
-                        else
-                            os << c;
-                }
-            }
-        }
-
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
-            xmlEncode.encodeTo( os );
-            return os;
-        }
-
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
-
-    class XmlWriter {
-    public:
-
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer )
-            :   m_writer( writer )
-            {}
-
-            ScopedElement( ScopedElement const& other )
-            :   m_writer( other.m_writer ){
-                other.m_writer = CATCH_NULL;
-            }
-
-            ~ScopedElement() {
-                if( m_writer )
-                    m_writer->endElement();
-            }
-
-            ScopedElement& writeText( std::string const& text, bool indent = true ) {
-                m_writer->writeText( text, indent );
-                return *this;
-            }
-
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
-            }
-
-        private:
-            mutable XmlWriter* m_writer;
-        };
-
-        XmlWriter()
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( Catch::cout() )
-        {
-            writeDeclaration();
-        }
-
-        XmlWriter( std::ostream& os )
-        :   m_tagIsOpen( false ),
-            m_needsNewline( false ),
-            m_os( os )
-        {
-            writeDeclaration();
-        }
-
-        ~XmlWriter() {
-            while( !m_tags.empty() )
-                endElement();
-        }
-
-        XmlWriter& startElement( std::string const& name ) {
-            ensureTagClosed();
-            newlineIfNecessary();
-            m_os << m_indent << '<' << name;
-            m_tags.push_back( name );
-            m_indent += "  ";
-            m_tagIsOpen = true;
-            return *this;
-        }
-
-        ScopedElement scopedElement( std::string const& name ) {
-            ScopedElement scoped( this );
-            startElement( name );
-            return scoped;
-        }
-
-        XmlWriter& endElement() {
-            newlineIfNecessary();
-            m_indent = m_indent.substr( 0, m_indent.size()-2 );
-            if( m_tagIsOpen ) {
-                m_os << "/>";
-                m_tagIsOpen = false;
-            }
-            else {
-                m_os << m_indent << "</" << m_tags.back() << ">";
-            }
-            m_os << std::endl;
-            m_tags.pop_back();
-            return *this;
-        }
-
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
-            if( !name.empty() && !attribute.empty() )
-                m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
-            return *this;
-        }
-
-        XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
-            m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
-            return *this;
-        }
-
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            std::ostringstream oss;
-            oss << attribute;
-            return writeAttribute( name, oss.str() );
-        }
-
-        XmlWriter& writeText( std::string const& text, bool indent = true ) {
-            if( !text.empty() ){
-                bool tagWasOpen = m_tagIsOpen;
-                ensureTagClosed();
-                if( tagWasOpen && indent )
-                    m_os << m_indent;
-                m_os << XmlEncode( text );
-                m_needsNewline = true;
-            }
-            return *this;
-        }
-
-        XmlWriter& writeComment( std::string const& text ) {
-            ensureTagClosed();
-            m_os << m_indent << "<!--" << text << "-->";
-            m_needsNewline = true;
-            return *this;
-        }
-
-        void writeStylesheetRef( std::string const& url ) {
-            m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
-        }
-
-        XmlWriter& writeBlankLine() {
-            ensureTagClosed();
-            m_os << '\n';
-            return *this;
-        }
-
-        void ensureTagClosed() {
-            if( m_tagIsOpen ) {
-                m_os << ">" << std::endl;
-                m_tagIsOpen = false;
-            }
-        }
-
-    private:
-        XmlWriter( XmlWriter const& );
-        void operator=( XmlWriter const& );
-
-        void writeDeclaration() {
-            m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
-        }
-
-        void newlineIfNecessary() {
-            if( m_needsNewline ) {
-                m_os << std::endl;
-                m_needsNewline = false;
-            }
-        }
-
-        bool m_tagIsOpen;
-        bool m_needsNewline;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
-
-}
-
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase {
-    public:
-        XmlReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_xml(_config.stream()),
-            m_sectionDepth( 0 )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
-        }
-
-        virtual ~XmlReporter() CATCH_OVERRIDE;
-
-        static std::string getDescription() {
-            return "Reports test results as an XML document";
-        }
-
-        virtual std::string getStylesheetRef() const {
-            return std::string();
-        }
-
-        void writeSourceInfo( SourceLineInfo const& sourceInfo ) {
-            m_xml
-                .writeAttribute( "filename", sourceInfo.file )
-                .writeAttribute( "line", sourceInfo.line );
-        }
-
-    public: // StreamingReporterBase
-
-        virtual void noMatchingTestCases( std::string const& s ) CATCH_OVERRIDE {
-            StreamingReporterBase::noMatchingTestCases( s );
-        }
-
-        virtual void testRunStarting( TestRunInfo const& testInfo ) CATCH_OVERRIDE {
-            StreamingReporterBase::testRunStarting( testInfo );
-            std::string stylesheetRef = getStylesheetRef();
-            if( !stylesheetRef.empty() )
-                m_xml.writeStylesheetRef( stylesheetRef );
-            m_xml.startElement( "Catch" );
-            if( !m_config->name().empty() )
-                m_xml.writeAttribute( "name", m_config->name() );
-        }
-
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-            StreamingReporterBase::testGroupStarting( groupInfo );
-            m_xml.startElement( "Group" )
-                .writeAttribute( "name", groupInfo.name );
-        }
-
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) CATCH_OVERRIDE {
-            StreamingReporterBase::testCaseStarting(testInfo);
-            m_xml.startElement( "TestCase" )
-                .writeAttribute( "name", trim( testInfo.name ) )
-                .writeAttribute( "description", testInfo.description )
-                .writeAttribute( "tags", testInfo.tagsAsString );
-
-            writeSourceInfo( testInfo.lineInfo );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                m_testCaseTimer.start();
-            m_xml.ensureTagClosed();
-        }
-
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) CATCH_OVERRIDE {
-            StreamingReporterBase::sectionStarting( sectionInfo );
-            if( m_sectionDepth++ > 0 ) {
-                m_xml.startElement( "Section" )
-                    .writeAttribute( "name", trim( sectionInfo.name ) )
-                    .writeAttribute( "description", sectionInfo.description );
-                writeSourceInfo( sectionInfo.lineInfo );
-                m_xml.ensureTagClosed();
-            }
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE { }
-
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-
-            AssertionResult const& result = assertionStats.assertionResult;
-
-            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-            if( includeResults || result.getResultType() == ResultWas::Warning ) {
-                // Print any info messages in <Info> tags.
-                for( std::vector<MessageInfo>::const_iterator it = assertionStats.infoMessages.begin(), itEnd = assertionStats.infoMessages.end();
-                     it != itEnd;
-                     ++it ) {
-                    if( it->type == ResultWas::Info && includeResults ) {
-                        m_xml.scopedElement( "Info" )
-                                .writeText( it->message );
-                    } else if ( it->type == ResultWas::Warning ) {
-                        m_xml.scopedElement( "Warning" )
-                                .writeText( it->message );
-                    }
-                }
-            }
-
-            // Drop out if result was successful but we're not printing them.
-            if( !includeResults && result.getResultType() != ResultWas::Warning )
-                return true;
-
-            // Print the expression if there is one.
-            if( result.hasExpression() ) {
-                m_xml.startElement( "Expression" )
-                    .writeAttribute( "success", result.succeeded() )
-                    .writeAttribute( "type", result.getTestMacroName() );
-
-                writeSourceInfo( result.getSourceInfo() );
-
-                m_xml.scopedElement( "Original" )
-                    .writeText( result.getExpression() );
-                m_xml.scopedElement( "Expanded" )
-                    .writeText( result.getExpandedExpression() );
-            }
-
-            // And... Print a result applicable to each result type.
-            switch( result.getResultType() ) {
-                case ResultWas::ThrewException:
-                    m_xml.startElement( "Exception" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                case ResultWas::FatalErrorCondition:
-                    m_xml.startElement( "FatalErrorCondition" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                case ResultWas::Info:
-                    m_xml.scopedElement( "Info" )
-                        .writeText( result.getMessage() );
-                    break;
-                case ResultWas::Warning:
-                    // Warning will already have been written
-                    break;
-                case ResultWas::ExplicitFailure:
-                    m_xml.startElement( "Failure" );
-                    writeSourceInfo( result.getSourceInfo() );
-                    m_xml.writeText( result.getMessage() );
-                    m_xml.endElement();
-                    break;
-                default:
-                    break;
-            }
-
-            if( result.hasExpression() )
-                m_xml.endElement();
-
-            return true;
-        }
-
-        virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::sectionEnded( sectionStats );
-            if( --m_sectionDepth > 0 ) {
-                XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
-                e.writeAttribute( "successes", sectionStats.assertions.passed );
-                e.writeAttribute( "failures", sectionStats.assertions.failed );
-                e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
-
-                if ( m_config->showDurations() == ShowDurations::Always )
-                    e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
-
-                m_xml.endElement();
-            }
-        }
-
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::testCaseEnded( testCaseStats );
-            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
-            e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
-
-            if ( m_config->showDurations() == ShowDurations::Always )
-                e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
-
-            if( !testCaseStats.stdOut.empty() )
-                m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
-            if( !testCaseStats.stdErr.empty() )
-                m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
-
-            m_xml.endElement();
-        }
-
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::testGroupEnded( testGroupStats );
-            // TODO: Check testGroupStats.aborting and act accordingly.
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
-                .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-        virtual void testRunEnded( TestRunStats const& testRunStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::testRunEnded( testRunStats );
-            m_xml.scopedElement( "OverallResults" )
-                .writeAttribute( "successes", testRunStats.totals.assertions.passed )
-                .writeAttribute( "failures", testRunStats.totals.assertions.failed )
-                .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
-            m_xml.endElement();
-        }
-
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth;
-    };
-
-     INTERNAL_CATCH_REGISTER_REPORTER( "xml", XmlReporter )
-
-} // end namespace Catch
-
-// #included from: ../reporters/catch_reporter_junit.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_JUNIT_HPP_INCLUDED
-
-#include <assert.h>
-
-namespace Catch {
+    const std::string unprintableString = "{?}";
 
     namespace {
-        std::string getCurrentTimestamp() {
-            // Beware, this is not reentrant because of backward compatibility issues
-            // Also, UTC only, again because of backward compatibility (%z is C++11)
-            time_t rawtime;
-            std::time(&rawtime);
-            const size_t timeStampSize = sizeof("2017-01-16T17:06:45Z");
+        const int hexThreshold = 255;
 
-#ifdef _MSC_VER
-            std::tm timeInfo = {};
-            gmtime_s(&timeInfo, &rawtime);
-#else
-            std::tm* timeInfo;
-            timeInfo = std::gmtime(&rawtime);
-#endif
-
-            char timeStamp[timeStampSize];
-            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
-
-#ifdef _MSC_VER
-            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
-#else
-            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
-#endif
-            return std::string(timeStamp);
-        }
+        struct Endianness {
+            enum Arch { Big, Little };
 
+            static Arch which() {
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
+            }
+        };
     }
 
-    class JunitReporter : public CumulativeReporterBase {
-    public:
-        JunitReporter( ReporterConfig const& _config )
-        :   CumulativeReporterBase( _config ),
-            xml( _config.stream() ),
-            unexpectedExceptions( 0 ),
-            m_okToFail( false )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = true;
+    std::string rawMemoryToString( const void *object, std::size_t size ) {
+        // Reverse order for little endian architectures
+        int i = 0, end = static_cast<int>( size ), inc = 1;
+        if( Endianness::which() == Endianness::Little ) {
+            i = end-1;
+            end = inc = -1;
         }
 
-        virtual ~JunitReporter() CATCH_OVERRIDE;
+        unsigned char const *bytes = static_cast<unsigned char const *>(object);
+        ReusableStringStream rss;
+        rss << "0x" << std::setfill('0') << std::hex;
+        for( ; i != end; i += inc )
+             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+       return rss.str();
+    }
+}
 
-        static std::string getDescription() {
-            return "Reports test results in an XML format that looks like Ant's junitreport target";
+template<typename T>
+std::string fpToString( T value, int precision ) {
+    if (Catch::isnan(value)) {
+        return "nan";
+    }
+
+    ReusableStringStream rss;
+    rss << std::setprecision( precision )
+        << std::fixed
+        << value;
+    std::string d = rss.str();
+    std::size_t i = d.find_last_not_of( '0' );
+    if( i != std::string::npos && i != d.size()-1 ) {
+        if( d[i] == '.' )
+            i++;
+        d = d.substr( 0, i+1 );
+    }
+    return d;
+}
+
+//// ======================================================= ////
+//
+//   Out-of-line defs for full specialization of StringMaker
+//
+//// ======================================================= ////
+
+std::string StringMaker<std::string>::convert(const std::string& str) {
+    if (!getCurrentContext().getConfig()->showInvisibles()) {
+        return '"' + str + '"';
+    }
+
+    std::string s("\"");
+    for (char c : str) {
+        switch (c) {
+        case '\n':
+            s.append("\\n");
+            break;
+        case '\t':
+            s.append("\\t");
+            break;
+        default:
+            s.push_back(c);
+            break;
         }
+    }
+    s.append("\"");
+    return s;
+}
 
-        virtual void noMatchingTestCases( std::string const& /*spec*/ ) CATCH_OVERRIDE {}
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
+}
+#endif
 
-        virtual void testRunStarting( TestRunInfo const& runInfo ) CATCH_OVERRIDE {
-            CumulativeReporterBase::testRunStarting( runInfo );
-            xml.startElement( "testsuites" );
-        }
+std::string StringMaker<char const*>::convert(char const* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<char*>::convert(char* str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::string{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
 
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) CATCH_OVERRIDE {
-            suiteTimer.start();
-            stdOutForSuite.str("");
-            stdErrForSuite.str("");
-            unexpectedExceptions = 0;
-            CumulativeReporterBase::testGroupStarting( groupInfo );
-        }
+#ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
 
-        virtual void testCaseStarting( TestCaseInfo const& testCaseInfo ) CATCH_OVERRIDE {
-            m_okToFail = testCaseInfo.okToFail();
-        }
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) CATCH_OVERRIDE {
-            if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
-                unexpectedExceptions++;
-            return CumulativeReporterBase::assertionEnded( assertionStats );
-        }
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
 
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) CATCH_OVERRIDE {
-            stdOutForSuite << testCaseStats.stdOut;
-            stdErrForSuite << testCaseStats.stdErr;
-            CumulativeReporterBase::testCaseEnded( testCaseStats );
-        }
+std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+    if (str) {
+        return ::Catch::Detail::stringify(std::wstring{ str });
+    } else {
+        return{ "{null string}" };
+    }
+}
+#endif
 
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) CATCH_OVERRIDE {
-            double suiteTime = suiteTimer.getElapsedSeconds();
-            CumulativeReporterBase::testGroupEnded( testGroupStats );
-            writeGroup( *m_testGroups.back(), suiteTime );
-        }
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
 
-        virtual void testRunEndedCumulative() CATCH_OVERRIDE {
-            xml.endElement();
-        }
+std::string StringMaker<int>::convert(int value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long>::convert(long value) {
+    return ::Catch::Detail::stringify(static_cast<long long>(value));
+}
+std::string StringMaker<long long>::convert(long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
 
-        void writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
-            XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
-            TestGroupStats const& stats = groupNode.value;
-            xml.writeAttribute( "name", stats.groupInfo.name );
-            xml.writeAttribute( "errors", unexpectedExceptions );
-            xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
-            xml.writeAttribute( "tests", stats.totals.assertions.total() );
-            xml.writeAttribute( "hostname", "tbd" ); // !TBD
-            if( m_config->showDurations() == ShowDurations::Never )
-                xml.writeAttribute( "time", "" );
-            else
-                xml.writeAttribute( "time", suiteTime );
-            xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+std::string StringMaker<unsigned int>::convert(unsigned int value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long>::convert(unsigned long value) {
+    return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+}
+std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+    ReusableStringStream rss;
+    rss << value;
+    if (value > Detail::hexThreshold) {
+        rss << " (0x" << std::hex << value << ')';
+    }
+    return rss.str();
+}
 
-            // Write test cases
-            for( TestGroupNode::ChildNodes::const_iterator
-                    it = groupNode.children.begin(), itEnd = groupNode.children.end();
-                    it != itEnd;
-                    ++it )
-                writeTestCase( **it );
+std::string StringMaker<bool>::convert(bool b) {
+    return b ? "true" : "false";
+}
 
-            xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite.str() ), false );
-            xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite.str() ), false );
-        }
+std::string StringMaker<signed char>::convert(signed char value) {
+    if (value == '\r') {
+        return "'\\r'";
+    } else if (value == '\f') {
+        return "'\\f'";
+    } else if (value == '\n') {
+        return "'\\n'";
+    } else if (value == '\t') {
+        return "'\\t'";
+    } else if ('\0' <= value && value < ' ') {
+        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+    } else {
+        char chstr[] = "' '";
+        chstr[1] = value;
+        return chstr;
+    }
+}
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
+}
+std::string StringMaker<unsigned char>::convert(unsigned char c) {
+    return ::Catch::Detail::stringify(static_cast<char>(c));
+}
 
-        void writeTestCase( TestCaseNode const& testCaseNode ) {
-            TestCaseStats const& stats = testCaseNode.value;
+std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
+    return "nullptr";
+}
 
-            // All test cases have exactly one section - which represents the
-            // test case itself. That section may have 0-n nested sections
-            assert( testCaseNode.children.size() == 1 );
-            SectionNode const& rootSection = *testCaseNode.children.front();
+int StringMaker<float>::precision = 5;
 
-            std::string className = stats.testInfo.className;
+std::string StringMaker<float>::convert(float value) {
+    return fpToString(value, precision) + 'f';
+}
 
-            if( className.empty() ) {
-                if( rootSection.childSections.empty() )
-                    className = "global";
-            }
-            writeSection( className, "", rootSection );
-        }
+int StringMaker<double>::precision = 10;
 
-        void writeSection(  std::string const& className,
-                            std::string const& rootName,
-                            SectionNode const& sectionNode ) {
-            std::string name = trim( sectionNode.stats.sectionInfo.name );
-            if( !rootName.empty() )
-                name = rootName + '/' + name;
+std::string StringMaker<double>::convert(double value) {
+    return fpToString(value, precision);
+}
 
-            if( !sectionNode.assertions.empty() ||
-                !sectionNode.stdOut.empty() ||
-                !sectionNode.stdErr.empty() ) {
-                XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
-                if( className.empty() ) {
-                    xml.writeAttribute( "classname", name );
-                    xml.writeAttribute( "name", "root" );
-                }
-                else {
-                    xml.writeAttribute( "classname", className );
-                    xml.writeAttribute( "name", name );
-                }
-                xml.writeAttribute( "time", Catch::toString( sectionNode.stats.durationInSeconds ) );
-
-                writeAssertions( sectionNode );
-
-                if( !sectionNode.stdOut.empty() )
-                    xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
-                if( !sectionNode.stdErr.empty() )
-                    xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
-            }
-            for( SectionNode::ChildSections::const_iterator
-                    it = sectionNode.childSections.begin(),
-                    itEnd = sectionNode.childSections.end();
-                    it != itEnd;
-                    ++it )
-                if( className.empty() )
-                    writeSection( name, "", **it );
-                else
-                    writeSection( className, name, **it );
-        }
-
-        void writeAssertions( SectionNode const& sectionNode ) {
-            for( SectionNode::Assertions::const_iterator
-                    it = sectionNode.assertions.begin(), itEnd = sectionNode.assertions.end();
-                    it != itEnd;
-                    ++it )
-                writeAssertion( *it );
-        }
-        void writeAssertion( AssertionStats const& stats ) {
-            AssertionResult const& result = stats.assertionResult;
-            if( !result.isOk() ) {
-                std::string elementName;
-                switch( result.getResultType() ) {
-                    case ResultWas::ThrewException:
-                    case ResultWas::FatalErrorCondition:
-                        elementName = "error";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        elementName = "failure";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        elementName = "failure";
-                        break;
-
-                    // We should never see these here:
-                    case ResultWas::Info:
-                    case ResultWas::Warning:
-                    case ResultWas::Ok:
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        elementName = "internalError";
-                        break;
-                }
-
-                XmlWriter::ScopedElement e = xml.scopedElement( elementName );
-
-                xml.writeAttribute( "message", result.getExpandedExpression() );
-                xml.writeAttribute( "type", result.getTestMacroName() );
-
-                std::ostringstream oss;
-                if( !result.getMessage().empty() )
-                    oss << result.getMessage() << '\n';
-                for( std::vector<MessageInfo>::const_iterator
-                        it = stats.infoMessages.begin(),
-                        itEnd = stats.infoMessages.end();
-                            it != itEnd;
-                            ++it )
-                    if( it->type == ResultWas::Info )
-                        oss << it->message << '\n';
-
-                oss << "at " << result.getSourceInfo();
-                xml.writeText( oss.str(), false );
-            }
-        }
-
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::ostringstream stdOutForSuite;
-        std::ostringstream stdErrForSuite;
-        unsigned int unexpectedExceptions;
-        bool m_okToFail;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+std::string ratio_string<std::atto>::symbol() { return "a"; }
+std::string ratio_string<std::femto>::symbol() { return "f"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::micro>::symbol() { return "u"; }
+std::string ratio_string<std::milli>::symbol() { return "m"; }
 
 } // end namespace Catch
 
-// #included from: ../reporters/catch_reporter_console.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+#if defined(__clang__)
+#    pragma clang diagnostic pop
+#endif
 
+// end catch_tostring.cpp
+// start catch_totals.cpp
+
+namespace Catch {
+
+    Counts Counts::operator - ( Counts const& other ) const {
+        Counts diff;
+        diff.passed = passed - other.passed;
+        diff.failed = failed - other.failed;
+        diff.failedButOk = failedButOk - other.failedButOk;
+        return diff;
+    }
+
+    Counts& Counts::operator += ( Counts const& other ) {
+        passed += other.passed;
+        failed += other.failed;
+        failedButOk += other.failedButOk;
+        return *this;
+    }
+
+    std::size_t Counts::total() const {
+        return passed + failed + failedButOk;
+    }
+    bool Counts::allPassed() const {
+        return failed == 0 && failedButOk == 0;
+    }
+    bool Counts::allOk() const {
+        return failed == 0;
+    }
+
+    Totals Totals::operator - ( Totals const& other ) const {
+        Totals diff;
+        diff.assertions = assertions - other.assertions;
+        diff.testCases = testCases - other.testCases;
+        return diff;
+    }
+
+    Totals& Totals::operator += ( Totals const& other ) {
+        assertions += other.assertions;
+        testCases += other.testCases;
+        return *this;
+    }
+
+    Totals Totals::delta( Totals const& prevTotals ) const {
+        Totals diff = *this - prevTotals;
+        if( diff.assertions.failed > 0 )
+            ++diff.testCases.failed;
+        else if( diff.assertions.failedButOk > 0 )
+            ++diff.testCases.failedButOk;
+        else
+            ++diff.testCases.passed;
+        return diff;
+    }
+
+}
+// end catch_totals.cpp
+// start catch_uncaught_exceptions.cpp
+
+// start catch_config_uncaught_exceptions.hpp
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+
+#if defined(_MSC_VER)
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+#endif
+
+#include <exception>
+
+#if defined(__cpp_lib_uncaught_exceptions) \
+    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif // __cpp_lib_uncaught_exceptions
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+// end catch_config_uncaught_exceptions.hpp
+#include <exception>
+
+namespace Catch {
+    bool uncaught_exceptions() {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        return false;
+#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+        return std::uncaught_exceptions() > 0;
+#else
+        return std::uncaught_exception();
+#endif
+  }
+} // end namespace Catch
+// end catch_uncaught_exceptions.cpp
+// start catch_version.cpp
+
+#include <ostream>
+
+namespace Catch {
+
+    Version::Version
+        (   unsigned int _majorVersion,
+            unsigned int _minorVersion,
+            unsigned int _patchNumber,
+            char const * const _branchName,
+            unsigned int _buildNumber )
+    :   majorVersion( _majorVersion ),
+        minorVersion( _minorVersion ),
+        patchNumber( _patchNumber ),
+        branchName( _branchName ),
+        buildNumber( _buildNumber )
+    {}
+
+    std::ostream& operator << ( std::ostream& os, Version const& version ) {
+        os  << version.majorVersion << '.'
+            << version.minorVersion << '.'
+            << version.patchNumber;
+        // branchName is never null -> 0th char is \0 if it is empty
+        if (version.branchName[0]) {
+            os << '-' << version.branchName
+               << '.' << version.buildNumber;
+        }
+        return os;
+    }
+
+    Version const& libraryVersion() {
+        static Version version( 2, 13, 8, "", 0 );
+        return version;
+    }
+
+}
+// end catch_version.cpp
+// start catch_wildcard_pattern.cpp
+
+namespace Catch {
+
+    WildcardPattern::WildcardPattern( std::string const& pattern,
+                                      CaseSensitive::Choice caseSensitivity )
+    :   m_caseSensitivity( caseSensitivity ),
+        m_pattern( normaliseString( pattern ) )
+    {
+        if( startsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 1 );
+            m_wildcard = WildcardAtStart;
+        }
+        if( endsWith( m_pattern, '*' ) ) {
+            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+        }
+    }
+
+    bool WildcardPattern::matches( std::string const& str ) const {
+        switch( m_wildcard ) {
+            case NoWildcard:
+                return m_pattern == normaliseString( str );
+            case WildcardAtStart:
+                return endsWith( normaliseString( str ), m_pattern );
+            case WildcardAtEnd:
+                return startsWith( normaliseString( str ), m_pattern );
+            case WildcardAtBothEnds:
+                return contains( normaliseString( str ), m_pattern );
+            default:
+                CATCH_INTERNAL_ERROR( "Unknown enum" );
+        }
+    }
+
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+    }
+}
+// end catch_wildcard_pattern.cpp
+// start catch_xmlwriter.cpp
+
+#include <iomanip>
+#include <type_traits>
+
+namespace Catch {
+
+namespace {
+
+    size_t trailingBytes(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return 2;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return 3;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return 4;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    uint32_t headerValue(unsigned char c) {
+        if ((c & 0xE0) == 0xC0) {
+            return c & 0x1F;
+        }
+        if ((c & 0xF0) == 0xE0) {
+            return c & 0x0F;
+        }
+        if ((c & 0xF8) == 0xF0) {
+            return c & 0x07;
+        }
+        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+    }
+
+    void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
+        os << "\\x"
+            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+            << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
+    }
+
+} // anonymous namespace
+
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
+    :   m_str( str ),
+        m_forWhat( forWhat )
+    {}
+
+    void XmlEncode::encodeTo( std::ostream& os ) const {
+        // Apostrophe escaping not necessary if we always use " to write attributes
+        // (see: http://www.w3.org/TR/xml/#syntax)
+
+        for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+            unsigned char c = m_str[idx];
+            switch (c) {
+            case '<':   os << "&lt;"; break;
+            case '&':   os << "&amp;"; break;
+
+            case '>':
+                // See: http://www.w3.org/TR/xml/#syntax
+                if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+                    os << "&gt;";
+                else
+                    os << c;
+                break;
+
+            case '\"':
+                if (m_forWhat == ForAttributes)
+                    os << "&quot;";
+                else
+                    os << c;
+                break;
+
+            default:
+                // Check for control characters and invalid utf-8
+
+                // Escape control characters in standard ascii
+                // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+                if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // Plain ASCII: Write it to stream
+                if (c < 0x7F) {
+                    os << c;
+                    break;
+                }
+
+                // UTF-8 territory
+                // Check if the encoding is valid and if it is not, hex escape bytes.
+                // Important: We do not check the exact decoded values for validity, only the encoding format
+                // First check that this bytes is a valid lead byte:
+                // This means that it is not encoded as 1111 1XXX
+                // Or as 10XX XXXX
+                if (c <  0xC0 ||
+                    c >= 0xF8) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                auto encBytes = trailingBytes(c);
+                // Are there enough bytes left to avoid accessing out-of-bounds memory?
+                if (idx + encBytes - 1 >= m_str.size()) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+                // The header is valid, check data
+                // The next encBytes bytes must together be a valid utf-8
+                // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+                bool valid = true;
+                uint32_t value = headerValue(c);
+                for (std::size_t n = 1; n < encBytes; ++n) {
+                    unsigned char nc = m_str[idx + n];
+                    valid &= ((nc & 0xC0) == 0x80);
+                    value = (value << 6) | (nc & 0x3F);
+                }
+
+                if (
+                    // Wrong bit pattern of following bytes
+                    (!valid) ||
+                    // Overlong encodings
+                    (value < 0x80) ||
+                    (0x80 <= value && value < 0x800   && encBytes > 2) ||
+                    (0x800 < value && value < 0x10000 && encBytes > 3) ||
+                    // Encoded value out of range
+                    (value >= 0x110000)
+                    ) {
+                    hexEscapeChar(os, c);
+                    break;
+                }
+
+                // If we got here, this is in fact a valid(ish) utf-8 sequence
+                for (std::size_t n = 0; n < encBytes; ++n) {
+                    os << m_str[idx + n];
+                }
+                idx += encBytes - 1;
+                break;
+            }
+        }
+    }
+
+    std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+        xmlEncode.encodeTo( os );
+        return os;
+    }
+
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
+    {}
+
+    XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
+        other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
+    }
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+        if ( m_writer ) {
+            m_writer->endElement();
+        }
+        m_writer = other.m_writer;
+        other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
+        return *this;
+    }
+
+    XmlWriter::ScopedElement::~ScopedElement() {
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
+    }
+
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
+        return *this;
+    }
+
+    XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+    {
+        writeDeclaration();
+    }
+
+    XmlWriter::~XmlWriter() {
+        while (!m_tags.empty()) {
+            endElement();
+        }
+        newlineIfNecessary();
+    }
+
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+        ensureTagClosed();
+        newlineIfNecessary();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
+        m_tags.push_back( name );
+        m_tagIsOpen = true;
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
+        return scoped;
+    }
+
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
+        if( m_tagIsOpen ) {
+            m_os << "/>";
+            m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
+        }
+        m_os << std::flush;
+        applyFormatting(fmt);
+        m_tags.pop_back();
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, std::string const& attribute ) {
+        if( !name.empty() && !attribute.empty() )
+            m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeAttribute( std::string const& name, bool attribute ) {
+        m_os << ' ' << name << "=\"" << ( attribute ? "true" : "false" ) << '"';
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
+        if( !text.empty() ){
+            bool tagWasOpen = m_tagIsOpen;
+            ensureTagClosed();
+            if (tagWasOpen && shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << XmlEncode( text );
+            applyFormatting(fmt);
+        }
+        return *this;
+    }
+
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
+        ensureTagClosed();
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
+        return *this;
+    }
+
+    void XmlWriter::writeStylesheetRef( std::string const& url ) {
+        m_os << "<?xml-stylesheet type=\"text/xsl\" href=\"" << url << "\"?>\n";
+    }
+
+    XmlWriter& XmlWriter::writeBlankLine() {
+        ensureTagClosed();
+        m_os << '\n';
+        return *this;
+    }
+
+    void XmlWriter::ensureTagClosed() {
+        if( m_tagIsOpen ) {
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
+            m_tagIsOpen = false;
+        }
+    }
+
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
+    void XmlWriter::writeDeclaration() {
+        m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
+    }
+
+    void XmlWriter::newlineIfNecessary() {
+        if( m_needsNewline ) {
+            m_os << std::endl;
+            m_needsNewline = false;
+        }
+    }
+}
+// end catch_xmlwriter.cpp
+// start catch_reporter_bases.cpp
+
+#include <cstring>
 #include <cfloat>
 #include <cstdio>
+#include <cassert>
+#include <memory>
 
 namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result) {
+        result.getExpandedExpression();
+    }
 
-    struct ConsoleReporter : StreamingReporterBase {
-        ConsoleReporter( ReporterConfig const& _config )
-        :   StreamingReporterBase( _config ),
-            m_headerPrinted( false )
-        {}
+    // Because formatting using c++ streams is stateful, drop down to C is required
+    // Alternatively we could use stringstream, but its performance is... not good.
+    std::string getFormattedDuration( double duration ) {
+        // Max exponent + 1 is required to represent the whole part
+        // + 1 for decimal point
+        // + 3 for the 3 decimal places
+        // + 1 for null terminator
+        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+        char buffer[maxDoubleSize];
 
-        virtual ~ConsoleReporter() CATCH_OVERRIDE;
-        static std::string getDescription() {
-            return "Reports test results as plain lines of text";
-        }
+        // Save previous errno, to prevent sprintf from overwriting it
+        ErrnoGuard guard;
+#ifdef _MSC_VER
+        sprintf_s(buffer, "%.3f", duration);
+#else
+        std::sprintf(buffer, "%.3f", duration);
+#endif
+        return std::string(buffer);
+    }
 
-        virtual void noMatchingTestCases( std::string const& spec ) CATCH_OVERRIDE {
-            stream << "No test cases matched '" << spec << '\'' << std::endl;
-        }
-
-        virtual void assertionStarting( AssertionInfo const& ) CATCH_OVERRIDE {
-        }
-
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) CATCH_OVERRIDE {
-            AssertionResult const& result = _assertionStats.assertionResult;
-
-            bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
-
-            // Drop out if result was successful but we're not printing them.
-            if( !includeResults && result.getResultType() != ResultWas::Warning )
-                return false;
-
-            lazyPrint();
-
-            AssertionPrinter printer( stream, _assertionStats, includeResults );
-            printer.print();
-            stream << std::endl;
+    bool shouldShowDuration( IConfig const& config, double duration ) {
+        if ( config.showDurations() == ShowDurations::Always ) {
             return true;
         }
-
-        virtual void sectionStarting( SectionInfo const& _sectionInfo ) CATCH_OVERRIDE {
-            m_headerPrinted = false;
-            StreamingReporterBase::sectionStarting( _sectionInfo );
-        }
-        virtual void sectionEnded( SectionStats const& _sectionStats ) CATCH_OVERRIDE {
-            if( _sectionStats.missingAssertions ) {
-                lazyPrint();
-                Colour colour( Colour::ResultError );
-                if( m_sectionStack.size() > 1 )
-                    stream << "\nNo assertions in section";
-                else
-                    stream << "\nNo assertions in test case";
-                stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
-            }
-            if( m_config->showDurations() == ShowDurations::Always ) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
-            }
-            if( m_headerPrinted ) {
-                m_headerPrinted = false;
-            }
-            StreamingReporterBase::sectionEnded( _sectionStats );
+        if ( config.showDurations() == ShowDurations::Never ) {
+            return false;
         }
+        const double min = config.minDuration();
+        return min >= 0 && duration >= min;
+    }
 
-        virtual void testCaseEnded( TestCaseStats const& _testCaseStats ) CATCH_OVERRIDE {
-            StreamingReporterBase::testCaseEnded( _testCaseStats );
-            m_headerPrinted = false;
-        }
-        virtual void testGroupEnded( TestGroupStats const& _testGroupStats ) CATCH_OVERRIDE {
-            if( currentGroupInfo.used ) {
-                printSummaryDivider();
-                stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
-                printTotals( _testGroupStats.totals );
-                stream << '\n' << std::endl;
-            }
-            StreamingReporterBase::testGroupEnded( _testGroupStats );
-        }
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) CATCH_OVERRIDE {
-            printTotalsDivider( _testRunStats.totals );
-            printTotals( _testRunStats.totals );
-            stream << std::endl;
-            StreamingReporterBase::testRunEnded( _testRunStats );
-        }
-
-    private:
-
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            :   stream( _stream ),
-                stats( _stats ),
-                result( _stats.assertionResult ),
-                colour( Colour::None ),
-                message( result.getMessage() ),
-                messages( _stats.infoMessages ),
-                printInfoMessages( _printInfoMessages )
-            {
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        colour = Colour::Success;
-                        passOrFail = "PASSED";
-                        //if( result.hasMessage() )
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() ) {
-                            colour = Colour::Success;
-                            passOrFail = "FAILED - but was ok";
-                        }
-                        else {
-                            colour = Colour::Error;
-                            passOrFail = "FAILED";
-                        }
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "with messages";
-                        break;
-                    case ResultWas::ThrewException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to unexpected exception with ";
-                        if (_stats.infoMessages.size() == 1)
-                            messageLabel += "message";
-                        if (_stats.infoMessages.size() > 1)
-                            messageLabel += "messages";
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "due to a fatal error condition";
-                        break;
-                    case ResultWas::DidntThrowException:
-                        colour = Colour::Error;
-                        passOrFail = "FAILED";
-                        messageLabel = "because no exception was thrown where one was expected";
-                        break;
-                    case ResultWas::Info:
-                        messageLabel = "info";
-                        break;
-                    case ResultWas::Warning:
-                        messageLabel = "warning";
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        passOrFail = "FAILED";
-                        colour = Colour::Error;
-                        if( _stats.infoMessages.size() == 1 )
-                            messageLabel = "explicitly with message";
-                        if( _stats.infoMessages.size() > 1 )
-                            messageLabel = "explicitly with messages";
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        passOrFail = "** internal error **";
-                        colour = Colour::Error;
-                        break;
-                }
-            }
-
-            void print() const {
-                printSourceInfo();
-                if( stats.totals.assertions.total() > 0 ) {
-                    if( result.isOk() )
-                        stream << '\n';
-                    printResultType();
-                    printOriginalExpression();
-                    printReconstructedExpression();
-                }
-                else {
-                    stream << '\n';
-                }
-                printMessage();
-            }
-
-        private:
-            void printResultType() const {
-                if( !passOrFail.empty() ) {
-                    Colour colourGuard( colour );
-                    stream << passOrFail << ":\n";
-                }
-            }
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    Colour colourGuard( Colour::OriginalExpression );
-                    stream  << "  ";
-                    stream << result.getExpressionInMacro();
-                    stream << '\n';
-                }
-            }
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    stream << "with expansion:\n";
-                    Colour colourGuard( Colour::ReconstructedExpression );
-                    stream << Text( result.getExpandedExpression(), TextAttributes().setIndent(2) ) << '\n';
-                }
-            }
-            void printMessage() const {
-                if( !messageLabel.empty() )
-                    stream << messageLabel << ':' << '\n';
-                for( std::vector<MessageInfo>::const_iterator it = messages.begin(), itEnd = messages.end();
-                        it != itEnd;
-                        ++it ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || it->type != ResultWas::Info )
-                        stream << Text( it->message, TextAttributes().setIndent(2) ) << '\n';
-                }
-            }
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ": ";
-            }
-
-            std::ostream& stream;
-            AssertionStats const& stats;
-            AssertionResult const& result;
-            Colour::Code colour;
-            std::string passOrFail;
-            std::string messageLabel;
-            std::string message;
-            std::vector<MessageInfo> messages;
-            bool printInfoMessages;
-        };
-
-        void lazyPrint() {
-
-            if( !currentTestRunInfo.used )
-                lazyPrintRunInfo();
-            if( !currentGroupInfo.used )
-                lazyPrintGroupInfo();
-
-            if( !m_headerPrinted ) {
-                printTestCaseAndSectionHeader();
-                m_headerPrinted = true;
-            }
-        }
-        void lazyPrintRunInfo() {
-            stream  << '\n' << getLineOfChars<'~'>() << '\n';
-            Colour colour( Colour::SecondaryText );
-            stream  << currentTestRunInfo->name
-                    << " is a Catch v"  << libraryVersion() << " host application.\n"
-                    << "Run with -? for options\n\n";
-
-            if( m_config->rngSeed() != 0 )
-                stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
-
-            currentTestRunInfo.used = true;
-        }
-        void lazyPrintGroupInfo() {
-            if( !currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1 ) {
-                printClosedHeader( "Group: " + currentGroupInfo->name );
-                currentGroupInfo.used = true;
-            }
-        }
-        void printTestCaseAndSectionHeader() {
-            assert( !m_sectionStack.empty() );
-            printOpenHeader( currentTestCaseInfo->name );
-
-            if( m_sectionStack.size() > 1 ) {
-                Colour colourGuard( Colour::Headers );
-
-                std::vector<SectionInfo>::const_iterator
-                    it = m_sectionStack.begin()+1, // Skip first section (test case)
-                    itEnd = m_sectionStack.end();
-                for( ; it != itEnd; ++it )
-                    printHeaderString( it->name, 2 );
-            }
-
-            SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
-
-            if( !lineInfo.empty() ){
-                stream << getLineOfChars<'-'>() << '\n';
-                Colour colourGuard( Colour::FileName );
-                stream << lineInfo << '\n';
-            }
-            stream << getLineOfChars<'.'>() << '\n' << std::endl;
-        }
-
-        void printClosedHeader( std::string const& _name ) {
-            printOpenHeader( _name );
-            stream << getLineOfChars<'.'>() << '\n';
-        }
-        void printOpenHeader( std::string const& _name ) {
-            stream  << getLineOfChars<'-'>() << '\n';
-            {
-                Colour colourGuard( Colour::Headers );
-                printHeaderString( _name );
-            }
-        }
-
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString( std::string const& _string, std::size_t indent = 0 ) {
-            std::size_t i = _string.find( ": " );
-            if( i != std::string::npos )
-                i+=2;
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
             else
-                i = 0;
-            stream << Text( _string, TextAttributes()
-                                        .setIndent( indent+i)
-                                        .setInitialIndent( indent ) ) << '\n';
+                first = false;
+
+            oss << filter;
         }
+        return oss.str();
+    }
 
-        struct SummaryColumn {
+    TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
+        :StreamingReporterBase(_config) {}
 
-            SummaryColumn( std::string const& _label, Colour::Code _colour )
-            :   label( _label ),
-                colour( _colour )
-            {}
-            SummaryColumn addRow( std::size_t count ) {
-                std::ostringstream oss;
-                oss << count;
-                std::string row = oss.str();
-                for( std::vector<std::string>::iterator it = rows.begin(); it != rows.end(); ++it ) {
-                    while( it->size() < row.size() )
-                        *it = ' ' + *it;
-                    while( it->size() > row.size() )
-                        row = ' ' + row;
-                }
-                rows.push_back( row );
-                return *this;
-            }
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
 
-            std::string label;
-            Colour::Code colour;
-            std::vector<std::string> rows;
+    void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
 
-        };
-
-        void printTotals( Totals const& totals ) {
-            if( totals.testCases.total() == 0 ) {
-                stream << Colour( Colour::Warning ) << "No tests ran\n";
-            }
-            else if( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
-                stream << Colour( Colour::ResultSuccess ) << "All tests passed";
-                stream << " ("
-                        << pluralise( totals.assertions.passed, "assertion" ) << " in "
-                        << pluralise( totals.testCases.passed, "test case" ) << ')'
-                        << '\n';
-            }
-            else {
-
-                std::vector<SummaryColumn> columns;
-                columns.push_back( SummaryColumn( "", Colour::None )
-                                        .addRow( totals.testCases.total() )
-                                        .addRow( totals.assertions.total() ) );
-                columns.push_back( SummaryColumn( "passed", Colour::Success )
-                                        .addRow( totals.testCases.passed )
-                                        .addRow( totals.assertions.passed ) );
-                columns.push_back( SummaryColumn( "failed", Colour::ResultError )
-                                        .addRow( totals.testCases.failed )
-                                        .addRow( totals.assertions.failed ) );
-                columns.push_back( SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
-                                        .addRow( totals.testCases.failedButOk )
-                                        .addRow( totals.assertions.failedButOk ) );
-
-                printSummaryRow( "test cases", columns, 0 );
-                printSummaryRow( "assertions", columns, 1 );
-            }
-        }
-        void printSummaryRow( std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row ) {
-            for( std::vector<SummaryColumn>::const_iterator it = cols.begin(); it != cols.end(); ++it ) {
-                std::string value = it->rows[row];
-                if( it->label.empty() ) {
-                    stream << label << ": ";
-                    if( value != "0" )
-                        stream << value;
-                    else
-                        stream << Colour( Colour::Warning ) << "- none -";
-                }
-                else if( value != "0" ) {
-                    stream  << Colour( Colour::LightGrey ) << " | ";
-                    stream  << Colour( it->colour )
-                            << value << ' ' << it->label;
-                }
-            }
-            stream << '\n';
-        }
-
-        static std::size_t makeRatio( std::size_t number, std::size_t total ) {
-            std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number/ total : 0;
-            return ( ratio == 0 && number > 0 ) ? 1 : ratio;
-        }
-        static std::size_t& findMax( std::size_t& i, std::size_t& j, std::size_t& k ) {
-            if( i > j && i > k )
-                return i;
-            else if( j > k )
-                return j;
-            else
-                return k;
-        }
-
-        void printTotalsDivider( Totals const& totals ) {
-            if( totals.testCases.total() > 0 ) {
-                std::size_t failedRatio = makeRatio( totals.testCases.failed, totals.testCases.total() );
-                std::size_t failedButOkRatio = makeRatio( totals.testCases.failedButOk, totals.testCases.total() );
-                std::size_t passedRatio = makeRatio( totals.testCases.passed, totals.testCases.total() );
-                while( failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )++;
-                while( failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH-1 )
-                    findMax( failedRatio, failedButOkRatio, passedRatio )--;
-
-                stream << Colour( Colour::Error ) << std::string( failedRatio, '=' );
-                stream << Colour( Colour::ResultExpectedFailure ) << std::string( failedButOkRatio, '=' );
-                if( totals.testCases.allPassed() )
-                    stream << Colour( Colour::ResultSuccess ) << std::string( passedRatio, '=' );
-                else
-                    stream << Colour( Colour::Success ) << std::string( passedRatio, '=' );
-            }
-            else {
-                stream << Colour( Colour::Warning ) << std::string( CATCH_CONFIG_CONSOLE_WIDTH-1, '=' );
-            }
-            stream << '\n';
-        }
-        void printSummaryDivider() {
-            stream << getLineOfChars<'-'>() << '\n';
-        }
-
-    private:
-        bool m_headerPrinted;
-    };
-
-    INTERNAL_CATCH_REGISTER_REPORTER( "console", ConsoleReporter )
+    bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
+        return false;
+    }
 
 } // end namespace Catch
+// end catch_reporter_bases.cpp
+// start catch_reporter_compact.cpp
 
-// #included from: ../reporters/catch_reporter_compact.hpp
-#define TWOBLUECUBES_CATCH_REPORTER_COMPACT_HPP_INCLUDED
+namespace {
+
+#ifdef CATCH_PLATFORM_MAC
+    const char* failedString() { return "FAILED"; }
+    const char* passedString() { return "PASSED"; }
+#else
+    const char* failedString() { return "failed"; }
+    const char* passedString() { return "passed"; }
+#endif
+
+    // Colour::LightGrey
+    Catch::Colour::Code dimColour() { return Catch::Colour::FileName; }
+
+    std::string bothOrAll( std::size_t count ) {
+        return count == 1 ? std::string() :
+               count == 2 ? "both " : "all " ;
+    }
+
+} // anon namespace
 
 namespace Catch {
+namespace {
+// Colour, message variants:
+// - white: No tests ran.
+// -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
+// - white: Passed [both/all] N test cases (no assertions).
+// -   red: Failed N tests cases, failed M assertions.
+// - green: Passed [both/all] N tests cases with M assertions.
+void printTotals(std::ostream& out, const Totals& totals) {
+    if (totals.testCases.total() == 0) {
+        out << "No tests ran.";
+    } else if (totals.testCases.failed == totals.testCases.total()) {
+        Colour colour(Colour::ResultError);
+        const std::string qualify_assertions_failed =
+            totals.assertions.failed == totals.assertions.total() ?
+            bothOrAll(totals.assertions.failed) : std::string();
+        out <<
+            "Failed " << bothOrAll(totals.testCases.failed)
+            << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << qualify_assertions_failed <<
+            pluralise(totals.assertions.failed, "assertion") << '.';
+    } else if (totals.assertions.total() == 0) {
+        out <<
+            "Passed " << bothOrAll(totals.testCases.total())
+            << pluralise(totals.testCases.total(), "test case")
+            << " (no assertions).";
+    } else if (totals.assertions.failed) {
+        Colour colour(Colour::ResultError);
+        out <<
+            "Failed " << pluralise(totals.testCases.failed, "test case") << ", "
+            "failed " << pluralise(totals.assertions.failed, "assertion") << '.';
+    } else {
+        Colour colour(Colour::ResultSuccess);
+        out <<
+            "Passed " << bothOrAll(totals.testCases.passed)
+            << pluralise(totals.testCases.passed, "test case") <<
+            " with " << pluralise(totals.assertions.passed, "assertion") << '.';
+    }
+}
 
-    struct CompactReporter : StreamingReporterBase {
+// Implementation of CompactReporter formatting
+class AssertionPrinter {
+public:
+    AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+    AssertionPrinter(AssertionPrinter const&) = delete;
+    AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream)
+        , result(_stats.assertionResult)
+        , messages(_stats.infoMessages)
+        , itMessage(_stats.infoMessages.begin())
+        , printInfoMessages(_printInfoMessages) {}
 
-        CompactReporter( ReporterConfig const& _config )
-        : StreamingReporterBase( _config )
-        {}
+    void print() {
+        printSourceInfo();
 
-        virtual ~CompactReporter();
+        itMessage = messages.begin();
 
-        static std::string getDescription() {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            printResultType(Colour::ResultSuccess, passedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            if (!result.hasExpression())
+                printRemainingMessages(Colour::None);
+            else
+                printRemainingMessages();
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk())
+                printResultType(Colour::ResultSuccess, failedString() + std::string(" - but was ok"));
+            else
+                printResultType(Colour::Error, failedString());
+            printOriginalExpression();
+            printReconstructedExpression();
+            printRemainingMessages();
+            break;
+        case ResultWas::ThrewException:
+            printResultType(Colour::Error, failedString());
+            printIssue("unexpected exception with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::FatalErrorCondition:
+            printResultType(Colour::Error, failedString());
+            printIssue("fatal error condition with message:");
+            printMessage();
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::DidntThrowException:
+            printResultType(Colour::Error, failedString());
+            printIssue("expected exception, got none");
+            printExpressionWas();
+            printRemainingMessages();
+            break;
+        case ResultWas::Info:
+            printResultType(Colour::None, "info");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::Warning:
+            printResultType(Colour::None, "warning");
+            printMessage();
+            printRemainingMessages();
+            break;
+        case ResultWas::ExplicitFailure:
+            printResultType(Colour::Error, failedString());
+            printIssue("explicitly");
+            printRemainingMessages(Colour::None);
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            printResultType(Colour::Error, "** internal error **");
+            break;
+        }
+    }
+
+private:
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ':';
+    }
+
+    void printResultType(Colour::Code colour, std::string const& passOrFail) const {
+        if (!passOrFail.empty()) {
+            {
+                Colour colourGuard(colour);
+                stream << ' ' << passOrFail;
+            }
+            stream << ':';
+        }
+    }
+
+    void printIssue(std::string const& issue) const {
+        stream << ' ' << issue;
+    }
+
+    void printExpressionWas() {
+        if (result.hasExpression()) {
+            stream << ';';
+            {
+                Colour colour(dimColour());
+                stream << " expression was:";
+            }
+            printOriginalExpression();
+        }
+    }
+
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            stream << ' ' << result.getExpression();
+        }
+    }
+
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            {
+                Colour colour(dimColour());
+                stream << " for: ";
+            }
+            stream << result.getExpandedExpression();
+        }
+    }
+
+    void printMessage() {
+        if (itMessage != messages.end()) {
+            stream << " '" << itMessage->message << '\'';
+            ++itMessage;
+        }
+    }
+
+    void printRemainingMessages(Colour::Code colour = dimColour()) {
+        if (itMessage == messages.end())
+            return;
+
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+
+        {
+            Colour colourGuard(colour);
+            stream << " with " << pluralise(N, "message") << ':';
+        }
+
+        while (itMessage != itEnd) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || itMessage->type != ResultWas::Info) {
+                printMessage();
+                if (itMessage != itEnd) {
+                    Colour colourGuard(dimColour());
+                    stream << " and";
+                }
+                continue;
+            }
+            ++itMessage;
+        }
+    }
+
+private:
+    std::ostream& stream;
+    AssertionResult const& result;
+    std::vector<MessageInfo> messages;
+    std::vector<MessageInfo>::const_iterator itMessage;
+    bool printInfoMessages;
+};
+
+} // anon namespace
+
+        std::string CompactReporter::getDescription() {
             return "Reports test results on a single line, suitable for IDEs";
         }
 
-        virtual ReporterPreferences getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
-        virtual void noMatchingTestCases( std::string const& spec ) {
+        void CompactReporter::noMatchingTestCases( std::string const& spec ) {
             stream << "No test cases matched '" << spec << '\'' << std::endl;
         }
 
-        virtual void assertionStarting( AssertionInfo const& ) {}
+        void CompactReporter::assertionStarting( AssertionInfo const& ) {}
 
-        virtual bool assertionEnded( AssertionStats const& _assertionStats ) {
+        bool CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
             AssertionResult const& result = _assertionStats.assertionResult;
 
             bool printInfoMessages = true;
@@ -11142,323 +16091,1438 @@ namespace Catch {
             return true;
         }
 
-        virtual void sectionEnded(SectionStats const& _sectionStats) CATCH_OVERRIDE {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+        void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+            double dur = _sectionStats.durationInSeconds;
+            if ( shouldShowDuration( *m_config, dur ) ) {
+                stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << std::endl;
             }
         }
 
-        virtual void testRunEnded( TestRunStats const& _testRunStats ) {
-            printTotals( _testRunStats.totals );
+        void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+            printTotals( stream, _testRunStats.totals );
             stream << '\n' << std::endl;
             StreamingReporterBase::testRunEnded( _testRunStats );
         }
 
-    private:
-        class AssertionPrinter {
-            void operator= ( AssertionPrinter const& );
-        public:
-            AssertionPrinter( std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages )
-            : stream( _stream )
-            , stats( _stats )
-            , result( _stats.assertionResult )
-            , messages( _stats.infoMessages )
-            , itMessage( _stats.infoMessages.begin() )
-            , printInfoMessages( _printInfoMessages )
-            {}
+        CompactReporter::~CompactReporter() {}
 
-            void print() {
-                printSourceInfo();
+    CATCH_REGISTER_REPORTER( "compact", CompactReporter )
 
-                itMessage = messages.begin();
+} // end namespace Catch
+// end catch_reporter_compact.cpp
+// start catch_reporter_console.cpp
 
-                switch( result.getResultType() ) {
-                    case ResultWas::Ok:
-                        printResultType( Colour::ResultSuccess, passedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        if ( ! result.hasExpression() )
-                            printRemainingMessages( Colour::None );
-                        else
-                            printRemainingMessages();
-                        break;
-                    case ResultWas::ExpressionFailed:
-                        if( result.isOk() )
-                            printResultType( Colour::ResultSuccess, failedString() + std::string( " - but was ok" ) );
-                        else
-                            printResultType( Colour::Error, failedString() );
-                        printOriginalExpression();
-                        printReconstructedExpression();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ThrewException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "unexpected exception with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::FatalErrorCondition:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "fatal error condition with message:" );
-                        printMessage();
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::DidntThrowException:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "expected exception, got none" );
-                        printExpressionWas();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Info:
-                        printResultType( Colour::None, "info" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::Warning:
-                        printResultType( Colour::None, "warning" );
-                        printMessage();
-                        printRemainingMessages();
-                        break;
-                    case ResultWas::ExplicitFailure:
-                        printResultType( Colour::Error, failedString() );
-                        printIssue( "explicitly" );
-                        printRemainingMessages( Colour::None );
-                        break;
-                    // These cases are here to prevent compiler warnings
-                    case ResultWas::Unknown:
-                    case ResultWas::FailureBit:
-                    case ResultWas::Exception:
-                        printResultType( Colour::Error, "** internal error **" );
-                        break;
-                }
-            }
+#include <cfloat>
+#include <cstdio>
 
-        private:
-            // Colour::LightGrey
-
-            static Colour::Code dimColour() { return Colour::FileName; }
-
-#ifdef CATCH_PLATFORM_MAC
-            static const char* failedString() { return "FAILED"; }
-            static const char* passedString() { return "PASSED"; }
-#else
-            static const char* failedString() { return "failed"; }
-            static const char* passedString() { return "passed"; }
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
 #endif
 
-            void printSourceInfo() const {
-                Colour colourGuard( Colour::FileName );
-                stream << result.getSourceInfo() << ':';
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
+#endif
+
+namespace Catch {
+
+namespace {
+
+// Formatter impl for ConsoleReporter
+class ConsoleAssertionPrinter {
+public:
+    ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+    ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages)
+        : stream(_stream),
+        stats(_stats),
+        result(_stats.assertionResult),
+        colour(Colour::None),
+        message(result.getMessage()),
+        messages(_stats.infoMessages),
+        printInfoMessages(_printInfoMessages) {
+        switch (result.getResultType()) {
+        case ResultWas::Ok:
+            colour = Colour::Success;
+            passOrFail = "PASSED";
+            //if( result.hasMessage() )
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ExpressionFailed:
+            if (result.isOk()) {
+                colour = Colour::Success;
+                passOrFail = "FAILED - but was ok";
+            } else {
+                colour = Colour::Error;
+                passOrFail = "FAILED";
             }
-
-            void printResultType( Colour::Code colour, std::string const& passOrFail ) const {
-                if( !passOrFail.empty() ) {
-                    {
-                        Colour colourGuard( colour );
-                        stream << ' ' << passOrFail;
-                    }
-                    stream << ':';
-                }
-            }
-
-            void printIssue( std::string const& issue ) const {
-                stream << ' ' << issue;
-            }
-
-            void printExpressionWas() {
-                if( result.hasExpression() ) {
-                    stream << ';';
-                    {
-                        Colour colour( dimColour() );
-                        stream << " expression was:";
-                    }
-                    printOriginalExpression();
-                }
-            }
-
-            void printOriginalExpression() const {
-                if( result.hasExpression() ) {
-                    stream << ' ' << result.getExpression();
-                }
-            }
-
-            void printReconstructedExpression() const {
-                if( result.hasExpandedExpression() ) {
-                    {
-                        Colour colour( dimColour() );
-                        stream << " for: ";
-                    }
-                    stream << result.getExpandedExpression();
-                }
-            }
-
-            void printMessage() {
-                if ( itMessage != messages.end() ) {
-                    stream << " '" << itMessage->message << '\'';
-                    ++itMessage;
-                }
-            }
-
-            void printRemainingMessages( Colour::Code colour = dimColour() ) {
-                if ( itMessage == messages.end() )
-                    return;
-
-                // using messages.end() directly yields compilation error:
-                std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-                const std::size_t N = static_cast<std::size_t>( std::distance( itMessage, itEnd ) );
-
-                {
-                    Colour colourGuard( colour );
-                    stream << " with " << pluralise( N, "message" ) << ':';
-                }
-
-                for(; itMessage != itEnd; ) {
-                    // If this assertion is a warning ignore any INFO messages
-                    if( printInfoMessages || itMessage->type != ResultWas::Info ) {
-                        stream << " '" << itMessage->message << '\'';
-                        if ( ++itMessage != itEnd ) {
-                            Colour colourGuard( dimColour() );
-                            stream << " and";
-                        }
-                    }
-                }
-            }
-
-        private:
-            std::ostream& stream;
-            AssertionStats const& stats;
-            AssertionResult const& result;
-            std::vector<MessageInfo> messages;
-            std::vector<MessageInfo>::const_iterator itMessage;
-            bool printInfoMessages;
-        };
-
-        // Colour, message variants:
-        // - white: No tests ran.
-        // -   red: Failed [both/all] N test cases, failed [both/all] M assertions.
-        // - white: Passed [both/all] N test cases (no assertions).
-        // -   red: Failed N tests cases, failed M assertions.
-        // - green: Passed [both/all] N tests cases with M assertions.
-
-        std::string bothOrAll( std::size_t count ) const {
-            return count == 1 ? std::string() : count == 2 ? "both " : "all " ;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "with messages";
+            break;
+        case ResultWas::ThrewException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to unexpected exception with ";
+            if (_stats.infoMessages.size() == 1)
+                messageLabel += "message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel += "messages";
+            break;
+        case ResultWas::FatalErrorCondition:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "due to a fatal error condition";
+            break;
+        case ResultWas::DidntThrowException:
+            colour = Colour::Error;
+            passOrFail = "FAILED";
+            messageLabel = "because no exception was thrown where one was expected";
+            break;
+        case ResultWas::Info:
+            messageLabel = "info";
+            break;
+        case ResultWas::Warning:
+            messageLabel = "warning";
+            break;
+        case ResultWas::ExplicitFailure:
+            passOrFail = "FAILED";
+            colour = Colour::Error;
+            if (_stats.infoMessages.size() == 1)
+                messageLabel = "explicitly with message";
+            if (_stats.infoMessages.size() > 1)
+                messageLabel = "explicitly with messages";
+            break;
+            // These cases are here to prevent compiler warnings
+        case ResultWas::Unknown:
+        case ResultWas::FailureBit:
+        case ResultWas::Exception:
+            passOrFail = "** internal error **";
+            colour = Colour::Error;
+            break;
         }
+    }
 
-        void printTotals( const Totals& totals ) const {
-            if( totals.testCases.total() == 0 ) {
-                stream << "No tests ran.";
-            }
-            else if( totals.testCases.failed == totals.testCases.total() ) {
-                Colour colour( Colour::ResultError );
-                const std::string qualify_assertions_failed =
-                    totals.assertions.failed == totals.assertions.total() ?
-                        bothOrAll( totals.assertions.failed ) : std::string();
-                stream <<
-                    "Failed " << bothOrAll( totals.testCases.failed )
-                              << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << qualify_assertions_failed <<
-                                 pluralise( totals.assertions.failed, "assertion" ) << '.';
-            }
-            else if( totals.assertions.total() == 0 ) {
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.total() )
-                              << pluralise( totals.testCases.total(), "test case" )
-                              << " (no assertions).";
-            }
-            else if( totals.assertions.failed ) {
-                Colour colour( Colour::ResultError );
-                stream <<
-                    "Failed " << pluralise( totals.testCases.failed, "test case"  ) << ", "
-                    "failed " << pluralise( totals.assertions.failed, "assertion" ) << '.';
-            }
-            else {
-                Colour colour( Colour::ResultSuccess );
-                stream <<
-                    "Passed " << bothOrAll( totals.testCases.passed )
-                              << pluralise( totals.testCases.passed, "test case"  ) <<
-                    " with "  << pluralise( totals.assertions.passed, "assertion" ) << '.';
-            }
+    void print() const {
+        printSourceInfo();
+        if (stats.totals.assertions.total() > 0) {
+            printResultType();
+            printOriginalExpression();
+            printReconstructedExpression();
+        } else {
+            stream << '\n';
         }
+        printMessage();
+    }
+
+private:
+    void printResultType() const {
+        if (!passOrFail.empty()) {
+            Colour colourGuard(colour);
+            stream << passOrFail << ":\n";
+        }
+    }
+    void printOriginalExpression() const {
+        if (result.hasExpression()) {
+            Colour colourGuard(Colour::OriginalExpression);
+            stream << "  ";
+            stream << result.getExpressionInMacro();
+            stream << '\n';
+        }
+    }
+    void printReconstructedExpression() const {
+        if (result.hasExpandedExpression()) {
+            stream << "with expansion:\n";
+            Colour colourGuard(Colour::ReconstructedExpression);
+            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
+        }
+    }
+    void printMessage() const {
+        if (!messageLabel.empty())
+            stream << messageLabel << ':' << '\n';
+        for (auto const& msg : messages) {
+            // If this assertion is a warning ignore any INFO messages
+            if (printInfoMessages || msg.type != ResultWas::Info)
+                stream << Column(msg.message).indent(2) << '\n';
+        }
+    }
+    void printSourceInfo() const {
+        Colour colourGuard(Colour::FileName);
+        stream << result.getSourceInfo() << ": ";
+    }
+
+    std::ostream& stream;
+    AssertionStats const& stats;
+    AssertionResult const& result;
+    Colour::Code colour;
+    std::string passOrFail;
+    std::string messageLabel;
+    std::string message;
+    std::vector<MessageInfo> messages;
+    bool printInfoMessages;
+};
+
+std::size_t makeRatio(std::size_t number, std::size_t total) {
+    std::size_t ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+    return (ratio == 0 && number > 0) ? 1 : ratio;
+}
+
+std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
+    if (i > j && i > k)
+        return i;
+    else if (j > k)
+        return j;
+    else
+        return k;
+}
+
+struct ColumnInfo {
+    enum Justification { Left, Right };
+    std::string name;
+    int width;
+    Justification justification;
+};
+struct ColumnBreak {};
+struct RowBreak {};
+
+class Duration {
+    enum class Unit {
+        Auto,
+        Nanoseconds,
+        Microseconds,
+        Milliseconds,
+        Seconds,
+        Minutes
     };
+    static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+    static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+    static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+    static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
 
-    INTERNAL_CATCH_REGISTER_REPORTER( "compact", CompactReporter )
+    double m_inNanoseconds;
+    Unit m_units;
+
+public:
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+        : m_inNanoseconds(inNanoseconds),
+        m_units(units) {
+        if (m_units == Unit::Auto) {
+            if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+                m_units = Unit::Nanoseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+                m_units = Unit::Microseconds;
+            else if (m_inNanoseconds < s_nanosecondsInASecond)
+                m_units = Unit::Milliseconds;
+            else if (m_inNanoseconds < s_nanosecondsInAMinute)
+                m_units = Unit::Seconds;
+            else
+                m_units = Unit::Minutes;
+        }
+
+    }
+
+    auto value() const -> double {
+        switch (m_units) {
+        case Unit::Microseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+        case Unit::Milliseconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+        case Unit::Seconds:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+        case Unit::Minutes:
+            return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+        default:
+            return m_inNanoseconds;
+        }
+    }
+    auto unitsAsString() const -> std::string {
+        switch (m_units) {
+        case Unit::Nanoseconds:
+            return "ns";
+        case Unit::Microseconds:
+            return "us";
+        case Unit::Milliseconds:
+            return "ms";
+        case Unit::Seconds:
+            return "s";
+        case Unit::Minutes:
+            return "m";
+        default:
+            return "** internal error **";
+        }
+
+    }
+    friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+        return os << duration.value() << ' ' << duration.unitsAsString();
+    }
+};
+} // end anon namespace
+
+class TablePrinter {
+    std::ostream& m_os;
+    std::vector<ColumnInfo> m_columnInfos;
+    std::ostringstream m_oss;
+    int m_currentColumn = -1;
+    bool m_isOpen = false;
+
+public:
+    TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+    :   m_os( os ),
+        m_columnInfos( std::move( columnInfos ) ) {}
+
+    auto columnInfos() const -> std::vector<ColumnInfo> const& {
+        return m_columnInfos;
+    }
+
+    void open() {
+        if (!m_isOpen) {
+            m_isOpen = true;
+            *this << RowBreak();
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
+        }
+    }
+    void close() {
+        if (m_isOpen) {
+            *this << RowBreak();
+            m_os << std::endl;
+            m_isOpen = false;
+        }
+    }
+
+    template<typename T>
+    friend TablePrinter& operator << (TablePrinter& tp, T const& value) {
+        tp.m_oss << value;
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
+        auto colStr = tp.m_oss.str();
+        const auto strSize = colStr.size();
+        tp.m_oss.str("");
+        tp.open();
+        if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+            tp.m_currentColumn = -1;
+            tp.m_os << '\n';
+        }
+        tp.m_currentColumn++;
+
+        auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
+            : std::string();
+        if (colInfo.justification == ColumnInfo::Left)
+            tp.m_os << colStr << padding << ' ';
+        else
+            tp.m_os << padding << colStr << ' ';
+        return tp;
+    }
+
+    friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
+        if (tp.m_currentColumn > 0) {
+            tp.m_os << '\n';
+            tp.m_currentColumn = -1;
+        }
+        return tp;
+    }
+};
+
+ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
+    : StreamingReporterBase(config),
+    m_tablePrinter(new TablePrinter(config.stream(),
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
+ConsoleReporter::~ConsoleReporter() = default;
+
+std::string ConsoleReporter::getDescription() {
+    return "Reports test results as plain lines of text";
+}
+
+void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
+    stream << "No test cases matched '" << spec << '\'' << std::endl;
+}
+
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
+void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+
+bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+    AssertionResult const& result = _assertionStats.assertionResult;
+
+    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+    // Drop out if result was successful but we're not printing them.
+    if (!includeResults && result.getResultType() != ResultWas::Warning)
+        return false;
+
+    lazyPrint();
+
+    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
+    printer.print();
+    stream << std::endl;
+    return true;
+}
+
+void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
+    m_headerPrinted = false;
+    StreamingReporterBase::sectionStarting(_sectionInfo);
+}
+void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+    m_tablePrinter->close();
+    if (_sectionStats.missingAssertions) {
+        lazyPrint();
+        Colour colour(Colour::ResultError);
+        if (m_sectionStack.size() > 1)
+            stream << "\nNo assertions in section";
+        else
+            stream << "\nNo assertions in test case";
+        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
+    }
+    double dur = _sectionStats.durationInSeconds;
+    if (shouldShowDuration(*m_config, dur)) {
+        stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    }
+    if (m_headerPrinted) {
+        m_headerPrinted = false;
+    }
+    StreamingReporterBase::sectionEnded(_sectionStats);
+}
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
+
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
+
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
+
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+    }
+}
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
+    (*m_tablePrinter)
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
+}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+    m_tablePrinter->close();
+    StreamingReporterBase::testCaseEnded(_testCaseStats);
+    m_headerPrinted = false;
+}
+void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
+    if (currentGroupInfo.used) {
+        printSummaryDivider();
+        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
+        printTotals(_testGroupStats.totals);
+        stream << '\n' << std::endl;
+    }
+    StreamingReporterBase::testGroupEnded(_testGroupStats);
+}
+void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+    printTotalsDivider(_testRunStats.totals);
+    printTotals(_testRunStats.totals);
+    stream << std::endl;
+    StreamingReporterBase::testRunEnded(_testRunStats);
+}
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
+
+void ConsoleReporter::lazyPrint() {
+
+    m_tablePrinter->close();
+    lazyPrintWithoutClosingBenchmarkTable();
+}
+
+void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+
+    if (!currentTestRunInfo.used)
+        lazyPrintRunInfo();
+    if (!currentGroupInfo.used)
+        lazyPrintGroupInfo();
+
+    if (!m_headerPrinted) {
+        printTestCaseAndSectionHeader();
+        m_headerPrinted = true;
+    }
+}
+void ConsoleReporter::lazyPrintRunInfo() {
+    stream << '\n' << getLineOfChars<'~'>() << '\n';
+    Colour colour(Colour::SecondaryText);
+    stream << currentTestRunInfo->name
+        << " is a Catch v" << libraryVersion() << " host application.\n"
+        << "Run with -? for options\n\n";
+
+    if (m_config->rngSeed() != 0)
+        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";
+
+    currentTestRunInfo.used = true;
+}
+void ConsoleReporter::lazyPrintGroupInfo() {
+    if (!currentGroupInfo->name.empty() && currentGroupInfo->groupsCounts > 1) {
+        printClosedHeader("Group: " + currentGroupInfo->name);
+        currentGroupInfo.used = true;
+    }
+}
+void ConsoleReporter::printTestCaseAndSectionHeader() {
+    assert(!m_sectionStack.empty());
+    printOpenHeader(currentTestCaseInfo->name);
+
+    if (m_sectionStack.size() > 1) {
+        Colour colourGuard(Colour::Headers);
+
+        auto
+            it = m_sectionStack.begin() + 1, // Skip first section (test case)
+            itEnd = m_sectionStack.end();
+        for (; it != itEnd; ++it)
+            printHeaderString(it->name, 2);
+    }
+
+    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
+    stream << getLineOfChars<'.'>() << '\n' << std::endl;
+}
+
+void ConsoleReporter::printClosedHeader(std::string const& _name) {
+    printOpenHeader(_name);
+    stream << getLineOfChars<'.'>() << '\n';
+}
+void ConsoleReporter::printOpenHeader(std::string const& _name) {
+    stream << getLineOfChars<'-'>() << '\n';
+    {
+        Colour colourGuard(Colour::Headers);
+        printHeaderString(_name);
+    }
+}
+
+// if string has a : in first line will set indent to follow it on
+// subsequent lines
+void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+    std::size_t i = _string.find(": ");
+    if (i != std::string::npos)
+        i += 2;
+    else
+        i = 0;
+    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
+}
+
+struct SummaryColumn {
+
+    SummaryColumn( std::string _label, Colour::Code _colour )
+    :   label( std::move( _label ) ),
+        colour( _colour ) {}
+    SummaryColumn addRow( std::size_t count ) {
+        ReusableStringStream rss;
+        rss << count;
+        std::string row = rss.str();
+        for (auto& oldRow : rows) {
+            while (oldRow.size() < row.size())
+                oldRow = ' ' + oldRow;
+            while (oldRow.size() > row.size())
+                row = ' ' + row;
+        }
+        rows.push_back(row);
+        return *this;
+    }
+
+    std::string label;
+    Colour::Code colour;
+    std::vector<std::string> rows;
+
+};
+
+void ConsoleReporter::printTotals( Totals const& totals ) {
+    if (totals.testCases.total() == 0) {
+        stream << Colour(Colour::Warning) << "No tests ran\n";
+    } else if (totals.assertions.total() > 0 && totals.testCases.allPassed()) {
+        stream << Colour(Colour::ResultSuccess) << "All tests passed";
+        stream << " ("
+            << pluralise(totals.assertions.passed, "assertion") << " in "
+            << pluralise(totals.testCases.passed, "test case") << ')'
+            << '\n';
+    } else {
+
+        std::vector<SummaryColumn> columns;
+        columns.push_back(SummaryColumn("", Colour::None)
+                          .addRow(totals.testCases.total())
+                          .addRow(totals.assertions.total()));
+        columns.push_back(SummaryColumn("passed", Colour::Success)
+                          .addRow(totals.testCases.passed)
+                          .addRow(totals.assertions.passed));
+        columns.push_back(SummaryColumn("failed", Colour::ResultError)
+                          .addRow(totals.testCases.failed)
+                          .addRow(totals.assertions.failed));
+        columns.push_back(SummaryColumn("failed as expected", Colour::ResultExpectedFailure)
+                          .addRow(totals.testCases.failedButOk)
+                          .addRow(totals.assertions.failedButOk));
+
+        printSummaryRow("test cases", columns, 0);
+        printSummaryRow("assertions", columns, 1);
+    }
+}
+void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
+    for (auto col : cols) {
+        std::string value = col.rows[row];
+        if (col.label.empty()) {
+            stream << label << ": ";
+            if (value != "0")
+                stream << value;
+            else
+                stream << Colour(Colour::Warning) << "- none -";
+        } else if (value != "0") {
+            stream << Colour(Colour::LightGrey) << " | ";
+            stream << Colour(col.colour)
+                << value << ' ' << col.label;
+        }
+    }
+    stream << '\n';
+}
+
+void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+    if (totals.testCases.total() > 0) {
+        std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+        std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+        std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+        while (failedRatio + failedButOkRatio + passedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)++;
+        while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+            findMax(failedRatio, failedButOkRatio, passedRatio)--;
+
+        stream << Colour(Colour::Error) << std::string(failedRatio, '=');
+        stream << Colour(Colour::ResultExpectedFailure) << std::string(failedButOkRatio, '=');
+        if (totals.testCases.allPassed())
+            stream << Colour(Colour::ResultSuccess) << std::string(passedRatio, '=');
+        else
+            stream << Colour(Colour::Success) << std::string(passedRatio, '=');
+    } else {
+        stream << Colour(Colour::Warning) << std::string(CATCH_CONFIG_CONSOLE_WIDTH - 1, '=');
+    }
+    stream << '\n';
+}
+void ConsoleReporter::printSummaryDivider() {
+    stream << getLineOfChars<'-'>() << '\n';
+}
+
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
+CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 
 } // end namespace Catch
 
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
+// end catch_reporter_console.cpp
+// start catch_reporter_junit.cpp
+
+#include <cassert>
+#include <sstream>
+#include <ctime>
+#include <algorithm>
+#include <iomanip>
+
 namespace Catch {
-    // These are all here to avoid warnings about not having any out of line
-    // virtual methods
-    NonCopyable::~NonCopyable() {}
-    IShared::~IShared() {}
-    IStream::~IStream() CATCH_NOEXCEPT {}
-    FileStream::~FileStream() CATCH_NOEXCEPT {}
-    CoutStream::~CoutStream() CATCH_NOEXCEPT {}
-    DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
-    StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
-    IContext::~IContext() {}
-    IResultCapture::~IResultCapture() {}
-    ITestCase::~ITestCase() {}
-    ITestCaseRegistry::~ITestCaseRegistry() {}
-    IRegistryHub::~IRegistryHub() {}
-    IMutableRegistryHub::~IMutableRegistryHub() {}
-    IExceptionTranslator::~IExceptionTranslator() {}
-    IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() {}
-    IReporter::~IReporter() {}
-    IReporterFactory::~IReporterFactory() {}
-    IReporterRegistry::~IReporterRegistry() {}
-    IStreamingReporter::~IStreamingReporter() {}
-    AssertionStats::~AssertionStats() {}
-    SectionStats::~SectionStats() {}
-    TestCaseStats::~TestCaseStats() {}
-    TestGroupStats::~TestGroupStats() {}
-    TestRunStats::~TestRunStats() {}
-    CumulativeReporterBase::SectionNode::~SectionNode() {}
-    CumulativeReporterBase::~CumulativeReporterBase() {}
 
-    StreamingReporterBase::~StreamingReporterBase() {}
-    ConsoleReporter::~ConsoleReporter() {}
-    CompactReporter::~CompactReporter() {}
-    IRunner::~IRunner() {}
-    IMutableContext::~IMutableContext() {}
-    IConfig::~IConfig() {}
-    XmlReporter::~XmlReporter() {}
+    namespace {
+        std::string getCurrentTimestamp() {
+            // Beware, this is not reentrant because of backward compatibility issues
+            // Also, UTC only, again because of backward compatibility (%z is C++11)
+            time_t rawtime;
+            std::time(&rawtime);
+            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+
+#ifdef _MSC_VER
+            std::tm timeInfo = {};
+            gmtime_s(&timeInfo, &rawtime);
+#else
+            std::tm* timeInfo;
+            timeInfo = std::gmtime(&rawtime);
+#endif
+
+            char timeStamp[timeStampSize];
+            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+
+#ifdef _MSC_VER
+            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+#else
+            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+#endif
+            return std::string(timeStamp, timeStampSize-1);
+        }
+
+        std::string fileNameTag(const std::vector<std::string> &tags) {
+            auto it = std::find_if(begin(tags),
+                                   end(tags),
+                                   [] (std::string const& tag) {return tag.front() == '#'; });
+            if (it != tags.end())
+                return it->substr(1);
+            return std::string();
+        }
+
+        // Formats the duration in seconds to 3 decimal places.
+        // This is done because some genius defined Maven Surefire schema
+        // in a way that only accepts 3 decimal places, and tools like
+        // Jenkins use that schema for validation JUnit reporter output.
+        std::string formatDuration( double seconds ) {
+            ReusableStringStream rss;
+            rss << std::fixed << std::setprecision( 3 ) << seconds;
+            return rss.str();
+        }
+
+    } // anonymous namespace
+
+    JunitReporter::JunitReporter( ReporterConfig const& _config )
+        :   CumulativeReporterBase( _config ),
+            xml( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
+        }
+
     JunitReporter::~JunitReporter() {}
-    TestRegistry::~TestRegistry() {}
-    FreeFunctionTestCase::~FreeFunctionTestCase() {}
-    IGeneratorInfo::~IGeneratorInfo() {}
-    IGeneratorsForTest::~IGeneratorsForTest() {}
-    WildcardPattern::~WildcardPattern() {}
-    TestSpec::Pattern::~Pattern() {}
-    TestSpec::NamePattern::~NamePattern() {}
-    TestSpec::TagPattern::~TagPattern() {}
-    TestSpec::ExcludedPattern::~ExcludedPattern() {}
-    Matchers::Impl::MatcherUntypedBase::~MatcherUntypedBase() {}
 
-    void Config::dummy() {}
-
-    namespace TestCaseTracking {
-        ITracker::~ITracker() {}
-        TrackerBase::~TrackerBase() {}
-        SectionTracker::~SectionTracker() {}
-        IndexTracker::~IndexTracker() {}
+    std::string JunitReporter::getDescription() {
+        return "Reports test results in an XML format that looks like Ant's junitreport target";
     }
+
+    void JunitReporter::noMatchingTestCases( std::string const& /*spec*/ ) {}
+
+    void JunitReporter::testRunStarting( TestRunInfo const& runInfo )  {
+        CumulativeReporterBase::testRunStarting( runInfo );
+        xml.startElement( "testsuites" );
+    }
+
+    void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        suiteTimer.start();
+        stdOutForSuite.clear();
+        stdErrForSuite.clear();
+        unexpectedExceptions = 0;
+        CumulativeReporterBase::testGroupStarting( groupInfo );
+    }
+
+    void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+        m_okToFail = testCaseInfo.okToFail();
+    }
+
+    bool JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+            unexpectedExceptions++;
+        return CumulativeReporterBase::assertionEnded( assertionStats );
+    }
+
+    void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        stdOutForSuite += testCaseStats.stdOut;
+        stdErrForSuite += testCaseStats.stdErr;
+        CumulativeReporterBase::testCaseEnded( testCaseStats );
+    }
+
+    void JunitReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        double suiteTime = suiteTimer.getElapsedSeconds();
+        CumulativeReporterBase::testGroupEnded( testGroupStats );
+        writeGroup( *m_testGroups.back(), suiteTime );
+    }
+
+    void JunitReporter::testRunEndedCumulative() {
+        xml.endElement();
+    }
+
+    void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
+        XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
+        TestGroupStats const& stats = groupNode.value;
+        xml.writeAttribute( "name", stats.groupInfo.name );
+        xml.writeAttribute( "errors", unexpectedExceptions );
+        xml.writeAttribute( "failures", stats.totals.assertions.failed-unexpectedExceptions );
+        xml.writeAttribute( "tests", stats.totals.assertions.total() );
+        xml.writeAttribute( "hostname", "tbd" ); // !TBD
+        if( m_config->showDurations() == ShowDurations::Never )
+            xml.writeAttribute( "time", "" );
+        else
+            xml.writeAttribute( "time", formatDuration( suiteTime ) );
+        xml.writeAttribute( "timestamp", getCurrentTimestamp() );
+
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
+        // Write test cases
+        for( auto const& child : groupNode.children )
+            writeTestCase( *child );
+
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+    }
+
+    void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+        TestCaseStats const& stats = testCaseNode.value;
+
+        // All test cases have exactly one section - which represents the
+        // test case itself. That section may have 0-n nested sections
+        assert( testCaseNode.children.size() == 1 );
+        SectionNode const& rootSection = *testCaseNode.children.front();
+
+        std::string className = stats.testInfo.className;
+
+        if( className.empty() ) {
+            className = fileNameTag(stats.testInfo.tags);
+            if ( className.empty() )
+                className = "global";
+        }
+
+        if ( !m_config->name().empty() )
+            className = m_config->name() + "." + className;
+
+        writeSection( className, "", rootSection, stats.testInfo.okToFail() );
+    }
+
+    void JunitReporter::writeSection( std::string const& className,
+                                      std::string const& rootName,
+                                      SectionNode const& sectionNode,
+                                      bool testOkToFail) {
+        std::string name = trim( sectionNode.stats.sectionInfo.name );
+        if( !rootName.empty() )
+            name = rootName + '/' + name;
+
+        if( !sectionNode.assertions.empty() ||
+            !sectionNode.stdOut.empty() ||
+            !sectionNode.stdErr.empty() ) {
+            XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+            if( className.empty() ) {
+                xml.writeAttribute( "classname", name );
+                xml.writeAttribute( "name", "root" );
+            }
+            else {
+                xml.writeAttribute( "classname", className );
+                xml.writeAttribute( "name", name );
+            }
+            xml.writeAttribute( "time", formatDuration( sectionNode.stats.durationInSeconds ) );
+            // This is not ideal, but it should be enough to mimic gtest's
+            // junit output.
+            // Ideally the JUnit reporter would also handle `skipTest`
+            // events and write those out appropriately.
+            xml.writeAttribute( "status", "run" );
+
+            if (sectionNode.stats.assertions.failedButOk) {
+                xml.scopedElement("skipped")
+                    .writeAttribute("message", "TEST_CASE tagged with !mayfail");
+            }
+
+            writeAssertions( sectionNode );
+
+            if( !sectionNode.stdOut.empty() )
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+            if( !sectionNode.stdErr.empty() )
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+        }
+        for( auto const& childNode : sectionNode.childSections )
+            if( className.empty() )
+                writeSection( name, "", *childNode, testOkToFail );
+            else
+                writeSection( className, name, *childNode, testOkToFail );
+    }
+
+    void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+        for( auto const& assertion : sectionNode.assertions )
+            writeAssertion( assertion );
+    }
+
+    void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+        AssertionResult const& result = stats.assertionResult;
+        if( !result.isOk() ) {
+            std::string elementName;
+            switch( result.getResultType() ) {
+                case ResultWas::ThrewException:
+                case ResultWas::FatalErrorCondition:
+                    elementName = "error";
+                    break;
+                case ResultWas::ExplicitFailure:
+                case ResultWas::ExpressionFailed:
+                case ResultWas::DidntThrowException:
+                    elementName = "failure";
+                    break;
+
+                // We should never see these here:
+                case ResultWas::Info:
+                case ResultWas::Warning:
+                case ResultWas::Ok:
+                case ResultWas::Unknown:
+                case ResultWas::FailureBit:
+                case ResultWas::Exception:
+                    elementName = "internalError";
+                    break;
+            }
+
+            XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+
+            xml.writeAttribute( "message", result.getExpression() );
+            xml.writeAttribute( "type", result.getTestMacroName() );
+
+            ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
+            if( !result.getMessage().empty() )
+                rss << result.getMessage() << '\n';
+            for( auto const& msg : stats.infoMessages )
+                if( msg.type == ResultWas::Info )
+                    rss << msg.message << '\n';
+
+            rss << "at " << result.getSourceInfo();
+            xml.writeText( rss.str(), XmlFormatting::Newline );
+        }
+    }
+
+    CATCH_REGISTER_REPORTER( "junit", JunitReporter )
+
+} // end namespace Catch
+// end catch_reporter_junit.cpp
+// start catch_reporter_listening.cpp
+
+#include <cassert>
+
+namespace Catch {
+
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
+    void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
+        m_listeners.push_back( std::move( listener ) );
+    }
+
+    void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
+        assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
+        m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
+    }
+
+    ReporterPreferences ListeningReporter::getPreferences() const {
+        return m_preferences;
+    }
+
+    std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
+        return std::set<Verbosity>{ };
+    }
+
+    void ListeningReporter::noMatchingTestCases( std::string const& spec ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->noMatchingTestCases( spec );
+        }
+        m_reporter->noMatchingTestCases( spec );
+    }
+
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
+    void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkStarting( benchmarkInfo );
+        }
+        m_reporter->benchmarkStarting( benchmarkInfo );
+    }
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->benchmarkEnded( benchmarkStats );
+        }
+        m_reporter->benchmarkEnded( benchmarkStats );
+    }
+
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunStarting( testRunInfo );
+        }
+        m_reporter->testRunStarting( testRunInfo );
+    }
+
+    void ListeningReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupStarting( groupInfo );
+        }
+        m_reporter->testGroupStarting( groupInfo );
+    }
+
+    void ListeningReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseStarting( testInfo );
+        }
+        m_reporter->testCaseStarting( testInfo );
+    }
+
+    void ListeningReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionStarting( sectionInfo );
+        }
+        m_reporter->sectionStarting( sectionInfo );
+    }
+
+    void ListeningReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->assertionStarting( assertionInfo );
+        }
+        m_reporter->assertionStarting( assertionInfo );
+    }
+
+    // The return value indicates if the messages buffer should be cleared:
+    bool ListeningReporter::assertionEnded( AssertionStats const& assertionStats ) {
+        for( auto const& listener : m_listeners ) {
+            static_cast<void>( listener->assertionEnded( assertionStats ) );
+        }
+        return m_reporter->assertionEnded( assertionStats );
+    }
+
+    void ListeningReporter::sectionEnded( SectionStats const& sectionStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->sectionEnded( sectionStats );
+        }
+        m_reporter->sectionEnded( sectionStats );
+    }
+
+    void ListeningReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testCaseEnded( testCaseStats );
+        }
+        m_reporter->testCaseEnded( testCaseStats );
+    }
+
+    void ListeningReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testGroupEnded( testGroupStats );
+        }
+        m_reporter->testGroupEnded( testGroupStats );
+    }
+
+    void ListeningReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->testRunEnded( testRunStats );
+        }
+        m_reporter->testRunEnded( testRunStats );
+    }
+
+    void ListeningReporter::skipTest( TestCaseInfo const& testInfo ) {
+        for ( auto const& listener : m_listeners ) {
+            listener->skipTest( testInfo );
+        }
+        m_reporter->skipTest( testInfo );
+    }
+
+    bool ListeningReporter::isMulti() const {
+        return true;
+    }
+
+} // end namespace Catch
+// end catch_reporter_listening.cpp
+// start catch_reporter_xml.cpp
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
+
+namespace Catch {
+    XmlReporter::XmlReporter( ReporterConfig const& _config )
+    :   StreamingReporterBase( _config ),
+        m_xml(_config.stream())
+    {
+        m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
+    }
+
+    XmlReporter::~XmlReporter() = default;
+
+    std::string XmlReporter::getDescription() {
+        return "Reports test results as an XML document";
+    }
+
+    std::string XmlReporter::getStylesheetRef() const {
+        return std::string();
+    }
+
+    void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+        m_xml
+            .writeAttribute( "filename", sourceInfo.file )
+            .writeAttribute( "line", sourceInfo.line );
+    }
+
+    void XmlReporter::noMatchingTestCases( std::string const& s ) {
+        StreamingReporterBase::noMatchingTestCases( s );
+    }
+
+    void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+        StreamingReporterBase::testRunStarting( testInfo );
+        std::string stylesheetRef = getStylesheetRef();
+        if( !stylesheetRef.empty() )
+            m_xml.writeStylesheetRef( stylesheetRef );
+        m_xml.startElement( "Catch" );
+        if( !m_config->name().empty() )
+            m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
+    }
+
+    void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
+        StreamingReporterBase::testGroupStarting( groupInfo );
+        m_xml.startElement( "Group" )
+            .writeAttribute( "name", groupInfo.name );
+    }
+
+    void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+        StreamingReporterBase::testCaseStarting(testInfo);
+        m_xml.startElement( "TestCase" )
+            .writeAttribute( "name", trim( testInfo.name ) )
+            .writeAttribute( "description", testInfo.description )
+            .writeAttribute( "tags", testInfo.tagsAsString() );
+
+        writeSourceInfo( testInfo.lineInfo );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            m_testCaseTimer.start();
+        m_xml.ensureTagClosed();
+    }
+
+    void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+        StreamingReporterBase::sectionStarting( sectionInfo );
+        if( m_sectionDepth++ > 0 ) {
+            m_xml.startElement( "Section" )
+                .writeAttribute( "name", trim( sectionInfo.name ) );
+            writeSourceInfo( sectionInfo.lineInfo );
+            m_xml.ensureTagClosed();
+        }
+    }
+
+    void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+
+    bool XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+
+        AssertionResult const& result = assertionStats.assertionResult;
+
+        bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+
+        if( includeResults || result.getResultType() == ResultWas::Warning ) {
+            // Print any info messages in <Info> tags.
+            for( auto const& msg : assertionStats.infoMessages ) {
+                if( msg.type == ResultWas::Info && includeResults ) {
+                    m_xml.scopedElement( "Info" )
+                            .writeText( msg.message );
+                } else if ( msg.type == ResultWas::Warning ) {
+                    m_xml.scopedElement( "Warning" )
+                            .writeText( msg.message );
+                }
+            }
+        }
+
+        // Drop out if result was successful but we're not printing them.
+        if( !includeResults && result.getResultType() != ResultWas::Warning )
+            return true;
+
+        // Print the expression if there is one.
+        if( result.hasExpression() ) {
+            m_xml.startElement( "Expression" )
+                .writeAttribute( "success", result.succeeded() )
+                .writeAttribute( "type", result.getTestMacroName() );
+
+            writeSourceInfo( result.getSourceInfo() );
+
+            m_xml.scopedElement( "Original" )
+                .writeText( result.getExpression() );
+            m_xml.scopedElement( "Expanded" )
+                .writeText( result.getExpandedExpression() );
+        }
+
+        // And... Print a result applicable to each result type.
+        switch( result.getResultType() ) {
+            case ResultWas::ThrewException:
+                m_xml.startElement( "Exception" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::FatalErrorCondition:
+                m_xml.startElement( "FatalErrorCondition" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            case ResultWas::Info:
+                m_xml.scopedElement( "Info" )
+                    .writeText( result.getMessage() );
+                break;
+            case ResultWas::Warning:
+                // Warning will already have been written
+                break;
+            case ResultWas::ExplicitFailure:
+                m_xml.startElement( "Failure" );
+                writeSourceInfo( result.getSourceInfo() );
+                m_xml.writeText( result.getMessage() );
+                m_xml.endElement();
+                break;
+            default:
+                break;
+        }
+
+        if( result.hasExpression() )
+            m_xml.endElement();
+
+        return true;
+    }
+
+    void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+        StreamingReporterBase::sectionEnded( sectionStats );
+        if( --m_sectionDepth > 0 ) {
+            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+            e.writeAttribute( "successes", sectionStats.assertions.passed );
+            e.writeAttribute( "failures", sectionStats.assertions.failed );
+            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );
+
+            if ( m_config->showDurations() == ShowDurations::Always )
+                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );
+
+            m_xml.endElement();
+        }
+    }
+
+    void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+        StreamingReporterBase::testCaseEnded( testCaseStats );
+        XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+        e.writeAttribute( "success", testCaseStats.totals.assertions.allOk() );
+
+        if ( m_config->showDurations() == ShowDurations::Always )
+            e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
+
+        if( !testCaseStats.stdOut.empty() )
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
+        if( !testCaseStats.stdErr.empty() )
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
+
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testGroupEnded( TestGroupStats const& testGroupStats ) {
+        StreamingReporterBase::testGroupEnded( testGroupStats );
+        // TODO: Check testGroupStats.aborting and act accordingly.
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
+            .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes", testGroupStats.totals.testCases.passed )
+            .writeAttribute( "failures", testGroupStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.testCases.failedButOk );
+        m_xml.endElement();
+    }
+
+    void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+        StreamingReporterBase::testRunEnded( testRunStats );
+        m_xml.scopedElement( "OverallResults" )
+            .writeAttribute( "successes", testRunStats.totals.assertions.passed )
+            .writeAttribute( "failures", testRunStats.totals.assertions.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes", testRunStats.totals.testCases.passed )
+            .writeAttribute( "failures", testRunStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.testCases.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
+        m_xml.endElement();
+    }
+
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    CATCH_REGISTER_REPORTER( "xml", XmlReporter )
+
+} // end namespace Catch
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+// end catch_reporter_xml.cpp
+
+namespace Catch {
+    LeakDetector leakDetector;
 }
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
+// end catch_impl.hpp
 #endif
 
 #ifdef CATCH_CONFIG_MAIN
-// #included from: internal/catch_default_main.hpp
-#define TWOBLUECUBES_CATCH_DEFAULT_MAIN_HPP_INCLUDED
+// start catch_default_main.hpp
 
 #ifndef __OBJC__
 
-#if defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
 // Standard C/C++ Win32 Unicode wmain entry point
 extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 #else
@@ -11466,8 +17530,7 @@ extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 int main (int argc, char * argv[]) {
 #endif
 
-    int result = Catch::Session().run( argc, argv );
-    return ( result < 0xff ? result : 0xff );
+    return Catch::Session().run( argc, argv );
 }
 
 #else // __OBJC__
@@ -11479,197 +17542,413 @@ int main (int argc, char * const argv[]) {
 #endif
 
     Catch::registerTestMethods();
-    int result = Catch::Session().run( argc, (char* const*)argv );
+    int result = Catch::Session().run( argc, (char**)argv );
 
 #if !CATCH_ARC_ENABLED
     [pool drain];
 #endif
 
-    return ( result < 0xff ? result : 0xff );
+    return result;
 }
 
 #endif // __OBJC__
 
+// end catch_default_main.hpp
 #endif
 
+#if !defined(CATCH_CONFIG_IMPL_ONLY)
+
 #ifdef CLARA_CONFIG_MAIN_NOT_DEFINED
 #  undef CLARA_CONFIG_MAIN
 #endif
 
+#if !defined(CATCH_CONFIG_DISABLE)
 //////
-
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
-#else
-#define CATCH_REQUIRE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr  )
-#endif
+#define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
 
-#define CATCH_REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#define CATCH_REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 
-#define CATCH_CHECK( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
-#define CATCH_CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+#define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
 
-#define CATCH_CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#define CATCH_CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#else
 #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
-#define CATCH_SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
 
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
-    #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
-    #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
-    #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
-    #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
-    #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
-    #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
-    #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
-    #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+#define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+#define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+#define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
 #else
-    #define CATCH_TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define CATCH_TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define CATCH_METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define CATCH_REGISTER_TEST_CASE( function, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( function, name, description )
-    #define CATCH_SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define CATCH_FAIL( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
-    #define CATCH_FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
-    #define CATCH_SUCCEED( msg ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
 #endif
-#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
-#define CATCH_REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define CATCH_REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define CATCH_GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
 
 // "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define CATCH_SCENARIO( name, tags ) CATCH_TEST_CASE( "Scenario: " name, tags )
-#define CATCH_SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc, "" )
-#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc, "" )
-#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
-#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc, "" )
-#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc, "" )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(C_A_T_C_H_B_E_N_C_H_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(C_A_T_C_H_B_E_N_C_H_), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define REQUIRE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE", Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST_NO_TRY( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
+#define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__  )
+#define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
 
-#else
-#define REQUIRE( expr ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, expr  )
-#define REQUIRE_FALSE( expr ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, expr )
-#endif
-
-#define REQUIRE_THROWS( expr ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", expr )
+#define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
-#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
-#define REQUIRE_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, expr )
+#define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 
-#define CHECK( expr ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_FALSE( expr ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, expr )
-#define CHECKED_IF( expr ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECKED_ELSE( expr ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_NOFAIL( expr ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, expr )
+#define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+#define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
 
-#define CHECK_THROWS( expr )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", expr )
+#define CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
-#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
-#define CHECK_NOTHROW( expr ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, expr )
+#define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
-#define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT_NO_TRY( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#else
 #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
-#endif
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define SCOPED_INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
-#define SCOPED_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << Catch::toString(msg) )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
 
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #else
-#define TEST_CASE( name, description ) INTERNAL_CATCH_TESTCASE( name, description )
-    #define TEST_CASE_METHOD( className, name, description ) INTERNAL_CATCH_TEST_CASE_METHOD( className, name, description )
-    #define METHOD_AS_TEST_CASE( method, name, description ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, name, description )
-    #define REGISTER_TEST_CASE( method, name, description ) INTERNAL_CATCH_REGISTER_TESTCASE( method, name, description )
-    #define SECTION( name, description ) INTERNAL_CATCH_SECTION( name, description )
-    #define FAIL( msg ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, msg )
-    #define FAIL_CHECK( msg ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, msg )
-    #define SUCCEED( msg ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, msg )
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
 #endif
-#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE( "", "" )
 
-#define REGISTER_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_REPORTER( name, reporterType )
-#define REGISTER_LEGACY_REPORTER( name, reporterType ) INTERNAL_CATCH_REGISTER_LEGACY_REPORTER( name, reporterType )
-
-#define GENERATE( expr) INTERNAL_CATCH_GENERATE( expr )
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
 
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
 
 // "BDD-style" convenience wrappers
-#ifdef CATCH_CONFIG_VARIADIC_MACROS
 #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#else
-#define SCENARIO( name, tags ) TEST_CASE( "Scenario: " name, tags )
-#define SCENARIO_METHOD( className, name, tags ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " name, tags )
-#endif
-#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc, "" )
-#define WHEN( desc )     SECTION( std::string("    When: ") + desc, "" )
-#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc, "" )
-#define THEN( desc )     SECTION( std::string("    Then: ") + desc, "" )
-#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc, "" )
+
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(C_A_T_C_H_B_E_N_C_H_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(C_A_T_C_H_B_E_N_C_H_), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 using Catch::Detail::Approx;
 
-// #included from: internal/catch_reenable_warnings.h
+#else // CATCH_CONFIG_DISABLE
+
+//////
+// If this config identifier is defined then all CATCH macros are prefixed with CATCH_
+#ifdef CATCH_CONFIG_PREFIX_ALL
+
+#define CATCH_REQUIRE( ... )        (void)(0)
+#define CATCH_REQUIRE_FALSE( ... )  (void)(0)
+
+#define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+#define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_REQUIRE_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif// CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CATCH_CHECK( ... )         (void)(0)
+#define CATCH_CHECK_FALSE( ... )   (void)(0)
+#define CATCH_CHECKED_IF( ... )    if (__VA_ARGS__)
+#define CATCH_CHECKED_ELSE( ... )  if (!(__VA_ARGS__))
+#define CATCH_CHECK_NOFAIL( ... )  (void)(0)
+
+#define CATCH_CHECK_THROWS( ... )  (void)(0)
+#define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CATCH_CHECK_THROWS_WITH( expr, matcher )     (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CATCH_CHECK_THAT( arg, matcher )   (void)(0)
+
+#define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
+
+#define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+#define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+#define CATCH_METHOD_AS_TEST_CASE( method, ... )
+#define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
+#define CATCH_FAIL( ... ) (void)(0)
+#define CATCH_FAIL_CHECK( ... ) (void)(0)
+#define CATCH_SUCCEED( ... ) (void)(0)
+
+#define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+// "BDD-style" convenience wrappers
+#define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+#define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), className )
+#define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
+#define CATCH_WHEN( desc )
+#define CATCH_AND_WHEN( desc )
+#define CATCH_THEN( desc )
+#define CATCH_AND_THEN( desc )
+
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+// If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
+#else
+
+#define REQUIRE( ... )       (void)(0)
+#define REQUIRE_FALSE( ... ) (void)(0)
+
+#define REQUIRE_THROWS( ... ) (void)(0)
+#define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+#define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define REQUIRE_NOTHROW( ... ) (void)(0)
+
+#define CHECK( ... ) (void)(0)
+#define CHECK_FALSE( ... ) (void)(0)
+#define CHECKED_IF( ... ) if (__VA_ARGS__)
+#define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+#define CHECK_NOFAIL( ... ) (void)(0)
+
+#define CHECK_THROWS( ... )  (void)(0)
+#define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+#define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+#define CHECK_NOTHROW( ... ) (void)(0)
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+#define CHECK_THAT( arg, matcher ) (void)(0)
+
+#define REQUIRE_THAT( arg, matcher ) (void)(0)
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+#define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
+#define WARN( msg ) (void)(0)
+#define CAPTURE( msg ) (void)(0)
+
+#define TEST_CASE( ... )  INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+#define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+#define METHOD_AS_TEST_CASE( method, ... )
+#define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+#define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
+#define FAIL( ... ) (void)(0)
+#define FAIL_CHECK( ... ) (void)(0)
+#define SUCCEED( ... ) (void)(0)
+#define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
+#endif
+
+#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+
+// "BDD-style" convenience wrappers
+#define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ) )
+#define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( C_A_T_C_H_T_E_S_T_ ), className )
+
+#define GIVEN( desc )
+#define AND_GIVEN( desc )
+#define WHEN( desc )
+#define AND_WHEN( desc )
+#define THEN( desc )
+#define AND_THEN( desc )
+
+using Catch::Detail::Approx;
+
+#endif
+
+#endif // ! CATCH_CONFIG_IMPL_ONLY
+
+// start catch_reenable_warnings.h
 
-#define TWOBLUECUBES_CATCH_REENABLE_WARNINGS_H_INCLUDED
 
 #ifdef __clang__
 #    ifdef __ICC // icpc defines the __clang__ macro
@@ -11681,5 +17960,7 @@ using Catch::Detail::Approx;
 #    pragma GCC diagnostic pop
 #endif
 
+// end catch_reenable_warnings.h
+// end catch.hpp
 #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
 
diff --git a/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp b/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
index d3b4c0e41..1934d14ba 100644
--- a/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-multipolygon.cpp
@@ -34,7 +34,7 @@ using tagmap_type = std::map<const char*, const char*, less_charptr>;
 tagmap_type create_map(const osmium::TagList& taglist) {
     tagmap_type map;
 
-    for (auto& tag : taglist) {
+    for (const auto& tag : taglist) {
         map[tag.key()] = tag.value();
     }
 
@@ -114,7 +114,7 @@ public:
 
             const auto tagmap = create_map(area.tags());
             bool first = true;
-            for (auto& tag : tagmap) {
+            for (const auto& tag : tagmap) {
                 if (first) {
                     first = false;
                 } else {
@@ -150,42 +150,49 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " INFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string output_format{"SQLite"};
-    const std::string input_filename{argv[1]};
-    const std::string output_filename{"multipolygon.db"};
+    try {
+        const std::string output_format{"SQLite"};
+        const std::string input_filename{argv[1]};
+        const std::string output_filename{"multipolygon.db"};
 
-    CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
-    gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{}, {"SPATIALITE=TRUE"}};
+        CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
+        gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{}, {"SPATIALITE=TRUE"}};
 
-    osmium::area::ProblemReporterOGR problem_reporter{dataset};
-    osmium::area::AssemblerLegacy::config_type assembler_config;
-    assembler_config.problem_reporter = &problem_reporter;
-    assembler_config.check_roles = true;
-    assembler_config.create_empty_areas = true;
-    assembler_config.debug_level = 2;
-    osmium::area::MultipolygonCollector<osmium::area::AssemblerLegacy> collector{assembler_config};
+        osmium::area::ProblemReporterOGR problem_reporter{dataset};
+        osmium::area::AssemblerLegacy::config_type assembler_config;
+        assembler_config.problem_reporter = &problem_reporter;
+        assembler_config.check_roles = true;
+        assembler_config.create_empty_areas = true;
+        assembler_config.debug_level = 2;
+        osmium::area::MultipolygonCollector<osmium::area::AssemblerLegacy> collector{assembler_config};
 
-    std::cerr << "Pass 1...\n";
-    osmium::io::Reader reader1{input_filename};
-    collector.read_relations(reader1);
-    reader1.close();
-    std::cerr << "Pass 1 done\n";
+        std::cerr << "Pass 1...\n";
+        osmium::io::Reader reader1{input_filename};
+        collector.read_relations(reader1);
+        reader1.close();
+        std::cerr << "Pass 1 done\n";
 
-    index_type index;
-    location_handler_type location_handler{index};
-    location_handler.ignore_errors();
+        index_type index;
+        location_handler_type location_handler{index};
+        location_handler.ignore_errors();
 
-    TestHandler test_handler{dataset};
+        TestHandler test_handler{dataset};
 
-    std::cerr << "Pass 2...\n";
-    osmium::io::Reader reader2{input_filename};
-    osmium::apply(reader2, location_handler, test_handler, collector.handler([&test_handler](const osmium::memory::Buffer& area_buffer) {
-        osmium::apply(area_buffer, test_handler);
-    }));
-    reader2.close();
-    std::cerr << "Pass 2 done\n";
+        std::cerr << "Pass 2...\n";
+        osmium::io::Reader reader2{input_filename};
+        osmium::apply(reader2, location_handler, test_handler, collector.handler([&test_handler](const osmium::memory::Buffer& area_buffer) {
+            osmium::apply(area_buffer, test_handler);
+        }));
+        reader2.close();
+        std::cerr << "Pass 2 done\n";
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/test/data-tests/testdata-overview.cpp b/third_party/libosmium/test/data-tests/testdata-overview.cpp
index 8c88f5b64..efaa24f1e 100644
--- a/third_party/libosmium/test/data-tests/testdata-overview.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-overview.cpp
@@ -76,26 +76,33 @@ public:
 int main(int argc, char* argv[]) {
     if (argc != 2) {
         std::cerr << "Usage: " << argv[0] << " INFILE\n";
-        std::exit(1);
+        return 1;
     }
 
-    const std::string output_format{"SQLite"};
-    const std::string input_filename{argv[1]};
-    const std::string output_filename{"testdata-overview.db"};
-    ::unlink(output_filename.c_str());
+    try {
+        const std::string output_format{"SQLite"};
+        const std::string input_filename{argv[1]};
+        const std::string output_filename{"testdata-overview.db"};
+        ::unlink(output_filename.c_str());
 
-    CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
-    gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{}, {"SPATIALITE=TRUE"}};
+        CPLSetConfigOption("OGR_SQLITE_SYNCHRONOUS", "FALSE");
+        gdalcpp::Dataset dataset{output_format, output_filename, gdalcpp::SRS{}, {"SPATIALITE=TRUE"}};
 
-    osmium::io::Reader reader{input_filename};
+        osmium::io::Reader reader{input_filename};
 
-    index_type index;
-    location_handler_type location_handler{index};
-    location_handler.ignore_errors();
+        index_type index;
+        location_handler_type location_handler{index};
+        location_handler.ignore_errors();
 
-    TestOverviewHandler handler{dataset};
+        TestOverviewHandler handler{dataset};
 
-    osmium::apply(reader, location_handler, handler);
-    reader.close();
+        osmium::apply(reader, location_handler, handler);
+        reader.close();
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/test/data-tests/testdata-testcases.cpp b/third_party/libosmium/test/data-tests/testdata-testcases.cpp
index 3c5f19e96..a4a684a9c 100644
--- a/third_party/libosmium/test/data-tests/testdata-testcases.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-testcases.cpp
@@ -6,7 +6,7 @@
 #include <iostream>
 #include <string>
 
-std::string dirname;
+std::string dirname; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 int main(int argc, char* argv[]) {
     const char* testcases_dir = getenv("TESTCASES_DIR");
@@ -15,9 +15,16 @@ int main(int argc, char* argv[]) {
         std::cerr << "Running tests from '" << dirname << "' (from TESTCASES_DIR environment variable)\n";
     } else {
         std::cerr << "Please set TESTCASES_DIR environment variable.\n";
-        std::exit(1);
+        return 1;
     }
 
-    return Catch::Session().run(argc, argv);
+    try {
+        return Catch::Session().run(argc, argv);
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << '\n';
+        return 1;
+    }
+
+    return 0;
 }
 
diff --git a/third_party/libosmium/test/data-tests/testdata-xml.cpp b/third_party/libosmium/test/data-tests/testdata-xml.cpp
index 16f78cba7..0bdbf92e2 100644
--- a/third_party/libosmium/test/data-tests/testdata-xml.cpp
+++ b/third_party/libosmium/test/data-tests/testdata-xml.cpp
@@ -21,11 +21,17 @@ static std::string S_(const char* s) {
     return std::string{s};
 }
 
+// From C++20 we need to handle unicode literals differently
+#ifdef __cpp_char8_t
+static std::string S_(const char8_t* s) {
+    return std::string{reinterpret_cast<const char*>(s)};
+}
+#endif
+
 static std::string filename(const char* test_id, const char* suffix = "osm") {
     const char* testdir = getenv("TESTDIR");
     if (!testdir) {
-        std::cerr << "You have to set TESTDIR environment variable before running testdata-xml\n";
-        std::exit(2);
+        throw std::runtime_error{"You have to set TESTDIR environment variable before running testdata-xml"};
     }
 
     std::string f;
@@ -55,7 +61,7 @@ static std::string read_file(const char* test_id) {
     assert(fd >= 0);
 
     std::string input(10000, '\0');
-    const auto n = ::read(fd, reinterpret_cast<unsigned char*>(const_cast<char*>(input.data())), 10000);
+    const auto n = ::read(fd, &*input.begin(), 10000);
     assert(n >= 0);
     input.resize(static_cast<std::string::size_type>(n));
 
@@ -69,13 +75,12 @@ static std::string read_gz_file(const char* test_id, const char* suffix) {
     assert(fd >= 0);
 
     osmium::io::GzipDecompressor gzip_decompressor{fd};
-    const std::string input = gzip_decompressor.read();
+    std::string input = gzip_decompressor.read();
     gzip_decompressor.close();
 
     return input;
 }
 
-// cppcheck-suppress passedByValue
 static header_buffer_type parse_xml(std::string input) {
     osmium::thread::Pool pool;
     osmium::io::detail::future_string_queue_type input_queue;
@@ -86,13 +91,19 @@ static header_buffer_type parse_xml(std::string input) {
     osmium::io::detail::add_to_queue(input_queue, std::move(input));
     osmium::io::detail::add_to_queue(input_queue, std::string{});
 
+    std::atomic<std::size_t> offset{0};
+
     osmium::io::detail::parser_arguments args = {
         pool,
+        -1,
         input_queue,
         output_queue,
         header_promise,
+        &offset,
         osmium::osm_entity_bits::all,
-        osmium::io::read_meta::yes
+        osmium::io::read_meta::yes,
+        osmium::io::buffers_type::any,
+        false
     };
     osmium::io::detail::XMLParser parser{args};
     parser.parse();
@@ -119,7 +130,7 @@ static header_buffer_type read_xml(const char* test_id) {
 
 template <typename TException>
 void test_fail(const char* xml_file_name, const char* errmsg) {
-    REQUIRE_THROWS_AS(read_xml(xml_file_name), const TException&);
+    REQUIRE_THROWS_AS(read_xml(xml_file_name), TException);
     REQUIRE_THROWS_WITH(read_xml(xml_file_name), errmsg);
 
     REQUIRE_THROWS_AS([&](){
@@ -127,7 +138,7 @@ void test_fail(const char* xml_file_name, const char* errmsg) {
         const osmium::io::Header header{reader.header()};
         osmium::memory::Buffer buffer = reader.read();
         reader.close();
-    }(), const TException&);
+    }(), TException);
 }
 
 // =============================================
@@ -282,7 +293,7 @@ TEST_CASE("Reading OSM XML 120: Using Reader") {
 // =============================================
 
 TEST_CASE("Reading OSM XML 121: Direct") {
-    REQUIRE_THROWS_AS(read_gz_file("121-truncated_gzip_file", "osm.gz"), const osmium::gzip_error&);
+    REQUIRE_THROWS_AS(read_gz_file("121-truncated_gzip_file", "osm.gz"), osmium::gzip_error);
 }
 
 TEST_CASE("Reading OSM XML 121: Using Reader") {
@@ -357,28 +368,25 @@ TEST_CASE("Reading OSM XML 140: Using Reader") {
 
         REQUIRE(S_(uc) == t["unicode_xml"]);
 
-// workaround for missing support for u8 string literals on Windows
-#if !defined(_MSC_VER)
         switch (count) {
             case 1:
-                REQUIRE(S_(uc) == u8"a");
+                REQUIRE(S_(uc) == S_(u8"a"));
                 break;
             case 2:
-                REQUIRE(S_(uc) == u8"\u00e4");
+                REQUIRE(S_(uc) == S_(u8"\u00e4"));
                 break;
             case 3:
-                REQUIRE(S_(uc) == u8"\u30dc");
+                REQUIRE(S_(uc) == S_(u8"\u30dc"));
                 break;
             case 4:
-                REQUIRE(S_(uc) == u8"\U0001d11e");
+                REQUIRE(S_(uc) == S_(u8"\U0001d11e"));
                 break;
             case 5:
-                REQUIRE(S_(uc) == u8"\U0001f6eb");
+                REQUIRE(S_(uc) == S_(u8"\U0001f6eb"));
                 break;
             default:
                 REQUIRE(false); // should not be here
         }
-#endif
     }
     REQUIRE(count == 5);
 }
diff --git a/third_party/libosmium/test/examples/t/change_tags/CMakeLists.txt b/third_party/libosmium/test/examples/t/change_tags/CMakeLists.txt
index b054aa9be..614e1b170 100644
--- a/third_party/libosmium/test/examples/t/change_tags/CMakeLists.txt
+++ b/third_party/libosmium/test/examples/t/change_tags/CMakeLists.txt
@@ -5,5 +5,5 @@ add_test(NAME examples_change_tags
 add_test(NAME examples_change_tags_compare
          COMMAND ${CMAKE_COMMAND} -E compare_files ${CMAKE_CURRENT_SOURCE_DIR}/result.osm ${CMAKE_CURRENT_BINARY_DIR}/result.osm)
 
-set_tests_properties(examples_change_tags_compare PROPERTIES DEPENDS example_change_tags)
+set_tests_properties(examples_change_tags_compare PROPERTIES DEPENDS examples_change_tags)
 
diff --git a/third_party/libosmium/test/examples/t/change_tags/result.osm b/third_party/libosmium/test/examples/t/change_tags/result.osm
index 1898b8952..4f57180d0 100644
--- a/third_party/libosmium/test/examples/t/change_tags/result.osm
+++ b/third_party/libosmium/test/examples/t/change_tags/result.osm
@@ -1,5 +1,5 @@
 <?xml version='1.0' encoding='UTF-8'?>
-<osm version="0.6" generator="osmium_change_tags">
+<osm version="0.6" upload="false" generator="osmium_change_tags">
   <node id="10" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.01" lon="7.11"/>
   <node id="11" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.04" lon="7.11"/>
   <node id="12" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.04" lon="7.14"/>
diff --git a/third_party/libosmium/test/examples/t/road_length/road.osm b/third_party/libosmium/test/examples/t/road_length/road.osm
index 934ef46f7..d00581b77 100644
--- a/third_party/libosmium/test/examples/t/road_length/road.osm
+++ b/third_party/libosmium/test/examples/t/road_length/road.osm
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<osm version="0.6" generator="CGImap 0.3.3 (31041 thorn-01.openstreetmap.org)" copyright="OpenStreetMap and contributors" attribution="http://www.openstreetmap.org/copyright" license="http://opendatacommons.org/licenses/odbl/1-0/">
+<osm version="0.6" generator="CGImap 0.3.3 (31041 thorn-01.openstreetmap.org)" copyright="OpenStreetMap and contributors" attribution="https://www.openstreetmap.org/copyright" license="https://opendatacommons.org/licenses/odbl/1-0/">
  <node id="5599384" visible="true" version="5" changeset="829716" timestamp="2009-03-18T17:16:26Z" user="burts" uid="97529" lat="51.0271601" lon="13.7252197"/>
  <node id="250384970" visible="true" version="3" changeset="855544" timestamp="2009-01-30T21:58:37Z" user="saftl" uid="7989" lat="51.0288568" lon="13.7248159">
   <tag k="created_by" v="JOSM"/>
@@ -56,4 +56,4 @@
   <tag k="smoothness" v="good"/>
   <tag k="surface" v="asphalt"/>
  </way>
-</osm>
\ No newline at end of file
+</osm>
diff --git a/third_party/libosmium/test/include/test_crc.hpp b/third_party/libosmium/test/include/test_crc.hpp
new file mode 100644
index 000000000..a819042e6
--- /dev/null
+++ b/third_party/libosmium/test/include/test_crc.hpp
@@ -0,0 +1,18 @@
+#ifndef OSMIUM_TEST_CRC_HPP
+#define OSMIUM_TEST_CRC_HPP
+
+#ifdef OSMIUM_TEST_CRC_USE_BOOST
+
+/* Use the CRC32 implementation from boost. */
+#include <boost/crc.hpp>
+using crc_type = boost::crc_32_type;
+
+#else
+
+/* Use the CRC32 implementation from zlib. */
+#include <osmium/osm/crc_zlib.hpp>
+using crc_type = osmium::CRC_zlib;
+
+#endif
+
+#endif // OSMIUM_TEST_CRC_HPP
diff --git a/third_party/libosmium/test/include/utils.hpp b/third_party/libosmium/test/include/utils.hpp
index 662155abf..714a1cdb5 100644
--- a/third_party/libosmium/test/include/utils.hpp
+++ b/third_party/libosmium/test/include/utils.hpp
@@ -2,6 +2,30 @@
 #include <cstdlib>
 #include <string>
 
+#ifndef _WIN32
+# include <unistd.h>
+# include <fcntl.h>
+
+// This function counts the number of open file descriptors. It is used in
+// some tests to make sure that we are not leaking file descriptors.
+inline int count_fds() noexcept {
+    int count = 0;
+    for (int fd = 0; fd < 100; ++fd) {
+        if (fcntl(fd, F_GETFD) == 0) {
+            ++count;
+        }
+    }
+    return count;
+}
+
+#else
+// Dummy for Windows which doesn't have fcntl
+inline int count_fds() noexcept {
+    return 0;
+}
+#endif
+
+
 inline std::string with_data_dir(const char* filename) {
     const char* data_dir = getenv("OSMIUM_TEST_DATA_DIR");
 
diff --git a/third_party/libosmium/test/t/builder/test_attr.cpp b/third_party/libosmium/test/t/builder/test_attr.cpp
index e0385fe1d..f2f293bfe 100644
--- a/third_party/libosmium/test/t/builder/test_attr.cpp
+++ b/third_party/libosmium/test/t/builder/test_attr.cpp
@@ -7,231 +7,296 @@
 
 #include <cstdint>
 #include <initializer_list>
+#include <iterator>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
-TEST_CASE("create node using builders") {
+using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+constexpr const std::size_t test_buffer_size = 1024UL * 10UL;
 
-    osmium::memory::Buffer buffer{1024 * 10};
+TEST_CASE("create node using builders: add node with only id") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    SECTION("add node with only id") {
-        const auto pos = osmium::builder::add_node(buffer, _id(22));
+    const auto pos = osmium::builder::add_node(buffer, _id(22));
 
-        const auto& node = buffer.get<osmium::Node>(pos);
-
-        REQUIRE(node.id() == 22);
-        REQUIRE(node.version() == 0);
-        REQUIRE(node.timestamp() == osmium::Timestamp{});
-        REQUIRE(node.changeset() == 0);
-        REQUIRE(node.uid() == 0);
-        REQUIRE(std::string{node.user()}.empty());
-        REQUIRE(node.location() == osmium::Location{});
-        REQUIRE(node.tags().empty());
-    }
-
-    SECTION("add node with complete info but no tags") {
-        const osmium::Location loc{3.14, 1.59};
-        const auto pos = osmium::builder::add_node(buffer,
-            _id(1),
-            _version(17),
-            _timestamp(osmium::Timestamp{"2015-01-01T10:20:30Z"}),
-            _cid(21),
-            _uid(222),
-            _location(loc),
-            _user("foo")
-        );
-
-        const auto& node = buffer.get<osmium::Node>(pos);
-
-        REQUIRE(node.id() == 1);
-        REQUIRE(node.version() == 17);
-        REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
-        REQUIRE(node.changeset() == 21);
-        REQUIRE(node.uid() == 222);
-        REQUIRE(std::string{node.user()} == "foo");
-        REQUIRE(node.location() == loc);
-        REQUIRE(node.tags().empty());
-        REQUIRE(std::distance(node.cbegin(), node.cend()) == 0);
-    }
-
-    SECTION("visible/deleted flag") {
-        osmium::builder::add_node(buffer, _id(1), _deleted());
-        osmium::builder::add_node(buffer, _id(2), _deleted(true));
-        osmium::builder::add_node(buffer, _id(3), _deleted(false));
-        osmium::builder::add_node(buffer, _id(4), _visible());
-        osmium::builder::add_node(buffer, _id(5), _visible(true));
-        osmium::builder::add_node(buffer, _id(6), _visible(false));
-
-        auto it = buffer.select<osmium::Node>().cbegin();
-        REQUIRE_FALSE(it++->visible());
-        REQUIRE_FALSE(it++->visible());
-        REQUIRE(it++->visible());
-        REQUIRE(it++->visible());
-        REQUIRE(it++->visible());
-        REQUIRE_FALSE(it++->visible());
-        REQUIRE(it == buffer.select<osmium::Node>().cend());
-    }
-
-    SECTION("order of attributes doesn't matter") {
-        const osmium::Location loc{3.14, 1.59};
-        const auto pos = osmium::builder::add_node(buffer,
-            _timestamp("2015-01-01T10:20:30Z"),
-            _version(17),
-            _cid(21),
-            _uid(222),
-            _user(std::string{"foo"}),
-            _id(1),
-            _location(3.14, 1.59)
-        );
-
-        const auto& node = buffer.get<osmium::Node>(pos);
-
-        REQUIRE(node.id() == 1);
-        REQUIRE(node.version() == 17);
-        REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
-        REQUIRE(node.changeset() == 21);
-        REQUIRE(node.uid() == 222);
-        REQUIRE(std::string{node.user()} == "foo");
-        REQUIRE(node.location() == loc);
-        REQUIRE(node.tags().empty());
-    }
+    const auto& node = buffer.get<osmium::Node>(pos);
 
+    REQUIRE(node.id() == 22);
+    REQUIRE(node.version() == 0);
+    REQUIRE(node.timestamp() == osmium::Timestamp{});
+    REQUIRE(node.changeset() == 0);
+    REQUIRE(node.uid() == 0);
+    REQUIRE(node.user()[0] == '\0');
+    REQUIRE(node.location() == osmium::Location{});
+    REQUIRE(node.tags().empty());
 }
 
-TEST_CASE("create node with tags using builders") {
+TEST_CASE("create node using builders: add node with complete info but no tags") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+    const osmium::Location loc{3.14, 1.59};
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(1),
+        _version(17),
+        _timestamp(osmium::Timestamp{"2015-01-01T10:20:30Z"}),
+        _cid(21),
+        _uid(222),
+        _location(loc),
+        _user("foo")
+    );
 
-    osmium::memory::Buffer buffer{1024 * 10};
+    const auto& node = buffer.get<osmium::Node>(pos);
 
-    SECTION("add tags using _tag") {
-        std::pair<const char*, const char*> t1 = {"name", "Node Inn"};
-        std::pair<std::string, std::string> t2 = {"phone", "+1-123-555-4567"};
+    REQUIRE(node.id() == 1);
+    REQUIRE(node.version() == 17);
+    REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
+    REQUIRE(node.changeset() == 21);
+    REQUIRE(node.uid() == 222);
+    REQUIRE(std::string{node.user()} == "foo");
+    REQUIRE(node.location() == loc);
+    REQUIRE(node.tags().empty());
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 0);
+}
 
-        const auto pos = osmium::builder::add_node(buffer,
-            _id(2),
-            _tag("amenity", "restaurant"),
-            _tag(t1),
-            _tag(t2),
-            _tag(std::string{"cuisine"}, std::string{"italian"})
-        );
+TEST_CASE("create node using builders: visible/deleted flag") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-        const auto& node = buffer.get<osmium::Node>(pos);
+    osmium::builder::add_node(buffer, _id(1), _deleted());
+    osmium::builder::add_node(buffer, _id(2), _deleted(true));
+    osmium::builder::add_node(buffer, _id(3), _deleted(false));
+    osmium::builder::add_node(buffer, _id(4), _visible());
+    osmium::builder::add_node(buffer, _id(5), _visible(true));
+    osmium::builder::add_node(buffer, _id(6), _visible(false));
 
-        REQUIRE(node.id() == 2);
-        REQUIRE(node.tags().size() == 4);
-        REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
+    auto it = buffer.select<osmium::Node>().cbegin();
+    REQUIRE_FALSE(it++->visible());
+    REQUIRE_FALSE(it++->visible());
+    REQUIRE(it++->visible());
+    REQUIRE(it++->visible());
+    REQUIRE(it++->visible());
+    REQUIRE_FALSE(it++->visible());
+    REQUIRE(it == buffer.select<osmium::Node>().cend());
+}
 
-        auto it = node.tags().cbegin();
-        REQUIRE(std::string{it->key()} == "amenity");
-        REQUIRE(std::string{it->value()} == "restaurant");
-        ++it;
-        REQUIRE(std::string{it->key()} == "name");
-        REQUIRE(std::string{it->value()} == "Node Inn");
-        ++it;
-        REQUIRE(std::string{it->key()} == "phone");
-        REQUIRE(std::string{it->value()} == "+1-123-555-4567");
-        ++it;
-        REQUIRE(std::string{it->key()} == "cuisine");
-        REQUIRE(std::string{it->value()} == "italian");
-        ++it;
-        REQUIRE(it == node.tags().cend());
-    }
+TEST_CASE("create node using builders: order of attributes doesn't matter") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    SECTION("add tags using _tags from initializer list") {
-        const auto pos = osmium::builder::add_node(buffer,
-            _id(3),
-            _tags({{"amenity", "post_box"}})
-        );
+    const osmium::Location loc{3.14, 1.59};
+    const auto pos = osmium::builder::add_node(buffer,
+        _timestamp("2015-01-01T10:20:30Z"),
+        _version(17),
+        _cid(21),
+        _uid(222),
+        _user(std::string{"foo"}),
+        _id(1),
+        _location(3.14, 1.59)
+    );
 
-        const auto& node = buffer.get<osmium::Node>(pos);
+    const auto& node = buffer.get<osmium::Node>(pos);
 
-        REQUIRE(node.id() == 3);
-        REQUIRE(node.tags().size() == 1);
+    REQUIRE(node.id() == 1);
+    REQUIRE(node.version() == 17);
+    REQUIRE(node.timestamp() == osmium::Timestamp{"2015-01-01T10:20:30Z"});
+    REQUIRE(node.changeset() == 21);
+    REQUIRE(node.uid() == 222);
+    REQUIRE(std::string{node.user()} == "foo");
+    REQUIRE(node.location() == loc);
+    REQUIRE(node.tags().empty());
+}
 
-        auto it = node.tags().cbegin();
-        REQUIRE(std::string{it->key()} == "amenity");
-        REQUIRE(std::string{it->value()} == "post_box");
-        ++it;
-        REQUIRE(it == node.tags().cend());
-        REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
-    }
+TEST_CASE("create node with tags using builders: add tags using _tag") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    SECTION("add tags using _tags from TagList") {
-        const auto pos1 = osmium::builder::add_node(buffer,
-            _id(3),
-            _tag("a", "d"),
-            _tag("b", "e"),
-            _tag("c", "f")
-        );
+    std::pair<const char*, const char*> t1 = {"name", "Node Inn"};
+    std::pair<std::string, std::string> t2 = {"phone", "+1-123-555-4567"};
 
-        const auto& node1 = buffer.get<osmium::Node>(pos1);
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(2),
+        _tag("amenity", "restaurant"),
+        _tag(t1),
+        _tag(t2),
+        _tag(std::string{"cuisine"}, std::string{"italian"})
+    );
 
-        const auto pos2 = osmium::builder::add_node(buffer,
-            _id(4),
-            _tags(node1.tags())
-        );
+    const auto& node = buffer.get<osmium::Node>(pos);
 
-        const auto& node2 = buffer.get<osmium::Node>(pos2);
+    REQUIRE(node.id() == 2);
+    REQUIRE(node.tags().size() == 4);
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
 
-        REQUIRE(node2.id() == 4);
-        REQUIRE(node2.tags().size() == 3);
+    auto it = node.tags().cbegin();
+    REQUIRE(std::string{it->key()} == "amenity");
+    REQUIRE(std::string{it->value()} == "restaurant");
+    ++it;
+    REQUIRE(std::string{it->key()} == "name");
+    REQUIRE(std::string{it->value()} == "Node Inn");
+    ++it;
+    REQUIRE(std::string{it->key()} == "phone");
+    REQUIRE(std::string{it->value()} == "+1-123-555-4567");
+    ++it;
+    REQUIRE(std::string{it->key()} == "cuisine");
+    REQUIRE(std::string{it->value()} == "italian");
+    ++it;
+    REQUIRE(it == node.tags().cend());
+}
 
-        auto it = node2.tags().cbegin();
-        REQUIRE(std::string{it++->key()} == "a");
-        REQUIRE(std::string{it++->key()} == "b");
-        REQUIRE(std::string{it++->key()} == "c");
-        REQUIRE(it == node2.tags().cend());
-        REQUIRE(std::distance(node2.cbegin(), node2.cend()) == 1);
-    }
+TEST_CASE("create node with tags using builders: add tags using _tag with equal sign in single cstring") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    SECTION("add tags using mixed tag sources") {
-        const std::vector<pair_of_cstrings> tags = {
-            {"t5", "t5"},
-            {"t6", "t6"}
-        };
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(2),
+        _tag("amenity=restaurant"),
+        _tag("name="),
+        _tag("phone"),
+        _tag(std::string{"cuisine=italian"})
+    );
 
-        const auto pos = osmium::builder::add_node(buffer,
-            _id(4),
-            _tag("t1", "t1"),
-            _tags({{"t2", "t2"}, {"t3", "t3"}}),
-            _tag("t4", "t4"),
-            _tags(tags)
-        );
+    const auto& node = buffer.get<osmium::Node>(pos);
 
-        const auto& node = buffer.get<osmium::Node>(pos);
+    REQUIRE(node.id() == 2);
+    REQUIRE(node.tags().size() == 4);
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
 
-        REQUIRE(node.id() == 4);
-        REQUIRE(node.tags().size() == 6);
+    auto it = node.tags().cbegin();
+    REQUIRE(std::string{it->key()} == "amenity");
+    REQUIRE(std::string{it->value()} == "restaurant");
+    ++it;
+    REQUIRE(std::string{it->key()} == "name");
+    REQUIRE(it->value()[0] == '\0');
+    ++it;
+    REQUIRE(std::string{it->key()} == "phone");
+    REQUIRE(it->value()[0] == '\0');
+    ++it;
+    REQUIRE(std::string{it->key()} == "cuisine");
+    REQUIRE(std::string{it->value()} == "italian");
+    ++it;
+    REQUIRE(it == node.tags().cend());
+}
 
-        auto it = node.tags().cbegin();
-        REQUIRE(std::string{it->key()} == "t1");
-        ++it;
-        REQUIRE(std::string{it->key()} == "t2");
-        ++it;
-        REQUIRE(std::string{it->key()} == "t3");
-        ++it;
-        REQUIRE(std::string{it->key()} == "t4");
-        ++it;
-        REQUIRE(std::string{it->key()} == "t5");
-        ++it;
-        REQUIRE(std::string{it->key()} == "t6");
-        ++it;
-        REQUIRE(it == node.tags().cend());
-        REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
-    }
+TEST_CASE("create node with tags using builders: add tags using _tags from initializer list") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(3),
+        _tags({{"amenity", "post_box"}})
+    );
+
+    const auto& node = buffer.get<osmium::Node>(pos);
+
+    REQUIRE(node.id() == 3);
+    REQUIRE(node.tags().size() == 1);
+
+    auto it = node.tags().cbegin();
+    REQUIRE(std::string{it->key()} == "amenity");
+    REQUIRE(std::string{it->value()} == "post_box");
+    ++it;
+    REQUIRE(it == node.tags().cend());
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
+}
+
+TEST_CASE("create node with tags using builders: add tags using _tags from TagList") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+
+    const auto pos1 = osmium::builder::add_node(buffer,
+        _id(3),
+        _tag("a", "d"),
+        _tag("b", "e"),
+        _tag("c", "f")
+    );
+
+    const auto& node1 = buffer.get<osmium::Node>(pos1);
+
+    const auto pos2 = osmium::builder::add_node(buffer,
+        _id(4),
+        _tags(node1.tags())
+    );
+
+    const auto& node2 = buffer.get<osmium::Node>(pos2);
+
+    REQUIRE(node2.id() == 4);
+    REQUIRE(node2.tags().size() == 3);
+
+    auto it = node2.tags().cbegin();
+    REQUIRE(std::string{it++->key()} == "a");
+    REQUIRE(std::string{it++->key()} == "b");
+    REQUIRE(std::string{it++->key()} == "c");
+    REQUIRE(it == node2.tags().cend());
+    REQUIRE(std::distance(node2.cbegin(), node2.cend()) == 1);
+}
+
+TEST_CASE("create node with tags using builders: add tags using mixed tag sources") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+
+    const std::vector<pair_of_cstrings> tags = {
+        {"t5", "t5"},
+        {"t6", "t6"}
+    };
+
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(4),
+        _tag("t1=t1"),
+        _tags({{"t2", "t2"}, {"t3", "t3"}}),
+        _tag("t4", "t4"),
+        _tags(tags)
+    );
+
+    const auto& node = buffer.get<osmium::Node>(pos);
+
+    REQUIRE(node.id() == 4);
+    REQUIRE(node.tags().size() == 6);
+
+    auto it = node.tags().cbegin();
+    REQUIRE(std::string{it->key()} == "t1");
+    ++it;
+    REQUIRE(std::string{it->key()} == "t2");
+    ++it;
+    REQUIRE(std::string{it->key()} == "t3");
+    ++it;
+    REQUIRE(std::string{it->key()} == "t4");
+    ++it;
+    REQUIRE(std::string{it->key()} == "t5");
+    ++it;
+    REQUIRE(std::string{it->key()} == "t6");
+    ++it;
+    REQUIRE(it == node.tags().cend());
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
+}
+
+TEST_CASE("create node with tags using builders: add tags using _t with string") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+
+    const auto pos = osmium::builder::add_node(buffer,
+        _id(5),
+        _t("amenity=post_box,,empty,also_empty=,operator=Deutsche Post")
+    );
+
+    const auto& node = buffer.get<osmium::Node>(pos);
+
+    REQUIRE(node.id() == 5);
+    REQUIRE(node.tags().size() == 4);
+
+    auto it = node.tags().cbegin();
+    REQUIRE(std::string{it->key()} == "amenity");
+    REQUIRE(std::string{it->value()} == "post_box");
+    ++it;
+    REQUIRE(std::string{it->key()} == "empty");
+    REQUIRE(it->value()[0] == '\0');
+    ++it;
+    REQUIRE(std::string{it->key()} == "also_empty");
+    REQUIRE(it->value()[0] == '\0');
+    ++it;
+    REQUIRE(std::string{it->key()} == "operator");
+    REQUIRE(std::string{it->value()} == "Deutsche Post");
+    ++it;
+    REQUIRE(it == node.tags().cend());
+    REQUIRE(std::distance(node.cbegin(), node.cend()) == 1);
 }
 
 TEST_CASE("create way using builders") {
-
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     SECTION("add way without nodes") {
         const auto pos = osmium::builder::add_way(buffer,
@@ -264,9 +329,7 @@ TEST_CASE("create way with nodes") {
         { 8, osmium::Location{8.8, 0.8} }
     };
 
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-
-    osmium::memory::Buffer wbuffer{1024 * 10};
+    osmium::memory::Buffer wbuffer{test_buffer_size};
     osmium::builder::add_way(wbuffer,
         _id(1),
         _nodes({1, 2, 4, 8})
@@ -274,7 +337,7 @@ TEST_CASE("create way with nodes") {
 
     const osmium::NodeRefList& nodes = wbuffer.get<osmium::Way>(0).nodes();
 
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     SECTION("add nodes using an OSM object id or NodeRef") {
         osmium::builder::add_way(buffer,
@@ -354,7 +417,7 @@ TEST_CASE("create way with nodes") {
     REQUIRE(way.nodes().size() == 4);
     REQUIRE(std::distance(way.cbegin(), way.cend()) == 1);
 
-    auto it = way.nodes().cbegin();
+    const auto* it = way.nodes().cbegin();
 
     REQUIRE(it->ref() == 1);
     if (it->location().valid()) {
@@ -383,171 +446,168 @@ TEST_CASE("create way with nodes") {
     REQUIRE(it == way.nodes().cend());
 }
 
-TEST_CASE("create relation using builders") {
+TEST_CASE("create relation using builders: create relation") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
+    osmium::builder::attr::member_type m{osmium::item_type::way, 113, "inner"};
 
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::builder::add_relation(buffer,
+        _id(123),
+        _member(osmium::item_type::node, 123, ""),
+        _member(osmium::item_type::node, 132),
+        _member(osmium::item_type::way, 111, "outer"),
+        _member(osmium::builder::attr::member_type{osmium::item_type::way, 112, "inner"}),
+        _member(m)
+    );
 
-    SECTION("create relation") {
-        osmium::builder::attr::member_type m{osmium::item_type::way, 113, "inner"};
+    const auto& relation = buffer.get<osmium::Relation>(0);
 
-        osmium::builder::add_relation(buffer,
-            _id(123),
-            _member(osmium::item_type::node, 123, ""),
-            _member(osmium::item_type::node, 132),
-            _member(osmium::item_type::way, 111, "outer"),
-            _member(osmium::builder::attr::member_type{osmium::item_type::way, 112, "inner"}),
-            _member(m)
-        );
+    REQUIRE(relation.id() == 123);
+    REQUIRE(relation.members().size() == 5);
+    REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 1);
 
-        const auto& relation = buffer.get<osmium::Relation>(0);
+    auto it = relation.members().begin();
 
-        REQUIRE(relation.id() == 123);
-        REQUIRE(relation.members().size() == 5);
-        REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 1);
+    REQUIRE(it->type() == osmium::item_type::node);
+    REQUIRE(it->ref() == 123);
+    REQUIRE(it->role()[0] == '\0');
+    ++it;
 
-        auto it = relation.members().begin();
+    REQUIRE(it->type() == osmium::item_type::node);
+    REQUIRE(it->ref() == 132);
+    REQUIRE(it->role()[0] == '\0');
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::node);
-        REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()}.empty());
-        ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 111);
+    REQUIRE(std::string{it->role()} == "outer");
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::node);
-        REQUIRE(it->ref() == 132);
-        REQUIRE(std::string{it->role()}.empty());
-        ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 112);
+    REQUIRE(std::string{it->role()} == "inner");
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 111);
-        REQUIRE(std::string{it->role()} == "outer");
-        ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 113);
+    REQUIRE(std::string{it->role()} == "inner");
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 112);
-        REQUIRE(std::string{it->role()} == "inner");
-        ++it;
+    REQUIRE(it == relation.members().end());
+}
 
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 113);
-        REQUIRE(std::string{it->role()} == "inner");
-        ++it;
+TEST_CASE("create relation using builders: create relation member from existing relation member") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-        REQUIRE(it == relation.members().end());
-    }
+    osmium::builder::add_relation(buffer,
+        _id(123),
+        _member(osmium::item_type::way, 111, "outer"),
+        _member(osmium::item_type::way, 112, "inner")
+    );
 
-    SECTION("create relation member from existing relation member") {
-        osmium::builder::add_relation(buffer,
-            _id(123),
-            _member(osmium::item_type::way, 111, "outer"),
-            _member(osmium::item_type::way, 112, "inner")
-        );
+    const auto& relation1 = buffer.get<osmium::Relation>(0);
 
-        const auto& relation1 = buffer.get<osmium::Relation>(0);
+    const auto pos = osmium::builder::add_relation(buffer,
+        _id(124),
+        _member(*relation1.members().begin()),
+        _members(std::next(relation1.members().begin()), relation1.members().end())
+    );
 
-        const auto pos = osmium::builder::add_relation(buffer,
-            _id(124),
-            _member(*relation1.members().begin()),
-            _members(std::next(relation1.members().begin()), relation1.members().end())
-        );
+    const auto& relation = buffer.get<osmium::Relation>(pos);
 
-        const auto& relation = buffer.get<osmium::Relation>(pos);
+    REQUIRE(relation.id() == 124);
+    REQUIRE(relation.members().size() == 2);
 
-        REQUIRE(relation.id() == 124);
-        REQUIRE(relation.members().size() == 2);
+    auto it = relation.members().begin();
 
-        auto it = relation.members().begin();
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 111);
+    REQUIRE(std::string{it->role()} == "outer");
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 111);
-        REQUIRE(std::string{it->role()} == "outer");
-        ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 112);
+    REQUIRE(std::string{it->role()} == "inner");
+    ++it;
 
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 112);
-        REQUIRE(std::string{it->role()} == "inner");
-        ++it;
+    REQUIRE(it == relation.members().end());
+}
 
-        REQUIRE(it == relation.members().end());
-    }
+TEST_CASE("create relation using builders: create relation with members from initializer list") {
+    osmium::memory::Buffer buffer{test_buffer_size};
 
-    SECTION("create relation with members from initializer list") {
-        const auto pos = osmium::builder::add_relation(buffer,
-            _id(123),
-            _members({
-                {osmium::item_type::node, 123, ""},
-                {osmium::item_type::way, 111, "outer"}
-            })
-        );
-
-        const auto& relation = buffer.get<osmium::Relation>(pos);
-
-        REQUIRE(relation.id() == 123);
-        REQUIRE(relation.members().size() == 2);
-        REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 1);
-
-        auto it = relation.members().begin();
-        REQUIRE(it->type() == osmium::item_type::node);
-        REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()}.empty());
-        ++it;
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 111);
-        REQUIRE(std::string{it->role()} == "outer");
-        ++it;
-        REQUIRE(it == relation.members().end());
-    }
-
-    SECTION("create relation with members from iterators and some tags") {
-        const std::vector<member_type> members = {
-            {osmium::item_type::node, 123},
+    const auto pos = osmium::builder::add_relation(buffer,
+        _id(123),
+        _members({
+            {osmium::item_type::node, 123, ""},
             {osmium::item_type::way, 111, "outer"}
-        };
+        })
+    );
 
-        SECTION("using iterators") {
-            osmium::builder::add_relation(buffer,
-                _id(123),
-                _members(members.begin(), members.end()),
-                _tag("a", "x"),
-                _tag("b", "y")
-            );
-        }
-        SECTION("using container") {
-            osmium::builder::add_relation(buffer,
-                _id(123),
-                _members(members),
-                _tag("a", "x"),
-                _tag("b", "y")
-            );
-        }
+    const auto& relation = buffer.get<osmium::Relation>(pos);
 
-        const auto& relation = buffer.get<osmium::Relation>(0);
+    REQUIRE(relation.id() == 123);
+    REQUIRE(relation.members().size() == 2);
+    REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 1);
 
-        REQUIRE(relation.id() == 123);
-        REQUIRE(relation.members().size() == 2);
-        REQUIRE(relation.tags().size() == 2);
-        REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 2);
+    auto it = relation.members().begin();
+    REQUIRE(it->type() == osmium::item_type::node);
+    REQUIRE(it->ref() == 123);
+    REQUIRE(it->role()[0] == '\0');
+    ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 111);
+    REQUIRE(std::string{it->role()} == "outer");
+    ++it;
+    REQUIRE(it == relation.members().end());
+}
 
-        auto it = relation.members().begin();
-        REQUIRE(it->type() == osmium::item_type::node);
-        REQUIRE(it->ref() == 123);
-        REQUIRE(std::string{it->role()}.empty());
-        ++it;
-        REQUIRE(it->type() == osmium::item_type::way);
-        REQUIRE(it->ref() == 111);
-        REQUIRE(std::string{it->role()} == "outer");
-        ++it;
-        REQUIRE(it == relation.members().end());
+TEST_CASE("create relation using builders: create relation with members from iterators and some tags") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+
+    const std::vector<member_type> members = {
+        {osmium::item_type::node, 123},
+        {osmium::item_type::way, 111, "outer"}
+    };
+
+    SECTION("using iterators") {
+        osmium::builder::add_relation(buffer,
+            _id(123),
+            _members(members.begin(), members.end()),
+            _tag("a", "x"),
+            _tag("b", "y")
+        );
+    }
+    SECTION("using container") {
+        osmium::builder::add_relation(buffer,
+            _id(123),
+            _members(members),
+            _tag("a", "x"),
+            _tag("b", "y")
+        );
     }
 
+    const auto& relation = buffer.get<osmium::Relation>(0);
+
+    REQUIRE(relation.id() == 123);
+    REQUIRE(relation.members().size() == 2);
+    REQUIRE(relation.tags().size() == 2);
+    REQUIRE(std::distance(relation.cbegin(), relation.cend()) == 2);
+
+    auto it = relation.members().begin();
+    REQUIRE(it->type() == osmium::item_type::node);
+    REQUIRE(it->ref() == 123);
+    REQUIRE(it->role()[0] == '\0');
+    ++it;
+    REQUIRE(it->type() == osmium::item_type::way);
+    REQUIRE(it->ref() == 111);
+    REQUIRE(std::string{it->role()} == "outer");
+    ++it;
+    REQUIRE(it == relation.members().end());
 }
 
 TEST_CASE("create area using builders") {
-
-    using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     SECTION("add area without rings") {
         const auto pos = osmium::builder::add_area(buffer,
diff --git a/third_party/libosmium/test/t/builder/test_object_builder.cpp b/third_party/libosmium/test/t/builder/test_object_builder.cpp
index eb7075bd6..aa356c12b 100644
--- a/third_party/libosmium/test/t/builder/test_object_builder.cpp
+++ b/third_party/libosmium/test/t/builder/test_object_builder.cpp
@@ -4,8 +4,12 @@
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm.hpp>
 
+#include <string>
+
+constexpr const std::size_t test_buffer_size = 1024UL * 10UL;
+
 TEST_CASE("create objects using builder") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::string user;
 
     SECTION("complete node with tags") {
@@ -364,7 +368,7 @@ TEST_CASE("create objects using builder") {
 }
 
 TEST_CASE("no call to set_user on node") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     {
         osmium::builder::NodeBuilder builder{buffer};
@@ -376,7 +380,7 @@ TEST_CASE("no call to set_user on node") {
 }
 
 TEST_CASE("set_user with length on node") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::string user = "userx";
 
     {
@@ -390,7 +394,7 @@ TEST_CASE("set_user with length on node") {
 }
 
 TEST_CASE("no call to set_user on way") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     {
         osmium::builder::WayBuilder builder{buffer};
@@ -402,7 +406,7 @@ TEST_CASE("no call to set_user on way") {
 }
 
 TEST_CASE("set_user with length on way") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::string user = "userx";
 
     {
@@ -416,7 +420,7 @@ TEST_CASE("set_user with length on way") {
 }
 
 TEST_CASE("no call to set_user on changeset") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     {
         osmium::builder::ChangesetBuilder builder{buffer};
@@ -428,7 +432,7 @@ TEST_CASE("no call to set_user on changeset") {
 }
 
 TEST_CASE("set_user with length on changeset") {
-    osmium::memory::Buffer buffer{1024 * 10};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::string user = "userx";
 
     {
@@ -441,3 +445,40 @@ TEST_CASE("set_user with length on changeset") {
     REQUIRE(std::string{"user"} == changeset.user());
 }
 
+TEST_CASE("clear_user should clear the user field but nothing else") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+    std::string user = "user";
+
+    {
+        osmium::builder::NodeBuilder builder{buffer};
+        builder.set_id(17)
+            .set_visible(true)
+            .set_version(1)
+            .set_changeset(123)
+            .set_uid(555)
+            .set_timestamp("2015-07-01T00:00:01Z")
+            .set_location(osmium::Location{1.2, 3.4})
+            .set_user(user);
+        builder.add_tags({{"highway", "primary"}, {"oneway", "yes"}});
+    }
+
+    auto& node = buffer.get<osmium::Node>(buffer.commit());
+
+    REQUIRE(std::string{"user"} == node.user());
+
+    node.clear_user();
+
+    REQUIRE(std::string{""} == node.user());
+    REQUIRE(node.uid() == 555);
+    REQUIRE(node.tags().size() == 2);
+
+    auto it = node.tags().begin();
+    REQUIRE(it->key() == std::string{"highway"});
+    REQUIRE(it->value() == std::string{"primary"});
+    ++it;
+    REQUIRE(it->key() == std::string{"oneway"});
+    REQUIRE(it->value() == std::string{"yes"});
+    ++it;
+    REQUIRE(it == node.tags().end());
+}
+
diff --git a/third_party/libosmium/test/t/geom/test_coordinates.cpp b/third_party/libosmium/test/t/geom/test_coordinates.cpp
index d87696937..847040962 100644
--- a/third_party/libosmium/test/t/geom/test_coordinates.cpp
+++ b/third_party/libosmium/test/t/geom/test_coordinates.cpp
@@ -2,6 +2,8 @@
 
 #include <osmium/geom/coordinates.hpp>
 
+#include <string>
+
 TEST_CASE("Default constructed coordinates are invalid") {
     const osmium::geom::Coordinates c;
     REQUIRE_FALSE(c.valid());
diff --git a/third_party/libosmium/test/t/geom/test_factory_with_projection.cpp b/third_party/libosmium/test/t/geom/test_factory_with_projection.cpp
index 08efc0314..690f044ec 100644
--- a/third_party/libosmium/test/t/geom/test_factory_with_projection.cpp
+++ b/third_party/libosmium/test/t/geom/test_factory_with_projection.cpp
@@ -5,6 +5,8 @@
 #include <osmium/geom/wkb.hpp>
 #include <osmium/geom/wkt.hpp>
 
+#include <string>
+
 TEST_CASE("Projection using MercatorProjection class to WKT") {
     osmium::geom::WKTFactory<osmium::geom::MercatorProjection> factory{2};
 
diff --git a/third_party/libosmium/test/t/geom/test_geojson.cpp b/third_party/libosmium/test/t/geom/test_geojson.cpp
index 24c2bf9fb..81c9efb3e 100644
--- a/third_party/libosmium/test/t/geom/test_geojson.cpp
+++ b/third_party/libosmium/test/t/geom/test_geojson.cpp
@@ -5,18 +5,18 @@
 
 #include <osmium/geom/geojson.hpp>
 
+#include <iterator>
+#include <string>
+
 TEST_CASE("GeoJSON point geometry") {
     osmium::geom::GeoJSONFactory<> factory;
+    const std::string json{factory.create_point(osmium::Location{3.2, 4.2})};
+    REQUIRE(std::string{"{\"type\":\"Point\",\"coordinates\":[3.2,4.2]}"} == json);
+}
 
-    SECTION("point") {
-        const std::string json{factory.create_point(osmium::Location{3.2, 4.2})};
-        REQUIRE(std::string{"{\"type\":\"Point\",\"coordinates\":[3.2,4.2]}"} == json);
-    }
-
-    SECTION("empty_point") {
-        REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), const osmium::invalid_location&);
-    }
-
+TEST_CASE("GeoJSON empty point geometry") {
+    osmium::geom::GeoJSONFactory<> factory;
+    REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), osmium::invalid_location);
 }
 
 TEST_CASE("GeoJSON linestring geometry") {
@@ -50,17 +50,17 @@ TEST_CASE("GeoJSON linestring geometry") {
     SECTION("empty_linestring") {
         const auto& wnl = create_test_wnl_empty(buffer);
 
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), const osmium::geometry_error&);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), osmium::geometry_error);
     }
 
     SECTION("linestring with two same locations") {
         const auto& wnl = create_test_wnl_same_location(buffer);
 
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
 
         {
             const std::string json{factory.create_linestring(wnl, osmium::geom::use_nodes::all)};
@@ -75,7 +75,7 @@ TEST_CASE("GeoJSON linestring geometry") {
 
     SECTION("linestring with undefined location") {
         const auto& wnl = create_test_wnl_undefined_location(buffer);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::invalid_location&);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::invalid_location);
     }
 
 }
diff --git a/third_party/libosmium/test/t/geom/test_geos.cpp b/third_party/libosmium/test/t/geom/test_geos.cpp
index 63a583d43..5714ad190 100644
--- a/third_party/libosmium/test/t/geom/test_geos.cpp
+++ b/third_party/libosmium/test/t/geom/test_geos.cpp
@@ -10,6 +10,8 @@
 
 #include <osmium/geom/mercator_projection.hpp>
 
+#include <memory>
+
 TEST_CASE("GEOS geometry factory - create point") {
     osmium::geom::GEOSFactory<> factory;
 
@@ -41,7 +43,7 @@ TEST_CASE("GEOS geometry factory - create point with externally created GEOS fac
 TEST_CASE("GEOS geometry factory - can not create from invalid location") {
     osmium::geom::GEOSFactory<> factory;
 
-    REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), osmium::invalid_location);
 }
 
 TEST_CASE("GEOS geometry factory - create linestring") {
diff --git a/third_party/libosmium/test/t/geom/test_ogr.cpp b/third_party/libosmium/test/t/geom/test_ogr.cpp
index 8fe9c69bd..8eb976d9c 100644
--- a/third_party/libosmium/test/t/geom/test_ogr.cpp
+++ b/third_party/libosmium/test/t/geom/test_ogr.cpp
@@ -5,19 +5,18 @@
 
 #include <osmium/geom/ogr.hpp>
 
+#include <memory>
+
 TEST_CASE("OGR point geometry") {
     osmium::geom::OGRFactory<> factory;
+    std::unique_ptr<OGRPoint> point{factory.create_point(osmium::Location{3.2, 4.2})};
+    REQUIRE(3.2 == point->getX());
+    REQUIRE(4.2 == point->getY());
+}
 
-    SECTION("point") {
-        std::unique_ptr<OGRPoint> point{factory.create_point(osmium::Location{3.2, 4.2})};
-        REQUIRE(3.2 == point->getX());
-        REQUIRE(4.2 == point->getY());
-    }
-
-    SECTION("empty_point") {
-        REQUIRE_THROWS_AS(factory.create_point(osmium::Location()), const osmium::invalid_location&);
-    }
-
+TEST_CASE("OGR empty point geometry") {
+    osmium::geom::OGRFactory<> factory;
+    REQUIRE_THROWS_AS(factory.create_point(osmium::Location()), osmium::invalid_location);
 }
 
 TEST_CASE("OGR linestring geometry") {
diff --git a/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp b/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
index cf5604999..1da701702 100644
--- a/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
+++ b/third_party/libosmium/test/t/geom/test_ogr_wkb.cpp
@@ -17,7 +17,7 @@ std::string to_wkb(const OGRGeometry* geometry) {
     std::string buffer;
     buffer.resize(geometry->WkbSize());
 
-    geometry->exportToWkb(wkbNDR, const_cast<unsigned char*>(reinterpret_cast<const unsigned char*>(buffer.data())));
+    geometry->exportToWkb(wkbNDR, reinterpret_cast<unsigned char*>(&*buffer.begin()));
 
     return buffer;
 }
@@ -26,7 +26,7 @@ TEST_CASE("compare WKB point against GDAL/OGR") {
     osmium::geom::WKBFactory<> wkb_factory{osmium::geom::wkb_type::wkb};
     osmium::geom::OGRFactory<> ogr_factory;
 
-    osmium::Location loc{3.2, 4.2};
+    const osmium::Location loc{3.2, 4.2};
     const std::string wkb{wkb_factory.create_point(loc)};
     const std::unique_ptr<OGRPoint> geometry = ogr_factory.create_point(loc);
     REQUIRE(to_wkb(geometry.get()) == wkb);
diff --git a/third_party/libosmium/test/t/geom/test_projection.cpp b/third_party/libosmium/test/t/geom/test_projection.cpp
index 2b1ba0d47..675aeadd7 100644
--- a/third_party/libosmium/test/t/geom/test_projection.cpp
+++ b/third_party/libosmium/test/t/geom/test_projection.cpp
@@ -4,8 +4,6 @@
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/projection.hpp>
 
-#include <random>
-
 TEST_CASE("Indentity Projection") {
     osmium::geom::IdentityProjection projection;
     REQUIRE(4326 == projection.epsg());
@@ -35,11 +33,11 @@ TEST_CASE("Projection 4326 from init string") {
 }
 
 TEST_CASE("Creating projection from unknown init string") {
-    REQUIRE_THROWS_AS(osmium::geom::Projection{"abc"}, const osmium::projection_error&);
+    REQUIRE_THROWS_AS(osmium::geom::Projection{"abc"}, osmium::projection_error);
 }
 
 TEST_CASE("Creating projection from unknown EPSG code") {
-    REQUIRE_THROWS_AS(osmium::geom::Projection{9999999}, const osmium::projection_error&);
+    REQUIRE_THROWS_AS(osmium::geom::Projection{9999999}, osmium::projection_error);
 }
 
 TEST_CASE("Projection 3857") {
@@ -76,35 +74,35 @@ TEST_CASE("Projection 3857") {
     }
 }
 
-TEST_CASE("MercatorProjection") {
+TEST_CASE("MercatorProjection: Zero coordinates") {
     osmium::geom::MercatorProjection projection;
-
-    SECTION("Zero coordinates") {
-        const osmium::Location loc{0.0, 0.0};
-        const osmium::geom::Coordinates c{0.0, 0.0};
-        REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
-        REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
-    }
-
-    SECTION("Max longitude") {
-        const osmium::Location loc{180.0, 0.0};
-        const osmium::geom::Coordinates c{20037508.34, 0.0};
-        REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
-        REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
-    }
-
-    SECTION("Min longitude") {
-        const osmium::Location loc{-180.0, 0.0};
-        const osmium::geom::Coordinates c{-20037508.34, 0.0};
-        REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
-        REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
-    }
-
-    SECTION("Max latitude") {
-        const osmium::Location loc{0.0, 85.0511288};
-        const osmium::geom::Coordinates c{0.0, 20037508.34};
-        REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
-        REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
-    }
+    const osmium::Location loc{0.0, 0.0};
+    const osmium::geom::Coordinates c{0.0, 0.0};
+    REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
+    REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
+}
+
+TEST_CASE("MercatorProjection: Max longitude") {
+    osmium::geom::MercatorProjection projection;
+    const osmium::Location loc{180.0, 0.0};
+    const osmium::geom::Coordinates c{20037508.34, 0.0};
+    REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
+    REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
+}
+
+TEST_CASE("MercatorProjection: Min longitude") {
+    osmium::geom::MercatorProjection projection;
+    const osmium::Location loc{-180.0, 0.0};
+    const osmium::geom::Coordinates c{-20037508.34, 0.0};
+    REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
+    REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
+}
+
+TEST_CASE("MercatorProjection: Max latitude") {
+    osmium::geom::MercatorProjection projection;
+    const osmium::Location loc{0.0, 85.0511288};
+    const osmium::geom::Coordinates c{0.0, 20037508.34};
+    REQUIRE(projection(loc).x == Approx(c.x).epsilon(0.00001));
+    REQUIRE(projection(loc).y == Approx(c.y).epsilon(0.00001));
 }
 
diff --git a/third_party/libosmium/test/t/geom/test_tile.cpp b/third_party/libosmium/test/t/geom/test_tile.cpp
index 81a3d36ef..58ee888e6 100644
--- a/third_party/libosmium/test/t/geom/test_tile.cpp
+++ b/third_party/libosmium/test/t/geom/test_tile.cpp
@@ -4,6 +4,7 @@
 
 #include <osmium/geom/tile.hpp>
 
+#include <cmath>
 #include <sstream>
 
 TEST_CASE("Helper functions") {
@@ -41,7 +42,7 @@ TEST_CASE("Tile from x180.0 y90.0 at zoom 4") {
 
     osmium::geom::Tile t{4, l};
 
-    REQUIRE(t.x == (1u << 4u) - 1);
+    REQUIRE(t.x == (1U << 4U) - 1);
     REQUIRE(t.y == 0);
     REQUIRE(t.z == 4);
     REQUIRE(t.valid());
@@ -52,7 +53,7 @@ TEST_CASE("Tile from x0.0 y0.0 at zoom 4") {
 
     osmium::geom::Tile t{4, l};
 
-    const auto n = 1u << (4u - 1u);
+    const auto n = 1U << (4U - 1U);
     REQUIRE(t.x == n);
     REQUIRE(t.y == n);
     REQUIRE(t.z == 4);
@@ -60,12 +61,12 @@ TEST_CASE("Tile from x0.0 y0.0 at zoom 4") {
 }
 
 TEST_CASE("Tile from max values at zoom 4") {
-    osmium::geom::Tile t{4u, 15u, 15u};
+    osmium::geom::Tile t{4U, 15U, 15U};
     REQUIRE(t.valid());
 }
 
 TEST_CASE("Tile from max values at zoom 30") {
-    osmium::geom::Tile t{30u, (1u << 30u) - 1, (1u << 30u) - 1};
+    osmium::geom::Tile t{30U, (1U << 30U) - 1, (1U << 30U) - 1};
     REQUIRE(t.valid());
 }
 
@@ -98,21 +99,35 @@ TEST_CASE("Tile order") {
 }
 
 TEST_CASE("Check a random list of tiles") {
-    std::istringstream input_data(s);
+    std::istringstream input_data{s};
+
+    int n = 0;
     while (input_data) {
-        double lon, lat;
-        uint32_t x, y, zoom;
+        double lon = NAN;
+        double lat = NAN;
+        uint32_t x = 0;
+        uint32_t y = 0;
+        uint32_t zoom = 0;
+
         input_data >> lon;
         input_data >> lat;
         input_data >> x;
         input_data >> y;
         input_data >> zoom;
 
+        if (std::isnan(lon)) {
+            break;
+        }
+
         osmium::Location l{lon, lat};
         osmium::geom::Tile t{zoom, l};
         REQUIRE(t.x == x);
         REQUIRE(t.y == y);
+
+        ++n;
     }
+
+    REQUIRE(n == 472);
 }
 
 TEST_CASE("Invalid tiles") {
diff --git a/third_party/libosmium/test/t/geom/test_wkb.cpp b/third_party/libosmium/test/t/geom/test_wkb.cpp
index 312595770..776bc0697 100644
--- a/third_party/libosmium/test/t/geom/test_wkb.cpp
+++ b/third_party/libosmium/test/t/geom/test_wkb.cpp
@@ -6,134 +6,143 @@
 #include <osmium/geom/wkb.hpp>
 #include <osmium/util/endian.hpp>
 
+#include <string>
+
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
-TEST_CASE("WKB geometry factory (byte-order-dependant), points") {
+TEST_CASE("WKB geometry factory (byte-order-dependent), point in WKB") {
     const osmium::Location loc{3.2, 4.2};
-
-    SECTION("point") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
-
-        const std::string wkb{factory.create_point(loc)};
-        REQUIRE(wkb == "01010000009A99999999990940CDCCCCCCCCCC1040");
-    }
-
-    SECTION("point in ewkb") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
-
-        const std::string wkb{factory.create_point(loc)};
-        REQUIRE(wkb == "0101000020E61000009A99999999990940CDCCCCCCCCCC1040");
-    }
-
-#ifndef OSMIUM_USE_SLOW_MERCATOR_PROJECTION
-    SECTION("point in web mercator") {
-        osmium::geom::WKBFactory<osmium::geom::MercatorProjection> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
-
-        const std::string wkb{factory.create_point(loc)};
-        REQUIRE(wkb == "010100000028706E7BF9BD1541D6A90093E48F1C41");
-    }
-
-    SECTION("point in ewkb in web mercator") {
-        osmium::geom::WKBFactory<osmium::geom::MercatorProjection> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
-
-        const std::string wkb{factory.create_point(loc)};
-        REQUIRE(wkb == "0101000020110F000028706E7BF9BD1541D6A90093E48F1C41");
-    }
-#endif
-
-}
-
-TEST_CASE("WKB geometry factory (byte-order-dependant)") {
-
-    osmium::memory::Buffer buffer{10000};
-
-    SECTION("linestring") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
-        const auto& wnl = create_test_wnl_okay(buffer);
-
-        {
-            const std::string wkb{factory.create_linestring(wnl)};
-            REQUIRE(wkb == "0102000000030000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
-        }
-
-        {
-            const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward)};
-            REQUIRE(wkb == "010200000003000000CDCCCCCCCCCC0C409A999999999913400000000000000C40CDCCCCCCCCCC12409A99999999990940CDCCCCCCCCCC1040");
-        }
-
-        {
-            const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all)};
-            REQUIRE(wkb == "0102000000040000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
-        }
-
-        {
-            const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
-            REQUIRE(wkb == "010200000004000000CDCCCCCCCCCC0C409A999999999913400000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC12409A99999999990940CDCCCCCCCCCC1040");
-        }
-    }
-
-    SECTION("linestring as ewkb") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
-
-        const auto& wnl = create_test_wnl_okay(buffer);
-
-        const std::string ewkb{factory.create_linestring(wnl)};
-        REQUIRE(ewkb == "0102000020E6100000030000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
-    }
-
-    SECTION("linestring with two same locations") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
-
-        const auto& wnl = create_test_wnl_same_location(buffer);
-
-        SECTION("unique forwards (default)") {
-            REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
-        }
-
-        SECTION("unique backwards") {
-            REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
-        }
-
-        SECTION("all forwards") {
-            const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all)};
-            REQUIRE(wkb == "0102000000020000000000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240");
-        }
-
-        SECTION("all backwards") {
-            const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
-            REQUIRE(wkb == "0102000000020000000000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240");
-        }
-    }
-
-    SECTION("linestring with undefined location") {
-        osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
-
-        const auto& wnl = create_test_wnl_undefined_location(buffer);
-
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::invalid_location&);
-    }
-
-}
-
-#endif
-
-TEST_CASE("WKB geometry (byte-order-independent)") {
-
     osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
 
-    SECTION("empty point") {
-        REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), const osmium::invalid_location&);
-    }
-
-    SECTION("empty linestring") {
-        osmium::memory::Buffer buffer{10000};
-        const auto& wnl = create_test_wnl_empty(buffer);
-
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), const osmium::geometry_error&);
-    }
-
+    const std::string wkb{factory.create_point(loc)};
+    REQUIRE(wkb == "01010000009A99999999990940CDCCCCCCCCCC1040");
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent), point in EWKB") {
+    const osmium::Location loc{3.2, 4.2};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
+
+    const std::string wkb{factory.create_point(loc)};
+    REQUIRE(wkb == "0101000020E61000009A99999999990940CDCCCCCCCCCC1040");
+}
+
+#ifndef OSMIUM_USE_SLOW_MERCATOR_PROJECTION
+TEST_CASE("WKB geometry factory (byte-order-dependent), point in web mercator WKB") {
+    const osmium::Location loc{3.2, 4.2};
+    osmium::geom::WKBFactory<osmium::geom::MercatorProjection> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+
+    const std::string wkb{factory.create_point(loc)};
+    REQUIRE(wkb.substr(0, 10) == "0101000000"); // little endian, point type
+    REQUIRE(wkb.substr(10 + 2, 16 - 2) == "706E7BF9BD1541"); // x coordinate (without first (least significant) byte)
+    REQUIRE(wkb.substr(26 + 2, 16 - 2) == "A90093E48F1C41"); // y coordinate (without first (least significant) byte)
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent), point in web mercator EWKB") {
+    const osmium::Location loc{3.2, 4.2};
+    osmium::geom::WKBFactory<osmium::geom::MercatorProjection> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
+
+    const std::string wkb{factory.create_point(loc)};
+    REQUIRE(wkb.substr(0, 10) == "0101000020"); // little endian, point type (extended)
+    REQUIRE(wkb.substr(10, 8) == "110F0000"); // SRID 3857
+    REQUIRE(wkb.substr(18 + 2, 16 - 2) == "706E7BF9BD1541"); // x coordinate (without first (least significant) byte)
+    REQUIRE(wkb.substr(34 + 2, 16 - 2) == "A90093E48F1C41"); // y coordinate (without first (least significant) byte)
+}
+#endif
+
+TEST_CASE("WKB geometry factory (byte-order-dependent): linestring") {
+    osmium::memory::Buffer buffer{10000};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+    const auto& wnl = create_test_wnl_okay(buffer);
+
+    {
+        const std::string wkb{factory.create_linestring(wnl)};
+        REQUIRE(wkb == "0102000000030000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
+    }
+
+    {
+        const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward)};
+        REQUIRE(wkb == "010200000003000000CDCCCCCCCCCC0C409A999999999913400000000000000C40CDCCCCCCCCCC12409A99999999990940CDCCCCCCCCCC1040");
+    }
+
+    {
+        const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all)};
+        REQUIRE(wkb == "0102000000040000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
+    }
+
+    {
+        const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
+        REQUIRE(wkb == "010200000004000000CDCCCCCCCCCC0C409A999999999913400000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC12409A99999999990940CDCCCCCCCCCC1040");
+    }
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent): linestring as ewkb") {
+    osmium::memory::Buffer buffer{10000};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::ewkb, osmium::geom::out_type::hex};
+
+    const auto& wnl = create_test_wnl_okay(buffer);
+
+    const std::string ewkb{factory.create_linestring(wnl)};
+    REQUIRE(ewkb == "0102000020E6100000030000009A99999999990940CDCCCCCCCCCC10400000000000000C40CDCCCCCCCCCC1240CDCCCCCCCCCC0C409A99999999991340");
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent): linestring with two same locations") {
+    osmium::memory::Buffer buffer{10000};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+
+    const auto& wnl = create_test_wnl_same_location(buffer);
+
+    SECTION("unique forwards (default)") {
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
+    }
+
+    SECTION("unique backwards") {
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
+    }
+
+    SECTION("all forwards") {
+        const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all)};
+        REQUIRE(wkb == "0102000000020000000000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240");
+    }
+
+    SECTION("all backwards") {
+        const std::string wkb{factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward)};
+        REQUIRE(wkb == "0102000000020000000000000000000C40CDCCCCCCCCCC12400000000000000C40CDCCCCCCCCCC1240");
+    }
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent): linestring with undefined location") {
+    osmium::memory::Buffer buffer{10000};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+
+    const auto& wnl = create_test_wnl_undefined_location(buffer);
+
+    REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::invalid_location);
+}
+
+TEST_CASE("WKB geometry factory (byte-order-dependent): polygon") {
+    osmium::memory::Buffer buffer{10000};
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+    const auto& wnl = create_test_wnl_closed(buffer);
+
+    const std::string wkb{factory.create_polygon(wnl)};
+    REQUIRE(wkb == "010300000001000000050000000000000000000840000000000000084066666666666610406666666666661040CDCCCCCCCCCC0C406666666666661040CDCCCCCCCCCC08400000000000000C4000000000000008400000000000000840");
+}
+
+#endif
+
+TEST_CASE("WKB geometry (byte-order-independent) of empty point") {
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+    REQUIRE_THROWS_AS(factory.create_point(osmium::Location{}), osmium::invalid_location);
+}
+
+TEST_CASE("WKB geometry (byte-order-independent) of empty linestring") {
+    osmium::geom::WKBFactory<> factory{osmium::geom::wkb_type::wkb, osmium::geom::out_type::hex};
+    osmium::memory::Buffer buffer{10000};
+    const auto& wnl = create_test_wnl_empty(buffer);
+
+    REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
+    REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
+    REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), osmium::geometry_error);
+    REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), osmium::geometry_error);
 }
 
diff --git a/third_party/libosmium/test/t/geom/test_wkt.cpp b/third_party/libosmium/test/t/geom/test_wkt.cpp
index e22fbe008..251f3e5ea 100644
--- a/third_party/libosmium/test/t/geom/test_wkt.cpp
+++ b/third_party/libosmium/test/t/geom/test_wkt.cpp
@@ -6,6 +6,8 @@
 #include <osmium/geom/mercator_projection.hpp>
 #include <osmium/geom/wkt.hpp>
 
+#include <string>
+
 TEST_CASE("WKT geometry for point") {
     const osmium::geom::WKTFactory<> factory;
     const std::string wkt{factory.create_point(osmium::Location{3.2, 4.2})};
@@ -14,7 +16,7 @@ TEST_CASE("WKT geometry for point") {
 
 TEST_CASE("WKT geometry for empty point") {
     const osmium::geom::WKTFactory<> factory;
-    REQUIRE_THROWS_AS(factory.create_point(osmium::Location()), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(factory.create_point(osmium::Location()), osmium::invalid_location);
 }
 
 TEST_CASE("WKT geometry for point in ekwt") {
@@ -87,17 +89,17 @@ TEST_CASE("WKT geometry factory") {
     SECTION("empty linestring") {
         const auto& wnl = create_test_wnl_empty(buffer);
 
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), const osmium::geometry_error&);
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), const osmium::geometry_error&);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all), osmium::geometry_error);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::all, osmium::geom::direction::backward), osmium::geometry_error);
     }
 
     SECTION("linestring with two same locations") {
         const auto& wnl = create_test_wnl_same_location(buffer);
 
         SECTION("unique forwards") {
-            REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::geometry_error&);
+            REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::geometry_error);
 
             try {
                 factory.create_linestring(wnl);
@@ -108,7 +110,7 @@ TEST_CASE("WKT geometry factory") {
         }
 
         SECTION("unique backwards") {
-            REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), const osmium::geometry_error&);
+            REQUIRE_THROWS_AS(factory.create_linestring(wnl, osmium::geom::use_nodes::unique, osmium::geom::direction::backward), osmium::geometry_error);
         }
 
         SECTION("all forwards") {
@@ -125,7 +127,7 @@ TEST_CASE("WKT geometry factory") {
     SECTION("linestring with undefined location") {
         const auto& wnl = create_test_wnl_undefined_location(buffer);
 
-        REQUIRE_THROWS_AS(factory.create_linestring(wnl), const osmium::invalid_location&);
+        REQUIRE_THROWS_AS(factory.create_linestring(wnl), osmium::invalid_location);
     }
 
     SECTION("area with one outer and no inner rings") {
diff --git a/third_party/libosmium/test/t/handler/test_apply.cpp b/third_party/libosmium/test/t/handler/test_apply.cpp
new file mode 100644
index 000000000..582d23b36
--- /dev/null
+++ b/third_party/libosmium/test/t/handler/test_apply.cpp
@@ -0,0 +1,129 @@
+#include "catch.hpp"
+
+#include "utils.hpp"
+
+#include <osmium/handler.hpp>
+#include <osmium/handler/node_locations_for_ways.hpp>
+#include <osmium/index/map/flex_mem.hpp>
+#include <osmium/io/xml_input.hpp>
+#include <osmium/memory/buffer.hpp>
+#include <osmium/visitor.hpp>
+
+TEST_CASE("apply with lambdas on reader") {
+    osmium::io::File file{with_data_dir("t/relations/data.osm")};
+    osmium::io::Reader reader{file};
+
+    int count_n = 0;
+    int count_w = 0;
+    int count_r = 0;
+    int count_o = 0;
+    int count_a = 0;
+
+    osmium::apply(reader,
+        [&](const osmium::Node& node) {
+            count_n += node.version();
+        },
+        [&](const osmium::Way& way) {
+            if (way.id() == 20) {
+                ++count_w;
+            }
+        },
+        [&](const osmium::Relation& relation) {
+            if (relation.id() > 30) {
+                ++count_r;
+            }
+        },
+        [&](const osmium::OSMObject& object) {
+            if (object.id() % 10 == 0) {
+                ++count_o;
+            }
+        },
+        [&](const osmium::Way& way) {
+            if (way.id() == 21) {
+                ++count_w;
+            }
+        },
+        [&](const osmium::Area& /*area*/) {
+            ++count_a;
+        }
+    );
+
+    REQUIRE(count_n == 5);
+    REQUIRE(count_w == 2);
+    REQUIRE(count_r == 2);
+    REQUIRE(count_o == 3);
+    REQUIRE(count_a == 0);
+}
+
+TEST_CASE("apply with lambda on buffer") {
+    osmium::io::File file{with_data_dir("t/relations/data.osm")};
+    osmium::io::Reader reader{file};
+
+    const auto buffer = reader.read();
+    reader.close();
+
+    std::size_t members = 0;
+
+    osmium::apply(buffer, [&](const osmium::Relation& relation) {
+        members += relation.members().size();
+    });
+
+    REQUIRE(members == 5);
+}
+
+TEST_CASE("apply on non-const buffer can change data") {
+    osmium::io::File file{with_data_dir("t/relations/data.osm")};
+    osmium::io::Reader reader{file};
+
+    auto buffer = reader.read();
+    reader.close();
+
+    int nodes = 0;
+
+    osmium::apply(buffer,
+        [&](osmium::Node& node) {
+            node.set_version(123);
+        },
+        [&](const osmium::Node& node) {
+            ++nodes;
+            REQUIRE(node.version() == 123);
+        }
+    );
+
+    REQUIRE(nodes == 5);
+}
+
+TEST_CASE("apply with handler and lambda") {
+    using index_type = osmium::index::map::FlexMem<osmium::unsigned_object_id_type, osmium::Location>;
+    using location_handler_type = osmium::handler::NodeLocationsForWays<index_type>;
+
+    osmium::io::File file{with_data_dir("t/relations/data.osm")};
+    osmium::io::Reader reader{file};
+
+    auto buffer = reader.read();
+    reader.close();
+
+    index_type index;
+    location_handler_type location_handler{index};
+
+    int64_t x = 0;
+    int64_t y = 0;
+
+    osmium::apply(buffer,
+        [&](const osmium::Way& way) {
+            REQUIRE_FALSE(way.nodes().front().location().valid());
+        },
+        location_handler,
+        [&](const osmium::Way& way) {
+            REQUIRE(way.nodes().front().location().valid());
+            for (const auto& wn : way.nodes()) {
+                x += wn.location().x();
+                y += wn.location().y();
+            }
+        }
+    );
+
+    REQUIRE(x == 44000000);
+    REQUIRE(y == 40000000);
+}
+
diff --git a/third_party/libosmium/test/t/handler/test_check_order_handler.cpp b/third_party/libosmium/test/t/handler/test_check_order_handler.cpp
index e6b1600a6..0da630043 100644
--- a/third_party/libosmium/test/t/handler/test_check_order_handler.cpp
+++ b/third_party/libosmium/test/t/handler/test_check_order_handler.cpp
@@ -38,7 +38,7 @@ TEST_CASE("CheckOrder handler: Nodes must be in order") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Ways must be in order") {
@@ -53,7 +53,7 @@ TEST_CASE("CheckOrder handler: Ways must be in order") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Relations must be in order") {
@@ -68,7 +68,7 @@ TEST_CASE("CheckOrder handler: Relations must be in order") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Same id twice is not allowed") {
@@ -78,7 +78,7 @@ TEST_CASE("CheckOrder handler: Same id twice is not allowed") {
     REQUIRE(osmium::opl_parse("n3", buffer));
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Nodes after ways") {
@@ -93,7 +93,7 @@ TEST_CASE("CheckOrder handler: Nodes after ways") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Nodes after relations") {
@@ -108,7 +108,7 @@ TEST_CASE("CheckOrder handler: Nodes after relations") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
 TEST_CASE("CheckOrder handler: Ways after relations") {
@@ -123,6 +123,6 @@ TEST_CASE("CheckOrder handler: Ways after relations") {
     }
 
     osmium::handler::CheckOrder handler;
-    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), const osmium::out_of_order_error&);
+    REQUIRE_THROWS_AS(osmium::apply(buffer, handler), osmium::out_of_order_error);
 }
 
diff --git a/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp b/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
index 591e85a7b..ea5429697 100644
--- a/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
+++ b/third_party/libosmium/test/t/handler/test_dynamic_handler.cpp
@@ -70,7 +70,7 @@ struct Handler2 : public osmium::handler::Handler {
 
 osmium::memory::Buffer fill_buffer() {
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-    osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+    osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_node(buffer, _id(1));
     osmium::builder::add_way(buffer, _id(2));
@@ -99,11 +99,9 @@ TEST_CASE("Dynamic handler") {
     const auto buffer = fill_buffer();
 
     osmium::handler::DynamicHandler handler;
-    int count = 0;
-
     osmium::apply(buffer, handler);
-    REQUIRE(count == 0);
 
+    int count = 0;
     handler.set<Handler1>(count);
     osmium::apply(buffer, handler);
     REQUIRE(count == 6);
diff --git a/third_party/libosmium/test/t/index/test_dump_and_load_index.cpp b/third_party/libosmium/test/t/index/test_dump_and_load_index.cpp
new file mode 100644
index 000000000..75297cb29
--- /dev/null
+++ b/third_party/libosmium/test/t/index/test_dump_and_load_index.cpp
@@ -0,0 +1,84 @@
+#include "catch.hpp"
+
+#include <osmium/index/detail/tmpfile.hpp>
+#include <osmium/index/map/dense_file_array.hpp>
+#include <osmium/index/map/dense_mem_array.hpp>
+#include <osmium/index/map/dense_mmap_array.hpp>
+#include <osmium/index/map/sparse_file_array.hpp>
+#include <osmium/index/map/sparse_mem_array.hpp>
+#include <osmium/index/map/sparse_mmap_array.hpp>
+#include <osmium/osm/location.hpp>
+#include <osmium/osm/types.hpp>
+
+using dense_file_array = osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
+using sparse_file_array = osmium::index::map::SparseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+template <class TMemoryIndex, class TFileIndex>
+void test_index(std::function<void(TMemoryIndex&, const int)> dump_method) {
+    const int fd = osmium::detail::create_tmp_file();
+    REQUIRE(osmium::file_size(fd) == 0);
+    const osmium::unsigned_object_id_type id1 = 12;
+    const osmium::unsigned_object_id_type id2 = 3;
+    const osmium::unsigned_object_id_type id3 = 7;
+    const osmium::Location loc1{1.2, 4.5};
+    const osmium::Location loc2{3.5, -7.2};
+    const osmium::Location loc3{-12.7, 14.5};
+
+    TMemoryIndex index;
+    index.set(id1, loc1);
+    index.set(id2, loc2);
+    index.set(id3, loc3);
+
+    // implementation of TMemoryIndex::sort should be empty if it is a dense index
+    index.sort();
+    dump_method(index, fd);
+
+    REQUIRE(osmium::file_size(fd) >= (3 * sizeof(typename TFileIndex::element_type)));
+
+    // load index from file
+    TFileIndex file_index{fd};
+
+    // test retrievals
+    REQUIRE(loc1 == file_index.get(id1));
+    REQUIRE(loc2 == file_index.get(id2));
+    REQUIRE(loc3 == file_index.get(id3));
+    REQUIRE_THROWS_AS(file_index.get(5), osmium::not_found);
+    REQUIRE_THROWS_AS(file_index.get(6), osmium::not_found);
+    REQUIRE_THROWS_AS(file_index.get(200), osmium::not_found);
+}
+
+#ifdef __linux__
+using dense_mmap_array = osmium::index::map::DenseMmapArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump DenseMmapArray, load as DenseFileArray") {
+    auto dump_method = [](dense_mmap_array& index, const int fd) { index.dump_as_array(fd);};
+    test_index<dense_mmap_array, dense_file_array>(dump_method);
+}
+#else
+# pragma message("not running 'DenseMmapArray' test case on this machine")
+#endif
+
+using dense_mem_array = osmium::index::map::DenseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump DenseMemArray, load as DenseFileArray") {
+    auto dump_method = [](dense_mem_array& index, const int fd) { index.dump_as_array(fd);};
+    test_index<dense_mem_array, dense_file_array>(dump_method);
+}
+
+#ifdef __linux__
+using sparse_mmap_array = osmium::index::map::SparseMmapArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump SparseMmapArray, load as SparseFileArray") {
+    auto dump_method = [](sparse_mmap_array& index, const int fd) { index.dump_as_list(fd);};
+    test_index<sparse_mmap_array, sparse_file_array>(dump_method);
+}
+#else
+# pragma message("not running 'SparseMmapArray' test case on this machine")
+#endif
+
+using sparse_mem_array = osmium::index::map::SparseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump SparseMemArray, load as SparseFileArray") {
+    auto dump_method = [](sparse_mem_array& index, const int fd) { index.dump_as_list(fd);};
+    test_index<sparse_mem_array, sparse_file_array>(dump_method);
+}
diff --git a/third_party/libosmium/test/t/index/test_dump_sparse_as_array.cpp b/third_party/libosmium/test/t/index/test_dump_sparse_as_array.cpp
new file mode 100644
index 000000000..487e5a68c
--- /dev/null
+++ b/third_party/libosmium/test/t/index/test_dump_sparse_as_array.cpp
@@ -0,0 +1,85 @@
+#include "catch.hpp"
+
+#include <osmium/index/detail/tmpfile.hpp>
+#include <osmium/index/map/dense_file_array.hpp>
+#include <osmium/index/map/sparse_mem_array.hpp>
+#include <osmium/index/map/sparse_mmap_array.hpp>
+#include <osmium/index/node_locations_map.hpp>
+#include <osmium/osm/node_ref.hpp>
+#include <osmium/osm/types.hpp>
+#include <osmium/util/file.hpp>
+
+#include <vector>
+
+using dense_file_array = osmium::index::map::DenseFileArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+template <class TSparseIndex>
+void test_index() {
+    const int fd = osmium::detail::create_tmp_file();
+    constexpr const size_t value_size = sizeof(typename TSparseIndex::element_type::second_type);
+    constexpr const size_t buffer_size = (10L * 1024L * 1024L) / value_size;
+
+    REQUIRE(osmium::file_size(fd) == 0);
+
+    std::vector<osmium::NodeRef> refs = {
+        osmium::NodeRef{1,                   osmium::Location{1.2, 4.5}},
+        osmium::NodeRef{6,                   osmium::Location{3.5, -7.2}},
+        osmium::NodeRef{2 * buffer_size,     osmium::Location{10.2, 64.5}},
+        osmium::NodeRef{2 * buffer_size + 1, osmium::Location{39.5, -71.2}},
+        osmium::NodeRef{3 * buffer_size - 1, osmium::Location{-1.2, 54.6}},
+        osmium::NodeRef{3 * buffer_size,     osmium::Location{-171.2, 9.3}},
+        osmium::NodeRef{3 * buffer_size + 1, osmium::Location{-171.21, 9.26}},
+        osmium::NodeRef{3 * buffer_size + 2, osmium::Location{-171.22, 9.25}},
+        osmium::NodeRef{3 * buffer_size + 3, osmium::Location{-171.24, 9.23}},
+        osmium::NodeRef{3 * buffer_size + 4, osmium::Location{-171.25, 9.22}},
+        osmium::NodeRef{3 * buffer_size + 5, osmium::Location{-171.26, 9.21}}
+    };
+
+    TSparseIndex sparse_index;
+    for (const auto& r : refs) {
+        sparse_index.set(r.ref(), r.location());
+    }
+    sparse_index.sort();
+    sparse_index.dump_as_array(fd);
+
+    dense_file_array dense_index{fd};
+    const auto max_id_in_refs = std::max_element(refs.begin(), refs.end())->ref();
+
+    // Array index should be as large as necessary.
+    REQUIRE(osmium::file_size(fd) >= max_id_in_refs * sizeof(osmium::Location));
+
+    // check beyond largest ID
+    REQUIRE_THROWS_AS(dense_index.get(max_id_in_refs + 1), osmium::not_found);
+
+    // check if written values can be retrieved
+    for (const auto& r : refs) {
+        REQUIRE(dense_index.get(r.ref()) == r.location());
+    }
+
+    // check if all other values are invalid locations
+    size_t invalid_count = 0;
+    for (osmium::object_id_type id = 0; id <= max_id_in_refs; ++id) {
+        if (!dense_index.get_noexcept(id).valid()) {
+            ++invalid_count;
+        }
+    }
+    REQUIRE(invalid_count == max_id_in_refs - refs.size() + 1);
+}
+
+
+#ifdef __linux__
+using sparse_mmap_array = osmium::index::map::SparseMmapArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump SparseMmapArray as array and load it as DenseFileArray") {
+    test_index<sparse_mmap_array>();
+}
+#else
+# pragma message("not running 'SparseMmapArray' test case on this machine")
+#endif
+
+using sparse_mem_array = osmium::index::map::SparseMemArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+TEST_CASE("Dump SparseMemArray as array and load it as DenseFileArray") {
+    test_index<sparse_mem_array>();
+}
+
diff --git a/third_party/libosmium/test/t/index/test_file_based_index.cpp b/third_party/libosmium/test/t/index/test_file_based_index.cpp
index 1489b825a..90e518fd8 100644
--- a/third_party/libosmium/test/t/index/test_file_based_index.cpp
+++ b/third_party/libosmium/test/t/index/test_file_based_index.cpp
@@ -8,6 +8,8 @@
 #include <osmium/osm/types.hpp>
 #include <osmium/util/file.hpp>
 
+#include <iterator>
+
 TEST_CASE("File based dense index") {
     const int fd = osmium::detail::create_tmp_file();
 
@@ -26,13 +28,13 @@ TEST_CASE("File based dense index") {
 
         REQUIRE(index.size() == 0);
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  3), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  6), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         index.set(id1, loc1);
         REQUIRE(index.size() == 7);
@@ -45,11 +47,11 @@ TEST_CASE("File based dense index") {
         REQUIRE(loc1 == index.get(id1));
         REQUIRE(loc2 == index.get(id2));
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         REQUIRE(index.size() == 7);
         REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
@@ -66,16 +68,16 @@ TEST_CASE("File based dense index") {
         REQUIRE(loc1 == index.get(id1));
         REQUIRE(loc2 == index.get(id2));
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         REQUIRE(index.size() == 7);
         REQUIRE(std::distance(index.cbegin(), index.cend()) == 7);
 
-        auto it = index.cbegin();
+        const auto* it = index.cbegin();
         REQUIRE(*it++ == osmium::Location{});
         REQUIRE(*it++ == osmium::Location{});
         REQUIRE(*it++ == osmium::Location{});
@@ -105,13 +107,13 @@ TEST_CASE("File based sparse index") {
 
         REQUIRE(index.size() == 0);
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  3), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  6), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  3), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  6), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         index.set(id1, loc1);
         REQUIRE(index.size() == 1);
@@ -124,11 +126,11 @@ TEST_CASE("File based sparse index") {
         REQUIRE(loc1 == index.get(id1));
         REQUIRE(loc2 == index.get(id2));
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         REQUIRE(index.size() == 2);
         REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
@@ -145,11 +147,11 @@ TEST_CASE("File based sparse index") {
         REQUIRE(loc1 == index.get(id1));
         REQUIRE(loc2 == index.get(id2));
 
-        REQUIRE_THROWS_AS(index.get(  0), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  1), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  5), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(  7), const osmium::not_found&);
-        REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+        REQUIRE_THROWS_AS(index.get(  0), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  1), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  5), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(  7), osmium::not_found);
+        REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
         REQUIRE(index.size() == 2);
         REQUIRE(std::distance(index.cbegin(), index.cend()) == 2);
diff --git a/third_party/libosmium/test/t/index/test_id_set.cpp b/third_party/libosmium/test/t/index/test_id_set.cpp
index 33d9325a9..cc80d6b91 100644
--- a/third_party/libosmium/test/t/index/test_id_set.cpp
+++ b/third_party/libosmium/test/t/index/test_id_set.cpp
@@ -43,15 +43,42 @@ TEST_CASE("Basic functionality of IdSetDense") {
     REQUIRE(s.empty());
 }
 
+TEST_CASE("Copying IdSetDense") {
+    osmium::index::IdSetDense<osmium::unsigned_object_id_type> s1;
+    osmium::index::IdSetDense<osmium::unsigned_object_id_type> s2;
+
+    REQUIRE(s1.empty());
+    REQUIRE(s2.empty());
+
+    s1.set(17);
+    s1.set(28);
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.size() == 2);
+
+    s2 = s1;
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.get(28));
+    REQUIRE(s1.size() == 2);
+    REQUIRE(s2.get(17));
+    REQUIRE(s2.get(28));
+    REQUIRE(s2.size() == 2);
+
+    osmium::index::IdSetDense<osmium::unsigned_object_id_type> s3{s1};
+    REQUIRE(s3.get(17));
+    REQUIRE(s3.get(28));
+    REQUIRE(s3.size() == 2);
+}
+
 TEST_CASE("Iterating over IdSetDense") {
     osmium::index::IdSetDense<osmium::unsigned_object_id_type> s;
     s.set(7);
     s.set(35);
     s.set(35);
     s.set(20);
-    s.set(1ull << 33u);
+    s.set(1ULL << 33U);
     s.set(21);
-    s.set((1ull << 27u) + 13u);
+    s.set((1ULL << 27U) + 13U);
 
     REQUIRE(s.size() == 6);
 
@@ -69,10 +96,10 @@ TEST_CASE("Iterating over IdSetDense") {
     REQUIRE(*it == 35);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == (1ull << 27u) + 13u);
+    REQUIRE(*it == (1ULL << 27U) + 13U);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == 1ull << 33u);
+    REQUIRE(*it == 1ULL << 33U);
     ++it;
     REQUIRE(it == s.end());
 }
@@ -98,10 +125,10 @@ TEST_CASE("Large gap") {
     osmium::index::IdSetDense<osmium::unsigned_object_id_type> s;
 
     s.set(3);
-    s.set(1u << 30u);
+    s.set(1U << 30U);
 
-    REQUIRE(s.get(1u << 30u));
-    REQUIRE_FALSE(s.get(1u << 29u));
+    REQUIRE(s.get(1U << 30U));
+    REQUIRE_FALSE(s.get(1U << 29U));
 }
 
 TEST_CASE("Basic functionality of IdSetSmall") {
@@ -120,20 +147,55 @@ TEST_CASE("Basic functionality of IdSetSmall") {
     REQUIRE(s.get(17));
     REQUIRE(s.get(28));
     REQUIRE_FALSE(s.empty());
+    const auto size = s.size();
+
+    // Setting the same id as last time doesn't grow the size
+    s.set(28);
+    REQUIRE(s.get(17));
+    REQUIRE(s.get(28));
+    REQUIRE_FALSE(s.empty());
+    REQUIRE(size == s.size());
 
     s.clear();
     REQUIRE(s.empty());
 }
 
+TEST_CASE("Copying IdSetSmall") {
+    osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s1;
+    osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s2;
+
+    REQUIRE(s1.empty());
+    REQUIRE(s2.empty());
+
+    s1.set(17);
+    s1.set(28);
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.size() == 2);
+
+    s2 = s1;
+    REQUIRE(s1.get(17));
+    REQUIRE(s1.get(28));
+    REQUIRE(s1.size() == 2);
+    REQUIRE(s2.get(17));
+    REQUIRE(s2.get(28));
+    REQUIRE(s2.size() == 2);
+
+    osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s3{s1};
+    REQUIRE(s3.get(17));
+    REQUIRE(s3.get(28));
+    REQUIRE(s3.size() == 2);
+}
+
 TEST_CASE("Iterating over IdSetSmall") {
     osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s;
     s.set(7);
     s.set(35);
     s.set(35);
     s.set(20);
-    s.set(1ull << 33u);
+    s.set(1ULL << 33U);
     s.set(21);
-    s.set((1ull << 27u) + 13u);
+    s.set((1ULL << 27U) + 13U);
 
     // needs to be called before size() and iterator will work properly
     s.sort_unique();
@@ -154,11 +216,39 @@ TEST_CASE("Iterating over IdSetSmall") {
     REQUIRE(*it == 35);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == (1ull << 27u) + 13u);
+    REQUIRE(*it == (1ULL << 27U) + 13U);
     ++it;
     REQUIRE(it != s.end());
-    REQUIRE(*it == 1ull << 33u);
+    REQUIRE(*it == 1ULL << 33U);
     ++it;
     REQUIRE(it == s.end());
 }
 
+TEST_CASE("Merge two IdSetSmall") {
+    osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s1;
+    osmium::index::IdSetSmall<osmium::unsigned_object_id_type> s2;
+
+    s1.set(23);
+    s1.set(2);
+    s1.set(7);
+    s1.set(55);
+    s1.set(42);
+    s1.set(7);
+
+    s2.set(2);
+    s2.set(32);
+    s2.set(8);
+    s2.set(55);
+    s2.set(1);
+
+    s1.sort_unique();
+    REQUIRE(s1.size() == 5);
+    s2.sort_unique();
+    REQUIRE(s2.size() == 5);
+    s1.merge_sorted(s2);
+    REQUIRE(s1.size() == 8);
+
+    const auto ids = {1, 2, 7, 8, 23, 32, 42, 55};
+    REQUIRE(std::equal(s1.cbegin(), s1.cend(), ids.begin()));
+}
+
diff --git a/third_party/libosmium/test/t/index/test_id_to_location.cpp b/third_party/libosmium/test/t/index/test_id_to_location.cpp
index f3416d556..f00ae1b9a 100644
--- a/third_party/libosmium/test/t/index/test_id_to_location.cpp
+++ b/third_party/libosmium/test/t/index/test_id_to_location.cpp
@@ -8,12 +8,15 @@
 #include <osmium/index/map/sparse_file_array.hpp>
 #include <osmium/index/map/sparse_mem_array.hpp>
 #include <osmium/index/map/sparse_mem_map.hpp>
-#include <osmium/index/map/sparse_mem_table.hpp>
 #include <osmium/index/map/sparse_mmap_array.hpp>
 #include <osmium/index/node_locations_map.hpp>
 #include <osmium/osm/location.hpp>
 #include <osmium/osm/types.hpp>
 
+#include <memory>
+#include <string>
+#include <vector>
+
 static_assert(osmium::index::empty_value<osmium::Location>() == osmium::Location{}, "Empty value for location is wrong");
 
 template <typename TIndex>
@@ -23,17 +26,17 @@ void test_func_all(TIndex& index) {
     const osmium::Location loc1{1.2, 4.5};
     const osmium::Location loc2{3.5, -7.2};
 
-    REQUIRE_THROWS_AS(index.get(id1), const osmium::not_found&);
+    REQUIRE_THROWS_AS(index.get(id1), osmium::not_found);
 
     index.set(id1, loc1);
     index.set(id2, loc2);
 
     index.sort();
 
-    REQUIRE_THROWS_AS(index.get(0), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(1), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(5), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+    REQUIRE_THROWS_AS(index.get(0), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(1), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(5), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
     REQUIRE_THROWS_WITH(index.get(0), "id 0 not found");
     REQUIRE_THROWS_WITH(index.get(1), "id 1 not found");
 
@@ -61,10 +64,10 @@ void test_func_real(TIndex& index) {
     REQUIRE(loc1 == index.get_noexcept(id1));
     REQUIRE(loc2 == index.get_noexcept(id2));
 
-    REQUIRE_THROWS_AS(index.get(0), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(1), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(5), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+    REQUIRE_THROWS_AS(index.get(0), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(1), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(5), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
     REQUIRE(index.get_noexcept(0) == osmium::Location{});
     REQUIRE(index.get_noexcept(1) == osmium::Location{});
@@ -73,13 +76,13 @@ void test_func_real(TIndex& index) {
 
     index.clear();
 
-    REQUIRE_THROWS_AS(index.get(id1), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(id2), const osmium::not_found&);
+    REQUIRE_THROWS_AS(index.get(id1), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(id2), osmium::not_found);
 
-    REQUIRE_THROWS_AS(index.get(0), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(1), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(5), const osmium::not_found&);
-    REQUIRE_THROWS_AS(index.get(100), const osmium::not_found&);
+    REQUIRE_THROWS_AS(index.get(0), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(1), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(5), osmium::not_found);
+    REQUIRE_THROWS_AS(index.get(100), osmium::not_found);
 
     REQUIRE(index.get_noexcept(id1) == osmium::Location{});
     REQUIRE(index.get_noexcept(id2) == osmium::Location{});
@@ -126,7 +129,7 @@ TEST_CASE("Map Id to location: DenseMmapArray") {
     test_func_real<index_type>(index2);
 }
 #else
-# pragma message("not running 'DenseMapMmap' test case on this machine")
+# pragma message("not running 'DenseMmapArray' test case on this machine")
 #endif
 
 TEST_CASE("Map Id to location: DenseFileArray") {
@@ -139,20 +142,6 @@ TEST_CASE("Map Id to location: DenseFileArray") {
     test_func_real<index_type>(index2);
 }
 
-#ifdef OSMIUM_WITH_SPARSEHASH
-
-TEST_CASE("Map Id to location: SparseMemTable") {
-    using index_type = osmium::index::map::SparseMemTable<osmium::unsigned_object_id_type, osmium::Location>;
-
-    index_type index1;
-    test_func_all<index_type>(index1);
-
-    index_type index2;
-    test_func_real<index_type>(index2);
-}
-
-#endif
-
 TEST_CASE("Map Id to location: SparseMemMap") {
     using index_type = osmium::index::map::SparseMemMap<osmium::unsigned_object_id_type, osmium::Location>;
 
@@ -179,6 +168,20 @@ TEST_CASE("Map Id to location: SparseMemArray") {
     test_func_real<index_type>(index2);
 }
 
+#ifdef __linux__
+TEST_CASE("Map Id to location: SparseMmapArray") {
+    using index_type = osmium::index::map::SparseMmapArray<osmium::unsigned_object_id_type, osmium::Location>;
+
+    index_type index1;
+    test_func_all<index_type>(index1);
+
+    index_type index2;
+    test_func_real<index_type>(index2);
+}
+#else
+# pragma message("not running 'SparseMmapArray' test case on this machine")
+#endif
+
 TEST_CASE("Map Id to location: FlexMem sparse") {
     using index_type = osmium::index::map::FlexMem<osmium::unsigned_object_id_type, osmium::Location>;
 
@@ -238,8 +241,8 @@ TEST_CASE("Map Id to location: Dynamic map choice") {
     const std::vector<std::string> map_type_names = map_factory.map_types();
     REQUIRE(map_type_names.size() >= 6);
 
-    REQUIRE_THROWS_AS(map_factory.create_map(""), const osmium::map_factory_error&);
-    REQUIRE_THROWS_AS(map_factory.create_map("does not exist"), const osmium::map_factory_error&);
+    REQUIRE_THROWS_AS(map_factory.create_map(""), osmium::map_factory_error);
+    REQUIRE_THROWS_AS(map_factory.create_map("does not exist"), osmium::map_factory_error);
     REQUIRE_THROWS_WITH(map_factory.create_map(""), "Need non-empty map type name");
     REQUIRE_THROWS_WITH(map_factory.create_map("does not exist"), "Support for map type 'does not exist' not compiled into this binary");
 
diff --git a/third_party/libosmium/test/t/index/test_nwr_array.cpp b/third_party/libosmium/test/t/index/test_nwr_array.cpp
new file mode 100644
index 000000000..ca0fc5fab
--- /dev/null
+++ b/third_party/libosmium/test/t/index/test_nwr_array.cpp
@@ -0,0 +1,21 @@
+#include "catch.hpp"
+
+#include <osmium/index/nwr_array.hpp>
+
+TEST_CASE("nwr_array") {
+    osmium::nwr_array<int> a;
+    a(osmium::item_type::node) = 1;
+    a(osmium::item_type::way) = 2;
+    a(osmium::item_type::relation) = 3;
+
+    REQUIRE(a(osmium::item_type::node) == 1);
+    REQUIRE(a(osmium::item_type::way) == 2);
+    REQUIRE(a(osmium::item_type::relation) == 3);
+
+    auto it = a.cbegin();
+    REQUIRE(*it++ == 1);
+    REQUIRE(*it++ == 2);
+    REQUIRE(*it++ == 3);
+    REQUIRE(it == a.cend());
+}
+
diff --git a/third_party/libosmium/test/t/io/corrupt_data_bzip2.txt.bz2 b/third_party/libosmium/test/t/io/corrupt_data_bzip2.txt.bz2
new file mode 100644
index 000000000..c602e27e4
Binary files /dev/null and b/third_party/libosmium/test/t/io/corrupt_data_bzip2.txt.bz2 differ
diff --git a/third_party/libosmium/test/t/io/data-cr.opl b/third_party/libosmium/test/t/io/data-cr.opl
new file mode 100644
index 000000000..2c7e2a35f
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-cr.opl
@@ -0,0 +1 @@
+n1 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.02 y1.02
diff --git a/third_party/libosmium/test/t/io/data-n0w1r3.osm b/third_party/libosmium/test/t/io/data-n0w1r3.osm
new file mode 100644
index 000000000..86a01c621
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n0w1r3.osm
@@ -0,0 +1,22 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="testdata" upload="false">
+    <way id="20" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="highway" v="primary"/>
+        <nd ref="10"/>
+        <nd ref="11"/>
+    </way>
+    <relation id="30" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="test"/>
+        <member type="node" ref="10" role="none"/>
+    </relation>
+    <relation id="31" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="restriction"/>
+        <member type="way" ref="20" role="from"/>
+        <member type="node" ref="11" role="via"/>
+        <member type="way" ref="22" role="to"/>
+    </relation>
+    <relation id="32" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="test" v="relinrel"/>
+        <member type="relation" ref="30" role="none"/>
+    </relation>
+</osm>
diff --git a/third_party/libosmium/test/t/io/data-n0w1r3.osm.o5m b/third_party/libosmium/test/t/io/data-n0w1r3.osm.o5m
new file mode 100644
index 000000000..0b76653e1
Binary files /dev/null and b/third_party/libosmium/test/t/io/data-n0w1r3.osm.o5m differ
diff --git a/third_party/libosmium/test/t/io/data-n0w1r3.osm.opl b/third_party/libosmium/test/t/io/data-n0w1r3.osm.opl
new file mode 100644
index 000000000..4c515c0e0
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n0w1r3.osm.opl
@@ -0,0 +1,4 @@
+w20 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Thighway=primary Nn10,n11
+r30 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=test Mn10@none
+r31 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=restriction Mw20@from,n11@via,w22@to
+r32 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttest=relinrel Mr30@none
diff --git a/third_party/libosmium/test/t/io/data-n5w0r3.osm b/third_party/libosmium/test/t/io/data-n5w0r3.osm
new file mode 100644
index 000000000..3c30e2d8c
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w0r3.osm
@@ -0,0 +1,22 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="testdata" upload="false">
+    <node id="10" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.0"/>
+    <node id="11" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.1"/>
+    <node id="12" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.2"/>
+    <node id="13" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.3"/>
+    <node id="14" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.4"/>
+    <relation id="30" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="test"/>
+        <member type="node" ref="10" role="none"/>
+    </relation>
+    <relation id="31" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="restriction"/>
+        <member type="way" ref="20" role="from"/>
+        <member type="node" ref="11" role="via"/>
+        <member type="way" ref="22" role="to"/>
+    </relation>
+    <relation id="32" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="test" v="relinrel"/>
+        <member type="relation" ref="30" role="none"/>
+    </relation>
+</osm>
diff --git a/third_party/libosmium/test/t/io/data-n5w0r3.osm.o5m b/third_party/libosmium/test/t/io/data-n5w0r3.osm.o5m
new file mode 100644
index 000000000..4606e9995
Binary files /dev/null and b/third_party/libosmium/test/t/io/data-n5w0r3.osm.o5m differ
diff --git a/third_party/libosmium/test/t/io/data-n5w0r3.osm.opl b/third_party/libosmium/test/t/io/data-n5w0r3.osm.opl
new file mode 100644
index 000000000..5d5c7ba94
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w0r3.osm.opl
@@ -0,0 +1,8 @@
+n10 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1 y1
+n11 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.1 y1
+n12 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.2 y1
+n13 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.3 y1
+n14 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.4 y1
+r30 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=test Mn10@none
+r31 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=restriction Mw20@from,n11@via,w22@to
+r32 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttest=relinrel Mr30@none
diff --git a/third_party/libosmium/test/t/io/data-n5w1r0.osm b/third_party/libosmium/test/t/io/data-n5w1r0.osm
new file mode 100644
index 000000000..13c39d307
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w1r0.osm
@@ -0,0 +1,13 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="testdata" upload="false">
+    <node id="10" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.0"/>
+    <node id="11" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.1"/>
+    <node id="12" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.2"/>
+    <node id="13" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.3"/>
+    <node id="14" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.4"/>
+    <way id="20" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="highway" v="primary"/>
+        <nd ref="10"/>
+        <nd ref="11"/>
+    </way>
+</osm>
diff --git a/third_party/libosmium/test/t/io/data-n5w1r0.osm.o5m b/third_party/libosmium/test/t/io/data-n5w1r0.osm.o5m
new file mode 100644
index 000000000..b2e049512
Binary files /dev/null and b/third_party/libosmium/test/t/io/data-n5w1r0.osm.o5m differ
diff --git a/third_party/libosmium/test/t/io/data-n5w1r0.osm.opl b/third_party/libosmium/test/t/io/data-n5w1r0.osm.opl
new file mode 100644
index 000000000..1dd89da39
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w1r0.osm.opl
@@ -0,0 +1,6 @@
+n10 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1 y1
+n11 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.1 y1
+n12 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.2 y1
+n13 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.3 y1
+n14 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.4 y1
+w20 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Thighway=primary Nn10,n11
diff --git a/third_party/libosmium/test/t/io/data-n5w1r3.osm b/third_party/libosmium/test/t/io/data-n5w1r3.osm
new file mode 100644
index 000000000..5f338a0ba
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w1r3.osm
@@ -0,0 +1,27 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="testdata" upload="false">
+    <node id="10" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.0"/>
+    <node id="11" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.1"/>
+    <node id="12" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.2"/>
+    <node id="13" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.3"/>
+    <node id="14" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.4"/>
+    <way id="20" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="highway" v="primary"/>
+        <nd ref="10"/>
+        <nd ref="11"/>
+    </way>
+    <relation id="30" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="test"/>
+        <member type="node" ref="10" role="none"/>
+    </relation>
+    <relation id="31" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="restriction"/>
+        <member type="way" ref="20" role="from"/>
+        <member type="node" ref="11" role="via"/>
+        <member type="way" ref="22" role="to"/>
+    </relation>
+    <relation id="32" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="test" v="relinrel"/>
+        <member type="relation" ref="30" role="none"/>
+    </relation>
+</osm>
diff --git a/third_party/libosmium/test/t/io/data-n5w1r3.osm.o5m b/third_party/libosmium/test/t/io/data-n5w1r3.osm.o5m
new file mode 100644
index 000000000..d3fc62106
Binary files /dev/null and b/third_party/libosmium/test/t/io/data-n5w1r3.osm.o5m differ
diff --git a/third_party/libosmium/test/t/io/data-n5w1r3.osm.opl b/third_party/libosmium/test/t/io/data-n5w1r3.osm.opl
new file mode 100644
index 000000000..85d76b345
--- /dev/null
+++ b/third_party/libosmium/test/t/io/data-n5w1r3.osm.opl
@@ -0,0 +1,9 @@
+n10 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1 y1
+n11 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.1 y1
+n12 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.2 y1
+n13 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.3 y1
+n14 v1 dV c1 t2014-01-01T00:00:00Z i1 utest T x1.4 y1
+w20 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Thighway=primary Nn10,n11
+r30 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=test Mn10@none
+r31 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttype=restriction Mw20@from,n11@via,w22@to
+r32 v1 dV c1 t2014-01-01T00:00:00Z i1 utest Ttest=relinrel Mr30@none
diff --git a/third_party/libosmium/test/t/io/data_bzip2.txt b/third_party/libosmium/test/t/io/data.txt
similarity index 100%
rename from third_party/libosmium/test/t/io/data_bzip2.txt
rename to third_party/libosmium/test/t/io/data.txt
diff --git a/third_party/libosmium/test/t/io/empty_file b/third_party/libosmium/test/t/io/empty_file
new file mode 100644
index 000000000..e69de29bb
diff --git a/third_party/libosmium/test/t/io/test_bzip2.cpp b/third_party/libosmium/test/t/io/test_bzip2.cpp
index 256d012db..8f4088a1e 100644
--- a/third_party/libosmium/test/t/io/test_bzip2.cpp
+++ b/third_party/libosmium/test/t/io/test_bzip2.cpp
@@ -3,15 +3,63 @@
 #include "utils.hpp"
 
 #include <osmium/io/bzip2_compression.hpp>
+#include <osmium/io/detail/read_write.hpp>
 
-#include <fcntl.h>
-#include <sys/stat.h>
-#include <sys/types.h>
+#include <string>
+
+TEST_CASE("Invalid file descriptor of bzip2-compressed file") {
+    REQUIRE_THROWS_AS(osmium::io::Bzip2Decompressor{-1}, std::system_error);
+}
+
+TEST_CASE("Non-open file descriptor of bzip2-compressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    REQUIRE_THROWS_AS(osmium::io::Bzip2Decompressor{12345}, std::system_error);
+}
+
+TEST_CASE("Empty bzip2-compressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/empty_file");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    osmium::io::Bzip2Decompressor decomp{fd};
+    REQUIRE_THROWS_AS(decomp.read(), osmium::bzip2_error);
+    decomp.close();
+
+    REQUIRE(count == count_fds());
+}
 
 TEST_CASE("Read bzip2-compressed file") {
-    const std::string input_file = with_data_dir("t/io/data_bzip2.txt.bz2");
+    const int count = count_fds();
 
-    const int fd = ::open(input_file.c_str(), O_RDONLY);
+    const std::string input_file = with_data_dir("t/io/data_bzip2.txt.bz2");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    size_t size = 0;
+    std::string all;
+    {
+        osmium::io::Bzip2Decompressor decomp{fd};
+        for (std::string data = decomp.read(); !data.empty(); data = decomp.read()) {
+            size += data.size();
+            all += data;
+        }
+        decomp.close();
+    }
+
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Read bzip2-compressed file without explicit close") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/data_bzip2.txt.bz2");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
     REQUIRE(fd > 0);
 
     size_t size = 0;
@@ -24,7 +72,65 @@ TEST_CASE("Read bzip2-compressed file") {
         }
     }
 
-    REQUIRE(9 == size);
-    REQUIRE("TESTDATA\n" == all);
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Corrupted bzip2-compressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/corrupt_data_bzip2.txt.bz2");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    osmium::io::Bzip2Decompressor decomp{fd};
+    REQUIRE_THROWS_AS(decomp.read(), osmium::bzip2_error);
+    decomp.close();
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Compressor: Invalid file descriptor for bzip2-compressed file") {
+    REQUIRE_THROWS_AS(osmium::io::Bzip2Compressor(-1, osmium::io::fsync::yes), std::system_error);
+}
+
+TEST_CASE("Compressor: Non-open file descriptor for bzip2-compressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    REQUIRE_THROWS_AS(osmium::io::Bzip2Compressor(12345, osmium::io::fsync::yes), std::system_error);
+}
+
+TEST_CASE("Write bzip2-compressed file with explicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_gzip_out.txt.bz2";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    osmium::io::Bzip2Compressor comp{fd, osmium::io::fsync::yes};
+    comp.write("foo");
+    comp.close();
+
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) > 10);
+}
+
+TEST_CASE("Write bzip2-compressed file with implicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_gzip_out.txt.bz2";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    {
+        osmium::io::Bzip2Compressor comp{fd, osmium::io::fsync::yes};
+        comp.write("foo");
+    }
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) > 10);
 }
 
diff --git a/third_party/libosmium/test/t/io/test_compression_factory.cpp b/third_party/libosmium/test/t/io/test_compression_factory.cpp
index 9bfd4a52e..ff8bc0e83 100644
--- a/third_party/libosmium/test/t/io/test_compression_factory.cpp
+++ b/third_party/libosmium/test/t/io/test_compression_factory.cpp
@@ -15,7 +15,7 @@ TEST_CASE("Create decompressor using factory") {
 TEST_CASE("Compression factory fails on undefined compression") {
     const auto& factory = osmium::io::CompressionFactory::instance();
     REQUIRE_THROWS_AS(factory.create_compressor(osmium::io::file_compression::gzip, -1, osmium::io::fsync::no),
-                      const osmium::unsupported_file_format_error&);
+                      osmium::unsupported_file_format_error);
     REQUIRE_THROWS_WITH(factory.create_compressor(osmium::io::file_compression::gzip, -1, osmium::io::fsync::no),
                         "Support for compression 'gzip' not compiled into this binary");
 }
diff --git a/third_party/libosmium/test/t/io/test_file_formats.cpp b/third_party/libosmium/test/t/io/test_file_formats.cpp
index fc2517ac6..5dc657510 100644
--- a/third_party/libosmium/test/t/io/test_file_formats.cpp
+++ b/third_party/libosmium/test/t/io/test_file_formats.cpp
@@ -3,13 +3,14 @@
 #include <osmium/io/file.hpp>
 
 #include <iterator>
+#include <stdexcept>
 
 TEST_CASE("Default file format") {
     const osmium::io::File f;
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
     REQUIRE_FALSE(f.has_multiple_object_versions());
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("File format when empty (stdin/stdout)") {
@@ -17,7 +18,7 @@ TEST_CASE("File format when empty (stdin/stdout)") {
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
     REQUIRE_FALSE(f.has_multiple_object_versions());
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("File format from dash (stdin/stdout)") {
@@ -25,7 +26,7 @@ TEST_CASE("File format from dash (stdin/stdout)") {
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
     REQUIRE_FALSE(f.has_multiple_object_versions());
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("File format from dash with osm.bz2") {
@@ -267,22 +268,22 @@ TEST_CASE("Unknown format 'foo.bar'") {
     const osmium::io::File f{"test.foo.bar"};
     REQUIRE(osmium::io::file_format::unknown == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("Unknown format 'foo'") {
     const osmium::io::File f{"test", "foo"};
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("Unknown format 'osm.foo'") {
     const osmium::io::File f{"test", "osm.foo"};
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("Unknown format 'bla=foo'") {
     const osmium::io::File f{"test", "bla=foo"};
-    REQUIRE_THROWS_AS(f.check(), const std::runtime_error&);
+    REQUIRE_THROWS_AS(f.check(), std::runtime_error);
 }
 
 TEST_CASE("URL without format") {
@@ -294,7 +295,7 @@ TEST_CASE("URL without format") {
 }
 
 TEST_CASE("URL without format and filename") {
-    const osmium::io::File f{"http://planet.osm.org/pbf/planet-latest.osm.pbf"};
+    const osmium::io::File f{"https://planet.osm.org/pbf/planet-latest.osm.pbf"};
     REQUIRE(osmium::io::file_format::pbf == f.format());
     REQUIRE(osmium::io::file_compression::none == f.compression());
     REQUIRE_FALSE(f.has_multiple_object_versions());
diff --git a/third_party/libosmium/test/t/io/test_gzip.cpp b/third_party/libosmium/test/t/io/test_gzip.cpp
new file mode 100644
index 000000000..874f1cc4b
--- /dev/null
+++ b/third_party/libosmium/test/t/io/test_gzip.cpp
@@ -0,0 +1,137 @@
+#include "catch.hpp"
+
+#include "utils.hpp"
+
+#include <osmium/io/detail/read_write.hpp>
+#include <osmium/io/gzip_compression.hpp>
+
+#include <string>
+
+TEST_CASE("Invalid file descriptor of gzip-compressed file") {
+    REQUIRE_THROWS_AS(osmium::io::GzipDecompressor{-1}, osmium::gzip_error);
+}
+
+TEST_CASE("Non-open file descriptor of gzip-compressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    osmium::io::GzipDecompressor decomp{12345};
+    REQUIRE_THROWS_AS(decomp.read(), osmium::gzip_error);
+}
+
+TEST_CASE("Empty gzip-compressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/empty_file");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    osmium::io::GzipDecompressor decomp{fd};
+    REQUIRE(decomp.read().empty());
+    decomp.close();
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Read gzip-compressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/data_gzip.txt.gz");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    size_t size = 0;
+    std::string all;
+    {
+        osmium::io::GzipDecompressor decomp{fd};
+        for (std::string data = decomp.read(); !data.empty(); data = decomp.read()) {
+            size += data.size();
+            all += data;
+        }
+        decomp.close();
+    }
+
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Read gzip-compressed file without explicit close") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/data_gzip.txt.gz");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    size_t size = 0;
+    std::string all;
+    {
+        osmium::io::GzipDecompressor decomp{fd};
+        for (std::string data = decomp.read(); !data.empty(); data = decomp.read()) {
+            size += data.size();
+            all += data;
+        }
+    }
+
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Corrupted gzip-compressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/corrupt_data_gzip.txt.gz");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    osmium::io::GzipDecompressor decomp{fd};
+    decomp.read();
+    REQUIRE_THROWS_AS(decomp.close(), osmium::gzip_error);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Compressor: Invalid file descriptor for gzip-compressed file") {
+    REQUIRE_THROWS_AS(osmium::io::GzipCompressor(-1, osmium::io::fsync::yes), std::system_error);
+}
+
+TEST_CASE("Compressor: Non-open file descriptor for gzip-compressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    REQUIRE_THROWS_AS(osmium::io::GzipCompressor(12345, osmium::io::fsync::yes), std::system_error);
+}
+
+TEST_CASE("Write gzip-compressed file with explicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_gzip_out.txt.gz";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    osmium::io::GzipCompressor comp{fd, osmium::io::fsync::yes};
+    comp.write("foo");
+    comp.close();
+
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) > 10);
+}
+
+TEST_CASE("Write gzip-compressed file with implicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_gzip_out.txt.gz";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    {
+        osmium::io::GzipCompressor comp{fd, osmium::io::fsync::yes};
+        comp.write("foo");
+    }
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) > 10);
+}
+
diff --git a/third_party/libosmium/test/t/io/test_nocompression.cpp b/third_party/libosmium/test/t/io/test_nocompression.cpp
new file mode 100644
index 000000000..4f9b78074
--- /dev/null
+++ b/third_party/libosmium/test/t/io/test_nocompression.cpp
@@ -0,0 +1,125 @@
+#include "catch.hpp"
+
+#include "utils.hpp"
+
+#include <osmium/io/compression.hpp>
+
+#include <string>
+
+TEST_CASE("Invalid file descriptor of uncompressed file") {
+    osmium::io::NoDecompressor decomp{-1};
+    REQUIRE_THROWS_AS(decomp.read(), std::system_error);
+}
+
+TEST_CASE("Non-open file descriptor of uncompressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    osmium::io::NoDecompressor decomp{12345};
+    REQUIRE_THROWS_AS(decomp.read(), std::system_error);
+}
+
+TEST_CASE("Empty uncompressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/empty_file");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    osmium::io::NoDecompressor decomp{fd};
+    REQUIRE(decomp.read().empty());
+    decomp.close();
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Read uncompressed file") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/data.txt");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    size_t size = 0;
+    std::string all;
+    {
+        osmium::io::NoDecompressor decomp{fd};
+        for (std::string data = decomp.read(); !data.empty(); data = decomp.read()) {
+            size += data.size();
+            all += data;
+        }
+        decomp.close();
+    }
+
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Read uncompressed file without explicit close") {
+    const int count = count_fds();
+
+    const std::string input_file = with_data_dir("t/io/data.txt");
+    const int fd = osmium::io::detail::open_for_reading(input_file);
+    REQUIRE(fd > 0);
+
+    size_t size = 0;
+    std::string all;
+    {
+        osmium::io::NoDecompressor decomp{fd};
+        for (std::string data = decomp.read(); !data.empty(); data = decomp.read()) {
+            size += data.size();
+            all += data;
+        }
+    }
+
+    REQUIRE(size >= 9);
+    all.resize(8);
+    REQUIRE("TESTDATA" == all);
+
+    REQUIRE(count == count_fds());
+}
+
+TEST_CASE("Compressor: Invalid file descriptor for uncompressed file") {
+    osmium::io::NoCompressor comp{-1, osmium::io::fsync::yes};
+    REQUIRE_THROWS_AS(comp.write("foo"), std::system_error);
+}
+
+TEST_CASE("Compressor: Non-open file descriptor for uncompressed file") {
+    // 12345 is just a random file descriptor that should not be open
+    osmium::io::NoCompressor comp{12345, osmium::io::fsync::yes};
+    REQUIRE_THROWS_AS(comp.write("foo"), std::system_error);
+}
+
+TEST_CASE("Write uncompressed file with explicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_uncompressed_out.txt";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    osmium::io::NoCompressor comp{fd, osmium::io::fsync::yes};
+    comp.write("foo");
+    comp.close();
+
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) == 3);
+}
+
+TEST_CASE("Write uncompressed file with implicit close") {
+    const int count = count_fds();
+
+    const std::string output_file = "test_uncompressed_out.txt";
+    const int fd = osmium::io::detail::open_for_writing(output_file, osmium::io::overwrite::allow);
+    REQUIRE(fd > 0);
+
+    {
+        osmium::io::NoCompressor comp{fd, osmium::io::fsync::yes};
+        comp.write("foo");
+    }
+    REQUIRE(count == count_fds());
+
+    REQUIRE(osmium::file_size(output_file) == 3);
+}
+
diff --git a/third_party/libosmium/test/t/io/test_opl_parser.cpp b/third_party/libosmium/test/t/io/test_opl_parser.cpp
index 5d13bb12d..24d2def62 100644
--- a/third_party/libosmium/test/t/io/test_opl_parser.cpp
+++ b/third_party/libosmium/test/t/io/test_opl_parser.cpp
@@ -8,9 +8,23 @@
 
 #include <algorithm>
 #include <cstring>
+#include <initializer_list>
+#include <string>
+#include <vector>
 
 namespace oid = osmium::io::detail;
 
+// From C++20 we need to handle unicode literals differently
+#ifdef __cpp_char8_t
+static const char* u8cast(const char8_t *s) noexcept {
+    return reinterpret_cast<const char*>(s);
+}
+#else
+static const char* u8cast(const char *s) noexcept {
+    return s;
+}
+#endif
+
 TEST_CASE("Parse OPL: base exception") {
     const osmium::opl_error e{"foo"};
     REQUIRE(e.data == nullptr);
@@ -35,13 +49,13 @@ TEST_CASE("Parse OPL: space") {
     const std::string d{"a b \t c"};
 
     const char* s = d.data();
-    REQUIRE_THROWS_AS(oid::opl_parse_space(&s), const osmium::opl_error&);
+    REQUIRE_THROWS_AS(oid::opl_parse_space(&s), osmium::opl_error);
 
     s = d.data() + 1;
     oid::opl_parse_space(&s);
     REQUIRE(*s == 'b');
 
-    REQUIRE_THROWS_AS(oid::opl_parse_space(&s), const osmium::opl_error&);
+    REQUIRE_THROWS_AS(oid::opl_parse_space(&s), osmium::opl_error);
 
     ++s;
     oid::opl_parse_space(&s);
@@ -101,7 +115,7 @@ TEST_CASE("Parse OPL: parse escaped") {
         const char* e = s + std::strlen(s);
         oid::opl_parse_escaped(&s, result);
         REQUIRE(result.size() == 1);
-        REQUIRE(result[0] == '\0');
+        REQUIRE(result[0] == '%');
         REQUIRE(s == e);
     }
 
@@ -141,7 +155,7 @@ TEST_CASE("Parse OPL: parse escaped") {
         result.append("_");
         const char* s3 = "1f6eb%";
         oid::opl_parse_escaped(&s3, result);
-        REQUIRE(result == u8"\u30dc_\U0001d11e_\U0001f6eb");
+        REQUIRE(result == u8cast(u8"\u30dc_\U0001d11e_\U0001f6eb"));
     }
 
     SECTION("Data after %") {
@@ -257,6 +271,12 @@ TEST_CASE("Parse OPL: integer") {
     REQUIRE(test_parse_int("-1x") == -1);
     REQUIRE(test_parse_int("1234567890123x") == 1234567890123);
     REQUIRE(test_parse_int("-1234567890123x") == -1234567890123);
+    REQUIRE(test_parse_int("999999999999999999x") == 999999999999999999);
+    REQUIRE(test_parse_int("-999999999999999999x") == -999999999999999999);
+    REQUIRE(test_parse_int("1000000000000000000x") == 1000000000000000000);
+    REQUIRE(test_parse_int("9223372036854775807x") == 9223372036854775807);
+    REQUIRE(test_parse_int("-9223372036854775807x") == -9223372036854775807);
+    REQUIRE(test_parse_int("-9223372036854775808x") == -9223372036854775807 - 1);
 
     REQUIRE_THROWS_WITH(test_parse_int(""),
                         "OPL error: expected integer");
@@ -270,7 +290,25 @@ TEST_CASE("Parse OPL: integer") {
     REQUIRE_THROWS_WITH(test_parse_int("x"),
                         "OPL error: expected integer");
 
-    REQUIRE_THROWS_WITH(test_parse_int("99999999999999999999999x"),
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775808x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775809x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775810x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-9223372036854775809x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-9223372036854775810x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("999999999999999999999x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-999999999999999999999x"),
                         "OPL error: integer too long");
 }
 
@@ -455,12 +493,12 @@ TEST_CASE("Parse OPL: nodes") {
         REQUIRE(buffer.written() > 0);
         const auto& wnl = buffer.get<osmium::WayNodeList>(0);
         REQUIRE(wnl.size() == 2);
-        auto it = wnl.begin();
+        const auto* it = wnl.cbegin();
         REQUIRE(it->ref() == 123);
         ++it;
         REQUIRE(it->ref() == 456);
         ++it;
-        REQUIRE(it == wnl.end());
+        REQUIRE(it == wnl.cend());
     }
 
     SECTION("Trailing comma") {
@@ -469,12 +507,12 @@ TEST_CASE("Parse OPL: nodes") {
         REQUIRE(buffer.written() > 0);
         const auto& wnl = buffer.get<osmium::WayNodeList>(0);
         REQUIRE(wnl.size() == 2);
-        auto it = wnl.begin();
+        const auto* it = wnl.cbegin();
         REQUIRE(it->ref() == 123);
         ++it;
         REQUIRE(it->ref() == 456);
         ++it;
-        REQUIRE(it == wnl.end());
+        REQUIRE(it == wnl.cend());
     }
 
     SECTION("Way nodes with coordinates") {
@@ -483,7 +521,7 @@ TEST_CASE("Parse OPL: nodes") {
         REQUIRE(buffer.written() > 0);
         const auto& wnl = buffer.get<osmium::WayNodeList>(0);
         REQUIRE(wnl.size() == 2);
-        auto it = wnl.begin();
+        const auto* it = wnl.cbegin();
         REQUIRE(it->ref() == 123);
         const osmium::Location loc1{1.2, 3.4};
         REQUIRE(it->location() == loc1);
@@ -492,7 +530,7 @@ TEST_CASE("Parse OPL: nodes") {
         const osmium::Location loc2{33.0, 0.1};
         REQUIRE(it->location() == loc2);
         ++it;
-        REQUIRE(it == wnl.end());
+        REQUIRE(it == wnl.cend());
     }
 
 }
@@ -717,7 +755,6 @@ TEST_CASE("Parse node") {
         REQUIRE(node.location() == loc);
         REQUIRE(node.tags().empty());
     }
-
 }
 
 TEST_CASE("Parse way") {
@@ -886,7 +923,6 @@ TEST_CASE("Parse line") {
     osmium::memory::Buffer buffer{1024};
 
     SECTION("Empty line") {
-        const char* s = "";
         REQUIRE_FALSE(oid::opl_parse_line(0, "", buffer));
         REQUIRE(buffer.written() == 0);
     }
@@ -1041,6 +1077,50 @@ TEST_CASE("Parse line with external interface") {
 
 }
 
+TEST_CASE("Duplicate attributes") {
+    osmium::memory::Buffer buffer{1024};
+    REQUIRE_THROWS_WITH(osmium::opl_parse("n123 v1 v2", buffer),
+                        "OPL error: Duplicate attribute: version (v) on line 0 column 0");
+    REQUIRE_THROWS_WITH(osmium::opl_parse("w123 c1 c2", buffer),
+                        "OPL error: Duplicate attribute: changeset_id (c) on line 0 column 0");
+    REQUIRE_THROWS_WITH(osmium::opl_parse("r123 Ta=b Tc=d", buffer),
+                        "OPL error: Duplicate attribute: tags (T) on line 0 column 0");
+    REQUIRE_THROWS_WITH(osmium::opl_parse("c123 k1 k2", buffer),
+                        "OPL error: Duplicate attribute: num_changes (k) on line 0 column 0");
+
+    for (const char *attr : {"v1", "dV", "c2", "t2020-01-01T00:00:01Z", "i3", "utest", "Ta=b", "x1.0", "y2.0"}) {
+        auto line = std::string{"n1 "} + attr;
+        REQUIRE_NOTHROW(osmium::opl_parse(line.c_str(), buffer));
+        line += " ";
+        line += attr;
+        REQUIRE_THROWS_AS(osmium::opl_parse(line.c_str(), buffer), osmium::opl_error);
+    }
+
+    for (const char *attr : {"v1", "dV", "c2", "t2020-01-01T00:00:01Z", "i3", "utest", "Ta=b", "Nn1"}) {
+        auto line = std::string{"w1 "} + attr;
+        REQUIRE_NOTHROW(osmium::opl_parse(line.c_str(), buffer));
+        line += " ";
+        line += attr;
+        REQUIRE_THROWS_AS(osmium::opl_parse(line.c_str(), buffer), osmium::opl_error);
+    }
+
+    for (const char *attr : {"v1", "dV", "c2", "t2020-01-01T00:00:01Z", "i3", "utest", "Ta=b", "Mn1@foo"}) {
+        auto line = std::string{"r1 "} + attr;
+        REQUIRE_NOTHROW(osmium::opl_parse(line.c_str(), buffer));
+        line += " ";
+        line += attr;
+        REQUIRE_THROWS_AS(osmium::opl_parse(line.c_str(), buffer), osmium::opl_error);
+    }
+
+    for (const char *attr : {"k1", "s2020-01-01T00:00:01Z", "e2020-01-01T00:00:02Z", "d1", "i3", "utest", "Ta=b", "x1", "y2", "X3", "Y4"}) {
+        auto line = std::string{"c1 "} + attr;
+        REQUIRE_NOTHROW(osmium::opl_parse(line.c_str(), buffer));
+        line += " ";
+        line += attr;
+        REQUIRE_THROWS_AS(osmium::opl_parse(line.c_str(), buffer), osmium::opl_error);
+    }
+}
+
 TEST_CASE("Parse OPL using Reader") {
     osmium::io::File file{with_data_dir("t/io/data.opl")};
     osmium::io::Reader reader{file};
diff --git a/third_party/libosmium/test/t/io/test_output_iterator.cpp b/third_party/libosmium/test/t/io/test_output_iterator.cpp
index 23b117dc5..af994b09f 100644
--- a/third_party/libosmium/test/t/io/test_output_iterator.cpp
+++ b/third_party/libosmium/test/t/io/test_output_iterator.cpp
@@ -4,12 +4,14 @@
 #include <osmium/io/writer.hpp>
 #include <osmium/io/xml_output.hpp>
 
-TEST_CASE("Output iterator should be copy constructable") {
+TEST_CASE("Output iterator should be copy constructable and incrementable") {
     const osmium::io::Header header{};
     osmium::io::Writer writer{"test.osm", header, osmium::io::overwrite::allow};
 
     osmium::io::OutputIterator<osmium::io::Writer> out1{writer};
     osmium::io::OutputIterator<osmium::io::Writer> out2{out1};
+
+    ++out2;
 }
 
 TEST_CASE("Output iterator should be copy assignable") {
@@ -23,11 +25,3 @@ TEST_CASE("Output iterator should be copy assignable") {
     out2 = out1;
 }
 
-TEST_CASE("Output iterator should be incrementable") {
-    const osmium::io::Header header{};
-    osmium::io::Writer writer{"test.osm", header, osmium::io::overwrite::allow};
-    osmium::io::OutputIterator<osmium::io::Writer> out{writer};
-
-    ++out;
-}
-
diff --git a/third_party/libosmium/test/t/io/test_output_utils.cpp b/third_party/libosmium/test/t/io/test_output_utils.cpp
index 5c4b18733..9d582edc9 100644
--- a/third_party/libosmium/test/t/io/test_output_utils.cpp
+++ b/third_party/libosmium/test/t/io/test_output_utils.cpp
@@ -2,151 +2,226 @@
 
 #include <osmium/io/detail/string_util.hpp>
 
+#include <iterator>
 #include <locale>
+#include <stdexcept>
+#include <string>
 
-TEST_CASE("output formatted") {
-
-    std::string out;
-
-    SECTION("small results") {
-        osmium::io::detail::append_printf_formatted_string(out, "%d", 17);
-        REQUIRE(out == "17");
-    }
-
-    SECTION("several parameters") {
-        osmium::io::detail::append_printf_formatted_string(out, "%d %s", 17, "foo");
-        REQUIRE(out == "17 foo");
-
-    }
-
-    SECTION("string already containing something") {
-        out += "foo";
-        osmium::io::detail::append_printf_formatted_string(out, " %d", 23);
-        REQUIRE(out == "foo 23");
-    }
-
-    SECTION("large results") {
-        const char* str =
-            "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-            "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-            "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-            "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
-            "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
-
-        osmium::io::detail::append_printf_formatted_string(out, "%s", str);
-
-        REQUIRE(out == str);
-    }
-
+// From C++20 we need to handle unicode literals differently
+#ifdef __cpp_char8_t
+static const char* u8cast(const char8_t *s) noexcept {
+    return reinterpret_cast<const char*>(s);
+}
+#else
+static const char* u8cast(const char *s) noexcept {
+    return s;
 }
-
-TEST_CASE("UTF8 encoding") {
-
-    std::string out;
-
-    SECTION("append to string") {
-        out += "1234";
-        osmium::io::detail::append_utf8_encoded_string(out, "abc");
-        REQUIRE(out == "1234abc");
-    }
-
-    SECTION("don't encode alphabetic characters") {
-        const char* s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-        osmium::io::detail::append_utf8_encoded_string(out, s);
-        REQUIRE(out == s);
-    }
-
-    SECTION("don't encode numeric characters") {
-        const char* s = "0123456789";
-        osmium::io::detail::append_utf8_encoded_string(out, s);
-        REQUIRE(out == s);
-    }
-
-    SECTION("don't encode lots of often used characters characters") {
-        const char* s = ".-;:_#+";
-        osmium::io::detail::append_utf8_encoded_string(out, s);
-        REQUIRE(out == s);
-    }
-
-    SECTION("encode characters that are special in OPL") {
-        osmium::io::detail::append_utf8_encoded_string(out, " \n,=@");
-        REQUIRE(out == "%20%%0a%%2c%%3d%%40%");
-    }
-
-// workaround for missing support for u8 string literals on Windows
-#if !defined(_MSC_VER)
-
-    SECTION("encode multibyte character") {
-        osmium::io::detail::append_utf8_encoded_string(out, u8"\u30dc_\U0001d11e_\U0001f6eb");
-        REQUIRE(out == "%30dc%_%1d11e%_%1f6eb%");
-    }
-
 #endif
 
+TEST_CASE("output formatted with small results") {
+    std::string out;
+    osmium::io::detail::append_printf_formatted_string(out, "%d", 17);
+    REQUIRE(out == "17");
 }
 
-TEST_CASE("html encoding") {
+TEST_CASE("output formatted with several parameters in format string") {
+    std::string out;
+    osmium::io::detail::append_printf_formatted_string(out, "%d %s", 17, "foo");
+    REQUIRE(out == "17 foo");
+}
+
+TEST_CASE("output formatted into string already containing something") {
+    std::string out{"foo"};
+    osmium::io::detail::append_printf_formatted_string(out, " %d", 23);
+    REQUIRE(out == "foo 23");
+}
+
+TEST_CASE("output formatted with large results") {
+    const char* str =
+        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
+        "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
 
     std::string out;
-
-    SECTION("do not encode normal characters") {
-        const char* s = "abc123,.-";
-        osmium::io::detail::append_xml_encoded_string(out, s);
-        REQUIRE(out == s);
-    }
-
-    SECTION("encode special XML characters") {
-        const char* s = "& \" \' < > \n \r \t";
-        osmium::io::detail::append_xml_encoded_string(out, s);
-        REQUIRE(out == "&amp; &quot; &apos; &lt; &gt; &#xA; &#xD; &#x9;");
-    }
-
+#pragma GCC diagnostic push
+#if __GNUC__ >= 8
+#pragma GCC diagnostic ignored "-Wformat-truncation"
+#endif
+    osmium::io::detail::append_printf_formatted_string(out, "%s", str);
+#pragma GCC diagnostic pop
+    REQUIRE(out == str);
 }
 
-TEST_CASE("debug encoding") {
+TEST_CASE("UTF8 encoding: append to string") {
+    std::string out{"1234"};
+    osmium::io::detail::append_utf8_encoded_string(out, "abc");
+    REQUIRE(out == "1234abc");
+}
 
+TEST_CASE("UTF8 encoding: don't encode alphabetic characters") {
+    const char* s = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
     std::string out;
-
-    SECTION("do not encode normal characters") {
-        const char* s = "abc123,.-";
-        osmium::io::detail::append_debug_encoded_string(out, s, "[", "]");
-        REQUIRE(out == s);
-    }
-
-    SECTION("encode some unicode characters") {
-        const char* s = u8"\n_\u30dc_\U0001d11e_\U0001f6eb";
-        osmium::io::detail::append_debug_encoded_string(out, s, "[", "]");
-        REQUIRE(out == "[<U+000A>]_[<U+30DC>]_[<U+1D11E>]_[<U+1F6EB>]");
-    }
-
+    osmium::io::detail::append_utf8_encoded_string(out, s);
+    REQUIRE(out == s);
 }
 
-TEST_CASE("encoding of non-printable characters in the first 127 characters") {
+TEST_CASE("UTF8 encoding: don't encode numeric characters") {
+    const char* s = "0123456789";
+    std::string out;
+    osmium::io::detail::append_utf8_encoded_string(out, s);
+    REQUIRE(out == s);
+}
 
-    std::locale cloc("C");
+TEST_CASE("UTF8 encoding: don't encode lots of often used characters characters") {
+    const char* s = ".-;:_#+";
+    std::string out;
+    osmium::io::detail::append_utf8_encoded_string(out, s);
+    REQUIRE(out == s);
+}
+
+TEST_CASE("UTF8 encoding: encode characters that are special in OPL") {
+    std::string out;
+    osmium::io::detail::append_utf8_encoded_string(out, " \n,=@");
+    REQUIRE(out == "%20%%0a%%2c%%3d%%40%");
+}
+
+TEST_CASE("UTF8 encoding: encode multibyte character") {
+    std::string out;
+    osmium::io::detail::append_utf8_encoded_string(out, u8cast(u8"\u30dc_\U0001d11e_\U0001f6eb"));
+    REQUIRE(out == "%30dc%_%1d11e%_%1f6eb%");
+}
+
+TEST_CASE("html encoding does not encode normal characters") {
+    const char* s = "abc123,.-";
+    std::string out;
+    osmium::io::detail::append_xml_encoded_string(out, s);
+    REQUIRE(out == s);
+}
+
+TEST_CASE("html encoding encodes special XML characters") {
+    const char* s = "& \" \' < > \n \r \t";
+    std::string out;
+    osmium::io::detail::append_xml_encoded_string(out, s);
+    REQUIRE(out == "&amp; &quot; &apos; &lt; &gt; &#xA; &#xD; &#x9;");
+}
+
+TEST_CASE("debug encoding does not encode normal characters") {
+    const char* s = "abc123,.-";
+    std::string out;
+    osmium::io::detail::append_debug_encoded_string(out, s, "[", "]");
+    REQUIRE(out == s);
+}
+
+TEST_CASE("debug encoding encodes some unicode characters") {
+    const char* s = u8cast(u8"\n_\u30dc_\U0001d11e_\U0001f6eb");
+    std::string out;
+    osmium::io::detail::append_debug_encoded_string(out, s, "[", "]");
+    REQUIRE(out == "[<U+000A>]_[<U+30DC>]_[<U+1D11E>]_[<U+1F6EB>]");
+}
+
+TEST_CASE("utf8 encoding of non-printable characters in the first 127 characters") {
+    std::locale cloc{"C"};
     char s[] = "a\0";
 
     for (char c = 1; c < 0x7f; ++c) {
         std::string out;
         s[0] = c;
-
-        SECTION("utf8 encode") {
-            osmium::io::detail::append_utf8_encoded_string(out, s);
-
-            if (!std::isprint(c, cloc)) {
-                REQUIRE(out[0] == '%');
-            }
+        osmium::io::detail::append_utf8_encoded_string(out, s);
+        if (!std::isprint(c, cloc)) {
+            REQUIRE(out[0] == '%');
         }
-
-        SECTION("debug encode") {
-            osmium::io::detail::append_debug_encoded_string(out, s, "", "");
-
-            if (!std::isprint(c, cloc)) {
-                REQUIRE(out[0] == '<');
-            }
-        }
-
     }
-
+}
+
+TEST_CASE("debug encoding of non-printable characters in the first 127 characters") {
+    std::locale cloc{"C"};
+    char s[] = "a\0";
+
+    for (char c = 1; c < 0x7f; ++c) {
+        std::string out;
+        s[0] = c;
+        osmium::io::detail::append_debug_encoded_string(out, s, "", "");
+        if (!std::isprint(c, cloc)) {
+            REQUIRE(out[0] == '<');
+        }
+    }
+}
+
+TEST_CASE("test codepoint to utf8 encoding") {
+    const char* s = u8cast(u8"\n_\u01a2_\u30dc_\U0001d11e_\U0001f680");
+
+    std::string out;
+    osmium::io::detail::append_codepoint_as_utf8(0x0aU, std::back_inserter(out)); // 1 utf8 byte
+    REQUIRE(out.size() == 1);
+    osmium::io::detail::append_codepoint_as_utf8('_', std::back_inserter(out));
+    REQUIRE(out.size() == 2);
+    osmium::io::detail::append_codepoint_as_utf8(0x01a2U, std::back_inserter(out)); // 2 utf8 bytes
+    REQUIRE(out.size() == 4);
+    osmium::io::detail::append_codepoint_as_utf8('_', std::back_inserter(out));
+    REQUIRE(out.size() == 5);
+    osmium::io::detail::append_codepoint_as_utf8(0x30dcU, std::back_inserter(out)); // 3 utf8 bytes
+    REQUIRE(out.size() == 8);
+    osmium::io::detail::append_codepoint_as_utf8('_', std::back_inserter(out));
+    REQUIRE(out.size() == 9);
+    osmium::io::detail::append_codepoint_as_utf8(0x1d11eU, std::back_inserter(out)); // 4 utf8 bytes
+    REQUIRE(out.size() == 13);
+    osmium::io::detail::append_codepoint_as_utf8('_', std::back_inserter(out));
+    REQUIRE(out.size() == 14);
+    osmium::io::detail::append_codepoint_as_utf8(0x1f680U, std::back_inserter(out)); // 4 utf8 bytes
+    REQUIRE(out.size() == 18);
+    REQUIRE(out == s);
+}
+
+TEST_CASE("test utf8 to codepoint decoding") {
+    const char* s = u8cast(u8"\n_\u01a2_\u30dc_\U0001d11e_\U0001f680");
+
+    const char* it = s;
+    const char* end = s + std::strlen(s) + 1;
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == 0x0aU);
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == '_');
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == 0x01a2U);
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == '_');
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == 0x30dcU);
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == '_');
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == 0x1d11eU);
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == '_');
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end) == 0x1f680U);
+
+    REQUIRE(*it++ == '\0');
+    REQUIRE(it == end);
+}
+
+TEST_CASE("Roundtrip unicode characters") {
+    char s[4] = {0};
+
+    const uint32_t max_code_point = 0x10ffffU;
+    for (uint32_t cp = 0; cp <= max_code_point; ++cp) {
+        const auto* const end = osmium::io::detail::append_codepoint_as_utf8(cp, s);
+        const char* it = s;
+        REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, std::end(s)) == cp);
+        REQUIRE(end == it);
+    }
+}
+
+TEST_CASE("invalid codepoint") {
+    const char s[] = {static_cast<char>(0xff), static_cast<char>(0xff), static_cast<char>(0xff), static_cast<char>(0xff)};
+    const char* it = s;
+    REQUIRE_THROWS_AS(osmium::io::detail::next_utf8_codepoint(&it, std::end(s)), std::runtime_error);
+}
+
+TEST_CASE("incomplete Unicode codepoint") {
+    const char* s = u8cast(u8"\U0001f680");
+
+    const auto* it = s;
+    const char* end = s + std::strlen(s) + 1;
+    REQUIRE(osmium::io::detail::next_utf8_codepoint(&it, end - 1) == 0x1f680U);
+    REQUIRE(std::distance(s, it) == 4);
+
+    for (int i : {0, 1, 2, 3}) {
+        it = s;
+        REQUIRE_THROWS_AS(osmium::io::detail::next_utf8_codepoint(&it, s + i), std::out_of_range);
+    }
 }
 
diff --git a/third_party/libosmium/test/t/io/test_pbf.cpp b/third_party/libosmium/test/t/io/test_pbf.cpp
index bfa9e9c3a..cb2fe8ac4 100644
--- a/third_party/libosmium/test/t/io/test_pbf.cpp
+++ b/third_party/libosmium/test/t/io/test_pbf.cpp
@@ -6,6 +6,13 @@
 #include <osmium/io/reader.hpp>
 #include <osmium/osm/object.hpp>
 
+TEST_CASE("Get supported PBF compression types") {
+    const auto types = osmium::io::supported_pbf_compression_types();
+    REQUIRE(types.size() >= 2);
+    REQUIRE(types[0] == "none");
+    REQUIRE(types[1] == "zlib");
+}
+
 /**
  * Osmosis writes PBF with changeset=-1 if its input file did not contain the changeset field.
  * The default value of the version field is -1 in the OSM.PBF format.
diff --git a/third_party/libosmium/test/t/io/test_reader.cpp b/third_party/libosmium/test/t/io/test_reader.cpp
index d528379cf..d3b2e07af 100644
--- a/third_party/libosmium/test/t/io/test_reader.cpp
+++ b/third_party/libosmium/test/t/io/test_reader.cpp
@@ -4,11 +4,14 @@
 
 #include <osmium/handler.hpp>
 #include <osmium/io/any_compression.hpp>
-#include <osmium/io/pbf_input.hpp>
-#include <osmium/io/xml_input.hpp>
+#include <osmium/io/any_input.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/visitor.hpp>
 
+#include <iterator>
+#include <stdexcept>
+#include <vector>
+
 struct CountHandler : public osmium::handler::Handler {
 
     int count = 0;
@@ -42,29 +45,46 @@ struct ZeroPositionNodeCountHandler : public osmium::handler::Handler {
 
 TEST_CASE("Reader can be initialized with file") {
     osmium::io::File file{with_data_dir("t/io/data.osm")};
+
+    const int count = count_fds();
     osmium::io::Reader reader{file};
     osmium::handler::Handler handler;
 
     osmium::apply(reader, handler);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader can be initialized with string") {
+    const int count = count_fds();
+
     osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
     osmium::handler::Handler handler;
 
     osmium::apply(reader, handler);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader can be initialized with user-provided pool") {
+    const int count = count_fds();
+
     osmium::thread::Pool pool{4};
     osmium::io::File file{with_data_dir("t/io/data.osm")};
     osmium::io::Reader reader{file, pool};
     osmium::handler::Handler handler;
 
     osmium::apply(reader, handler);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should throw after eof") {
+    const int count = count_fds();
+
     osmium::io::File file{with_data_dir("t/io/data.osm")};
     osmium::io::Reader reader{file};
 
@@ -81,22 +101,30 @@ TEST_CASE("Reader should throw after eof") {
 
     REQUIRE(reader.eof());
 
-    REQUIRE_THROWS_AS(reader.read(), const osmium::io_error&);
+    REQUIRE_THROWS_AS(reader.read(), osmium::io_error);
 
     reader.close();
     REQUIRE(reader.eof());
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should not hang when apply() is called twice on reader") {
+    const int count = count_fds();
+
     osmium::io::File file{with_data_dir("t/io/data.osm")};
     osmium::io::Reader reader{file};
     osmium::handler::Handler handler;
 
     osmium::apply(reader, handler);
-    REQUIRE_THROWS_AS(osmium::apply(reader, handler), const osmium::io_error&);
+    REQUIRE_THROWS_AS(osmium::apply(reader, handler), osmium::io_error);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should work with a buffer with uncompressed data") {
+    const int count = count_fds();
+
     const int fd = osmium::io::detail::open_for_reading(with_data_dir("t/io/data.osm"));
     REQUIRE(fd >= 0);
 
@@ -104,6 +132,7 @@ TEST_CASE("Reader should work with a buffer with uncompressed data") {
     char buffer[buffer_size];
     const auto length = ::read(fd, buffer, buffer_size);
     REQUIRE(length > 0);
+    osmium::io::detail::reliable_close(fd);
 
     osmium::io::File file{buffer, static_cast<size_t>(length), "osm"};
     osmium::io::Reader reader{file};
@@ -112,9 +141,14 @@ TEST_CASE("Reader should work with a buffer with uncompressed data") {
     REQUIRE(handler.count == 0);
     osmium::apply(reader, handler);
     REQUIRE(handler.count == 1);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should work with a buffer with gzip-compressed data") {
+    const int count = count_fds();
+
     const int fd = osmium::io::detail::open_for_reading(with_data_dir("t/io/data.osm.gz"));
     REQUIRE(fd >= 0);
 
@@ -122,6 +156,7 @@ TEST_CASE("Reader should work with a buffer with gzip-compressed data") {
     char buffer[buffer_size];
     const auto length = ::read(fd, buffer, buffer_size);
     REQUIRE(length > 0);
+    osmium::io::detail::reliable_close(fd);
 
     osmium::io::File file{buffer, static_cast<size_t>(length), "osm.gz"};
     osmium::io::Reader reader{file};
@@ -130,9 +165,14 @@ TEST_CASE("Reader should work with a buffer with gzip-compressed data") {
     REQUIRE(handler.count == 0);
     osmium::apply(reader, handler);
     REQUIRE(handler.count == 1);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should work with a buffer with bzip2-compressed data") {
+    const int count = count_fds();
+
     const int fd = osmium::io::detail::open_for_reading(with_data_dir("t/io/data.osm.bz2"));
     REQUIRE(fd >= 0);
 
@@ -140,6 +180,7 @@ TEST_CASE("Reader should work with a buffer with bzip2-compressed data") {
     char buffer[buffer_size];
     const auto length = ::read(fd, buffer, buffer_size);
     REQUIRE(length > 0);
+    osmium::io::detail::reliable_close(fd);
 
     osmium::io::File file{buffer, static_cast<size_t>(length), "osm.bz2"};
     osmium::io::Reader reader{file};
@@ -148,9 +189,14 @@ TEST_CASE("Reader should work with a buffer with bzip2-compressed data") {
     REQUIRE(handler.count == 0);
     osmium::apply(reader, handler);
     REQUIRE(handler.count == 1);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should decode zero node positions in history (XML)") {
+    const int count = count_fds();
+
     osmium::io::Reader reader{with_data_dir("t/io/deleted_nodes.osh"),
                               osmium::osm_entity_bits::node};
     ZeroPositionNodeCountHandler handler;
@@ -162,9 +208,14 @@ TEST_CASE("Reader should decode zero node positions in history (XML)") {
 
     REQUIRE(handler.count == 0);
     REQUIRE(handler.total_count == 2);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should decode zero node positions in history (PBF)") {
+    const int count = count_fds();
+
     osmium::io::Reader reader{with_data_dir("t/io/deleted_nodes.osh.pbf"),
                               osmium::osm_entity_bits::node};
     ZeroPositionNodeCountHandler handler;
@@ -176,30 +227,51 @@ TEST_CASE("Reader should decode zero node positions in history (PBF)") {
 
     REQUIRE(handler.count == 0);
     REQUIRE(handler.total_count == 2);
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should fail with nonexistent file") {
+    const int count = count_fds();
+
     REQUIRE_THROWS(osmium::io::Reader{with_data_dir("t/io/nonexistent-file.osm")});
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should fail with nonexistent file (gz)") {
+    const int count = count_fds();
+
     REQUIRE_THROWS(osmium::io::Reader{with_data_dir("t/io/nonexistent-file.osm.gz")});
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should fail with nonexistent file (pbf)") {
+    const int count = count_fds();
+
     REQUIRE_THROWS(osmium::io::Reader{with_data_dir("t/io/nonexistent-file.osm.pbf")});
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should work when there is an exception in main thread before getting header") {
+    const int count = count_fds();
+
     try {
         osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
         REQUIRE_FALSE(reader.eof());
         throw std::runtime_error{"foo"};
     } catch (...) {
     }
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Reader should work when there is an exception in main thread while reading") {
+    const int count = count_fds();
+
     try {
         osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
         REQUIRE_FALSE(reader.eof());
@@ -207,15 +279,24 @@ TEST_CASE("Reader should work when there is an exception in main thread while re
         throw std::runtime_error{"foo"};
     } catch (...) {
     }
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Applying rvalue handler on reader") {
+    const int count = count_fds();
+
     osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
     struct NullHandler : public osmium::handler::Handler { };
     osmium::apply(reader, NullHandler{});
+
+    reader.close();
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Can call read() exactly once on Reader with entity_bits nothing") {
+    const int count = count_fds();
+
     osmium::io::File file{with_data_dir("t/io/data.osm")};
     osmium::io::Reader reader{file, osmium::osm_entity_bits::nothing};
     REQUIRE_FALSE(reader.eof());
@@ -229,13 +310,17 @@ TEST_CASE("Can call read() exactly once on Reader with entity_bits nothing") {
     osmium::memory::Buffer buffer = reader.read();
     REQUIRE_FALSE(buffer);
     REQUIRE(reader.eof());
-    REQUIRE_THROWS_AS(reader.read(), const osmium::io_error&);
+    REQUIRE_THROWS_AS(reader.read(), osmium::io_error);
 
     reader.close();
     REQUIRE(reader.eof());
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Can not read after close") {
+    const int count = count_fds();
+
     osmium::io::File file{with_data_dir("t/io/data.osm")};
     osmium::io::Reader reader{file};
 
@@ -253,6 +338,43 @@ TEST_CASE("Can not read after close") {
 
     reader.close();
     REQUIRE(reader.eof());
-    REQUIRE_THROWS_AS(reader.read(), const osmium::io_error&);
+    REQUIRE_THROWS_AS(reader.read(), osmium::io_error);
+
+    REQUIRE(count == count_fds());
+}
+
+using object_counts = std::array<std::size_t, 3>;
+
+std::vector<object_counts> count_objects_per_buffer(const char* filename, osmium::io::buffers_type btype) {
+    osmium::io::File file{with_data_dir(filename)};
+    osmium::io::Reader reader{file, btype};
+
+    std::vector<object_counts> counts;
+    while (osmium::memory::Buffer buffer = reader.read()) {
+        const auto rn = buffer.select<osmium::Node>();
+        const auto rw = buffer.select<osmium::Way>();
+        const auto rr = buffer.select<osmium::Relation>();
+        counts.push_back(object_counts{static_cast<std::size_t>(std::distance(rn.begin(), rn.end())),
+                                       static_cast<std::size_t>(std::distance(rw.begin(), rw.end())),
+                                       static_cast<std::size_t>(std::distance(rr.begin(), rr.end()))});
+    }
+
+    return counts;
+}
+
+void check_buffer_counts(const std::string& filename, const std::vector<object_counts>& oc, osmium::io::buffers_type btype) {
+    for (const auto* suffix : {".osm", ".osm.opl", ".osm.o5m"}) {
+        const std::string fn = filename + suffix;
+        const auto counts = count_objects_per_buffer(fn.c_str(), btype);
+        REQUIRE(counts == oc);
+    }
+}
+
+TEST_CASE("Reader with single object type per buffer") {
+    check_buffer_counts("t/io/data-n5w1r3", {{5, 1, 3}}, osmium::io::buffers_type::any);
+    check_buffer_counts("t/io/data-n5w1r3", {{5, 0, 0}, {0, 1, 0}, {0, 0, 3}}, osmium::io::buffers_type::single);
+    check_buffer_counts("t/io/data-n0w1r3", {{0, 1, 0}, {0, 0, 3}}, osmium::io::buffers_type::single);
+    check_buffer_counts("t/io/data-n5w0r3", {{5, 0, 0}, {0, 0, 3}}, osmium::io::buffers_type::single);
+    check_buffer_counts("t/io/data-n5w1r0", {{5, 0, 0}, {0, 1, 0}}, osmium::io::buffers_type::single);
 }
 
diff --git a/third_party/libosmium/test/t/io/test_reader_fileformat.cpp b/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
index 7a2ae5bce..24fa2a6e0 100644
--- a/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_fileformat.cpp
@@ -5,6 +5,6 @@
 #include <osmium/io/reader.hpp>
 
 TEST_CASE("Reader throws on unsupported file format") {
-    REQUIRE_THROWS_AS(osmium::io::Reader{with_data_dir("t/io/data.osm")}, const osmium::unsupported_file_format_error&);
+    REQUIRE_THROWS_AS(osmium::io::Reader{with_data_dir("t/io/data.osm")}, osmium::unsupported_file_format_error);
 }
 
diff --git a/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp b/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
index c7bef89a3..93e09020f 100644
--- a/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_with_mock_decompression.cpp
@@ -5,6 +5,7 @@
 #include <osmium/io/compression.hpp>
 #include <osmium/io/xml_input.hpp>
 
+#include <stdexcept>
 #include <string>
 #include <utility>
 
@@ -13,7 +14,7 @@
 // constructor it can be instructed to throw an exception in specific parts
 // of its code. This is then used to test the internals of the Reader.
 
-class MockDecompressor : public osmium::io::Decompressor {
+class MockDecompressor final : public osmium::io::Decompressor {
 
     std::string m_fail_in;
     int m_read_count = 0;
@@ -33,15 +34,15 @@ public:
     MockDecompressor(MockDecompressor&&) = delete;
     MockDecompressor& operator=(MockDecompressor&&) = delete;
 
-    ~MockDecompressor() noexcept final = default;
+    ~MockDecompressor() noexcept override = default;
 
-    void add_node(std::string& s, int i) {
+    static void add_node(std::string& s, int i) {
         s += "<node id='";
         s += std::to_string(i);
         s += "' version='1' timestamp='2014-01-01T00:00:00Z' uid='1' user='test' changeset='1' lon='1.02' lat='1.02'/>\n";
     }
 
-    std::string read() final {
+    std::string read() override {
         std::string buffer;
         ++m_read_count;
 
@@ -67,7 +68,7 @@ public:
         return buffer;
     }
 
-    void close() final {
+    void close() override {
         if (m_fail_in == "close") {
             throw std::runtime_error{"error close"};
         }
@@ -80,9 +81,9 @@ TEST_CASE("Test Reader using MockDecompressor") {
     std::string fail_in;
 
     osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip,
-        [](int, osmium::io::fsync) { return nullptr; },
-        [&](int) { return new MockDecompressor(fail_in); },
-        [](const char*, size_t) { return nullptr; }
+        [](int /*unused*/, osmium::io::fsync /*unused*/) { return nullptr; },
+        [&](int /*unused*/) { return new MockDecompressor(fail_in); },
+        [](const char* /*unused*/, size_t /*unused*/) { return nullptr; }
     );
 
     SECTION("fail in constructor") {
diff --git a/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp b/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
index 65a421f9d..d4d2cb76a 100644
--- a/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
+++ b/third_party/libosmium/test/t/io/test_reader_with_mock_parser.cpp
@@ -13,6 +13,8 @@
 #include <osmium/thread/queue.hpp>
 #include <osmium/thread/util.hpp>
 
+#include <memory>
+#include <stdexcept>
 #include <string>
 #include <utility>
 
diff --git a/third_party/libosmium/test/t/io/test_string_table.cpp b/third_party/libosmium/test/t/io/test_string_table.cpp
index aefc11cb8..797186789 100644
--- a/third_party/libosmium/test/t/io/test_string_table.cpp
+++ b/third_party/libosmium/test/t/io/test_string_table.cpp
@@ -3,6 +3,9 @@
 #include <osmium/io/detail/string_table.hpp>
 #include <osmium/util/misc.hpp>
 
+#include <iterator>
+#include <string>
+
 TEST_CASE("Empty StringStore") {
     const osmium::io::detail::StringStore ss{100};
 
@@ -38,9 +41,6 @@ TEST_CASE("Add strings to StringStore") {
     REQUIRE(s1 == *it++);
     REQUIRE(s2 == *it++);
     REQUIRE(it == ss.end());
-
-    ss.clear();
-    REQUIRE(ss.begin() == ss.end());
 }
 
 TEST_CASE("Add zero-length string and longer strings to StringStore") {
@@ -58,9 +58,8 @@ TEST_CASE("Add zero-length string and longer strings to StringStore") {
 }
 
 TEST_CASE("Add many strings to StringStore") {
-    osmium::io::detail::StringStore ss{100};
-
     for (const char* teststring : {"", "a", "abc", "abcd", "abcde"}) {
+        osmium::io::detail::StringStore ss{100};
         int i = 0;
         for (; i < 200; ++i) {
             ss.add(teststring);
@@ -73,8 +72,6 @@ TEST_CASE("Add many strings to StringStore") {
 
         REQUIRE(i == 0);
         REQUIRE(ss.get_chunk_count() > 1);
-        ss.clear();
-        REQUIRE(ss.get_chunk_count() == 1);
     }
 }
 
@@ -101,9 +98,6 @@ TEST_CASE("Add strings to StringTable") {
     REQUIRE(std::string{"bar"} == *it++);
     REQUIRE(std::string{"baz"} == *it++);
     REQUIRE(it == st.end());
-
-    st.clear();
-    REQUIRE(st.size() == 1);
 }
 
 TEST_CASE("Add empty string to StringTable") {
diff --git a/third_party/libosmium/test/t/io/test_writer.cpp b/third_party/libosmium/test/t/io/test_writer.cpp
index 350f39307..c5468b285 100644
--- a/third_party/libosmium/test/t/io/test_writer.cpp
+++ b/third_party/libosmium/test/t/io/test_writer.cpp
@@ -9,7 +9,10 @@
 #include <osmium/memory/buffer.hpp>
 
 #include <algorithm>
+#include <iterator>
 #include <stdexcept>
+#include <string>
+#include <utility>
 
 static osmium::memory::Buffer get_buffer() {
     osmium::io::Reader reader{with_data_dir("t/io/data.osm")};
@@ -31,7 +34,7 @@ static osmium::memory::Buffer get_and_check_buffer() {
 }
 
 TEST_CASE("Writer: Empty writes") {
-    auto buffer = get_and_check_buffer();
+    const int count = count_fds();
 
     std::string filename;
 
@@ -54,9 +57,13 @@ TEST_CASE("Writer: Empty writes") {
     osmium::io::Reader reader_check{filename};
     osmium::memory::Buffer buffer_check = reader_check.read();
     REQUIRE_FALSE(buffer_check);
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer: Successful writes writing buffer") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
 
     const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
@@ -68,17 +75,21 @@ TEST_CASE("Writer: Successful writes writing buffer") {
     writer(std::move(buffer));
     writer.close();
 
-    REQUIRE_THROWS_AS(writer(osmium::memory::Buffer{}), const osmium::io_error&);
+    REQUIRE(count == count_fds());
+
+    REQUIRE_THROWS_AS(writer(osmium::memory::Buffer{}), osmium::io_error);
 
     osmium::io::Reader reader_check{filename};
     const osmium::memory::Buffer buffer_check = reader_check.read();
     REQUIRE(buffer_check);
     REQUIRE(buffer_check.committed() > 0);
-    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == static_cast<std::size_t>(num));
     REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
 }
 
 TEST_CASE("Writer: Successful writes writing items") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
 
     const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
@@ -92,15 +103,19 @@ TEST_CASE("Writer: Successful writes writing items") {
     }
     writer.close();
 
+    REQUIRE(count == count_fds());
+
     osmium::io::Reader reader_check{filename};
     const osmium::memory::Buffer buffer_check = reader_check.read();
     REQUIRE(buffer_check);
     REQUIRE(buffer_check.committed() > 0);
-    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == static_cast<std::size_t>(num));
     REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
 }
 
 TEST_CASE("Writer: Successful writes using output iterator") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
 
     const auto num = std::distance(buffer.select<osmium::OSMObject>().cbegin(), buffer.select<osmium::OSMObject>().cend());
@@ -113,15 +128,19 @@ TEST_CASE("Writer: Successful writes using output iterator") {
     std::copy(buffer.cbegin(), buffer.cend(), it);
     writer.close();
 
+    REQUIRE(count == count_fds());
+
     osmium::io::Reader reader_check{filename};
     const osmium::memory::Buffer buffer_check = reader_check.read();
     REQUIRE(buffer_check);
     REQUIRE(buffer_check.committed() > 0);
-    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == num);
+    REQUIRE(buffer_check.select<osmium::OSMObject>().size() == static_cast<std::size_t>(num));
     REQUIRE(buffer_check.select<osmium::OSMObject>().cbegin()->id() == 1);
 }
 
 TEST_CASE("Writer: Interrupted writer after open") {
+    const int count = count_fds();
+
     auto buffer = get_and_check_buffer();
 
     bool error = false;
@@ -133,9 +152,13 @@ TEST_CASE("Writer: Interrupted writer after open") {
     }
 
     REQUIRE(error);
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer: Interrupted writer after write") {
+    const int count = count_fds();
+
     auto buffer = get_and_check_buffer();
 
     bool error = false;
@@ -148,37 +171,55 @@ TEST_CASE("Writer: Interrupted writer after write") {
     }
 
     REQUIRE(error);
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer with user-provided pool with default number of threads") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
     osmium::thread::Pool pool;
     osmium::io::Writer writer{"test-writer-pool-with-default-threads.osm", pool, osmium::io::overwrite::allow};
     writer(std::move(buffer));
     writer.close();
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer with user-provided pool with negative number of threads") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
     osmium::thread::Pool pool{-2};
     osmium::io::Writer writer{"test-writer-pool-with-negative-threads.osm", pool, osmium::io::overwrite::allow};
     writer(std::move(buffer));
     writer.close();
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer with user-provided pool with outlier negative number of threads") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
     osmium::thread::Pool pool{-1000};
     osmium::io::Writer writer{"test-writer-pool-with-outlier-negative-threads.osm", osmium::io::overwrite::allow, pool};
     writer(std::move(buffer));
     writer.close();
+
+    REQUIRE(count == count_fds());
 }
 
 TEST_CASE("Writer with user-provided pool with outlier positive number of threads") {
+    const int count = count_fds();
+
     auto buffer = get_buffer();
     osmium::thread::Pool pool{1000};
     osmium::io::Writer writer{"test-writer-pool-with-outlier-positive-threads.osm", osmium::io::overwrite::allow, pool};
     writer(std::move(buffer));
     writer.close();
+
+    REQUIRE(count == count_fds());
 }
 
diff --git a/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp b/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
index bda799baf..17857d531 100644
--- a/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
+++ b/third_party/libosmium/test/t/io/test_writer_with_mock_compression.cpp
@@ -10,7 +10,7 @@
 #include <string>
 #include <utility>
 
-class MockCompressor : public osmium::io::Compressor {
+class MockCompressor final : public osmium::io::Compressor {
 
     std::string m_fail_in;
 
@@ -30,15 +30,15 @@ public:
     MockCompressor(MockCompressor&&) = delete;
     MockCompressor& operator=(MockCompressor&&) = delete;
 
-    ~MockCompressor() noexcept final = default;
+    ~MockCompressor() noexcept override = default;
 
-    void write(const std::string& /*data*/) final {
+    void write(const std::string& /*data*/) override {
         if (m_fail_in == "write") {
             throw std::logic_error{"write"};
         }
     }
 
-    void close() final {
+    void close() override {
         if (m_fail_in == "close") {
             throw std::logic_error{"close"};
         }
@@ -51,9 +51,9 @@ TEST_CASE("Write with mock compressor") {
     std::string fail_in;
 
     osmium::io::CompressionFactory::instance().register_compression(osmium::io::file_compression::gzip,
-        [&](int, osmium::io::fsync) { return new MockCompressor(fail_in); },
-        [](int) { return nullptr; },
-        [](const char*, size_t) { return nullptr; }
+        [&](int /*unused*/, osmium::io::fsync /*unused*/) { return new MockCompressor(fail_in); },
+        [](int /*unused*/) { return nullptr; },
+        [](const char* /*unused*/, size_t /*unused*/) { return nullptr; }
     );
 
     osmium::io::Header header;
@@ -74,7 +74,7 @@ TEST_CASE("Write with mock compressor") {
             osmium::io::Writer writer("test-writer-mock-fail-on-construction.osm.gz", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
@@ -86,7 +86,7 @@ TEST_CASE("Write with mock compressor") {
             osmium::io::Writer writer("test-writer-mock-fail-on-write.osm.gz", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
@@ -98,7 +98,7 @@ TEST_CASE("Write with mock compressor") {
             osmium::io::Writer writer("test-writer-mock-fail-on-close.osm.gz", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
diff --git a/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp b/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
index f09f400d6..b8629a6f0 100644
--- a/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
+++ b/third_party/libosmium/test/t/io/test_writer_with_mock_encoder.cpp
@@ -74,7 +74,7 @@ TEST_CASE("Test Writer with MockOutputFormat") {
             osmium::io::Writer writer("test-writer-mock-fail-on-construction.osm", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
@@ -86,7 +86,7 @@ TEST_CASE("Test Writer with MockOutputFormat") {
             osmium::io::Writer writer("test-writer-mock-fail-on-construction.osm", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
@@ -98,7 +98,7 @@ TEST_CASE("Test Writer with MockOutputFormat") {
             osmium::io::Writer writer("test-writer-mock-fail-on-construction.osm", header, osmium::io::overwrite::allow);
             writer(std::move(buffer));
             writer.close();
-        }(), const std::logic_error&);
+        }(), std::logic_error);
 
     }
 
diff --git a/third_party/libosmium/test/t/memory/test_buffer_basics.cpp b/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
index e2be4a4c2..735aabb95 100644
--- a/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
+++ b/third_party/libosmium/test/t/memory/test_buffer_basics.cpp
@@ -75,7 +75,7 @@ TEST_CASE("Reserve space in a non-growing buffer") {
 
     REQUIRE(buffer.reserve_space(20) != nullptr);
     REQUIRE(buffer.written() == 20);
-    REQUIRE_THROWS_AS(buffer.reserve_space(1000), const osmium::buffer_is_full&);
+    REQUIRE_THROWS_AS(buffer.reserve_space(1000), osmium::buffer_is_full);
 }
 
 TEST_CASE("Reserve space in a growing buffer") {
@@ -88,7 +88,7 @@ TEST_CASE("Reserve space in a growing buffer") {
 }
 
 TEST_CASE("Create buffer from existing data with good alignment works") {
-    std::array<unsigned char, 128> data;
+    std::array<unsigned char, 128> data = {{0}};
 
     osmium::memory::Buffer buffer{data.data(), data.size()};
     REQUIRE(buffer.capacity() == 128);
@@ -96,7 +96,7 @@ TEST_CASE("Create buffer from existing data with good alignment works") {
 }
 
 TEST_CASE("Create buffer from existing data with good alignment and committed value works") {
-    std::array<unsigned char, 128> data;
+    std::array<unsigned char, 128> data = {{0}};
 
     osmium::memory::Buffer buffer{data.data(), data.size(), 32};
     REQUIRE(buffer.capacity() == 128);
@@ -105,7 +105,7 @@ TEST_CASE("Create buffer from existing data with good alignment and committed va
 }
 
 TEST_CASE("Create buffer from existing data with bad alignment fails") {
-    std::array<unsigned char, 128> data;
+    std::array<unsigned char, 128> data = {{0}};
 
     const auto l1 = [&](){
         osmium::memory::Buffer buffer{data.data(), 127};
@@ -123,9 +123,9 @@ TEST_CASE("Create buffer from existing data with bad alignment fails") {
         osmium::memory::Buffer buffer{data.data(), 32, 128};
     };
 
-    REQUIRE_THROWS_AS(l1(), const std::invalid_argument&);
-    REQUIRE_THROWS_AS(l2(), const std::invalid_argument&);
-    REQUIRE_THROWS_AS(l3(), const std::invalid_argument&);
-    REQUIRE_THROWS_AS(l4(), const std::invalid_argument&);
+    REQUIRE_THROWS_AS(l1(), std::invalid_argument);
+    REQUIRE_THROWS_AS(l2(), std::invalid_argument);
+    REQUIRE_THROWS_AS(l3(), std::invalid_argument);
+    REQUIRE_THROWS_AS(l4(), std::invalid_argument);
 }
 
diff --git a/third_party/libosmium/test/t/memory/test_buffer_node.cpp b/third_party/libosmium/test/t/memory/test_buffer_node.cpp
index 1f939a5fa..403d3c47b 100644
--- a/third_party/libosmium/test/t/memory/test_buffer_node.cpp
+++ b/third_party/libosmium/test/t/memory/test_buffer_node.cpp
@@ -3,6 +3,10 @@
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm/node.hpp>
 
+#include <algorithm>
+#include <iterator>
+#include <string>
+
 void check_node_1(const osmium::Node& node) {
     REQUIRE(1 == node.id());
     REQUIRE(3 == node.version());
@@ -50,6 +54,8 @@ void check_node_2(const osmium::Node& node) {
                 REQUIRE(std::string("name") == tag.key());
                 REQUIRE(std::string("OSM Savings") == tag.value());
                 break;
+            default:
+                REQUIRE(false);
         }
         ++n;
     }
diff --git a/third_party/libosmium/test/t/memory/test_buffer_purge.cpp b/third_party/libosmium/test/t/memory/test_buffer_purge.cpp
index e61e08d44..60cf20962 100644
--- a/third_party/libosmium/test/t/memory/test_buffer_purge.cpp
+++ b/third_party/libosmium/test/t/memory/test_buffer_purge.cpp
@@ -3,6 +3,8 @@
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm/node.hpp>
 
+#include <iterator>
+
 struct CallbackClass {
 
     int count = 0;
@@ -14,161 +16,193 @@ struct CallbackClass {
 
 }; // struct CallbackClass
 
-TEST_CASE("Purge data from buffer") {
-
-    constexpr size_t buffer_size = 10000;
+TEST_CASE("Purge data from empty buffer") {
+    constexpr const size_t buffer_size = 10000;
     osmium::memory::Buffer buffer{buffer_size};
 
-    SECTION("purge empty buffer") {
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
 
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 0);
-        REQUIRE(buffer.committed() == 0);
-    }
-
-    SECTION("purge buffer with one object but nothing to delete") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-        }
-        buffer.commit();
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
-        const size_t committed = buffer.committed();
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 0);
-        REQUIRE(committed == buffer.committed());
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
-    }
-
-    SECTION("purge buffer with one object which gets deleted") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 0);
-        REQUIRE(buffer.committed() == 0);
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
-    }
-
-    SECTION("purge buffer with two objects, first gets deleted") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-        const size_t size1 = buffer.committed();
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-        }
-        buffer.commit();
-        const size_t size2 = buffer.committed() - size1;
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 1);
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
-        REQUIRE(buffer.committed() == size2);
-    }
-
-    SECTION("purge buffer with two objects, second gets deleted") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser_longer_name");
-        }
-        buffer.commit();
-        size_t size1 = buffer.committed();
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 0);
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
-        REQUIRE(buffer.committed() == size1);
-    }
-
-    SECTION("purge buffer with three objects, middle one gets deleted") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser_longer_name");
-        }
-        buffer.commit();
-
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("sn");
-        }
-        buffer.commit();
-
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 3);
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 1);
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
-    }
-
-    SECTION("purge buffer with three objects, all get deleted") {
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser_longer_name");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("testuser");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-
-        {
-            osmium::builder::NodeBuilder node_builder{buffer};
-            node_builder.set_user("sn");
-            node_builder.set_removed(true);
-        }
-        buffer.commit();
-
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 3);
-
-        CallbackClass callback;
-        buffer.purge_removed(&callback);
-
-        REQUIRE(callback.count == 0);
-        REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
-    }
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
 
+    REQUIRE(callback.count == 0);
+    REQUIRE(buffer.committed() == 0);
 }
+
+TEST_CASE("Purge buffer with one object but nothing to delete") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+    }
+    buffer.commit();
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+    const size_t committed = buffer.committed();
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 0);
+    REQUIRE(committed == buffer.committed());
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+}
+
+TEST_CASE("Purge buffer with one object which gets deleted") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 0);
+    REQUIRE(buffer.committed() == 0);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
+}
+
+TEST_CASE("Purge buffer without callback") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+
+    buffer.purge_removed();
+    REQUIRE(buffer.committed() == 0);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
+}
+
+TEST_CASE("Purge buffer with two objects, first gets deleted") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+    const size_t size1 = buffer.committed();
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+    }
+    buffer.commit();
+    const size_t size2 = buffer.committed() - size1;
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 1);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+    REQUIRE(buffer.committed() == size2);
+}
+
+TEST_CASE("Purge buffer with two objects, second gets deleted") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser_longer_name");
+    }
+    buffer.commit();
+    const size_t size1 = buffer.committed();
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 0);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 1);
+    REQUIRE(buffer.committed() == size1);
+}
+
+TEST_CASE("Purge buffer with three objects, middle one gets deleted") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser_longer_name");
+    }
+    buffer.commit();
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("sn");
+    }
+    buffer.commit();
+
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 3);
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 1);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 2);
+}
+
+TEST_CASE("Purge buffer with three objects, all get deleted") {
+    constexpr const size_t buffer_size = 10000;
+    osmium::memory::Buffer buffer{buffer_size};
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser_longer_name");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("testuser");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+
+    {
+        osmium::builder::NodeBuilder node_builder{buffer};
+        node_builder.set_user("sn");
+        node_builder.set_removed(true);
+    }
+    buffer.commit();
+
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 3);
+
+    CallbackClass callback;
+    buffer.purge_removed(&callback);
+
+    REQUIRE(callback.count == 0);
+    REQUIRE(std::distance(buffer.begin(), buffer.end()) == 0);
+}
+
diff --git a/third_party/libosmium/test/t/memory/test_item.cpp b/third_party/libosmium/test/t/memory/test_item.cpp
index 354e86e76..e7aceefad 100644
--- a/third_party/libosmium/test/t/memory/test_item.cpp
+++ b/third_party/libosmium/test/t/memory/test_item.cpp
@@ -10,20 +10,20 @@ TEST_CASE("padded length") {
     REQUIRE(osmium::memory::padded_length(8) ==  8);
     REQUIRE(osmium::memory::padded_length(9) == 16);
 
-    REQUIRE(osmium::memory::padded_length(2147483647ul) == 2147483648ul);
-    REQUIRE(osmium::memory::padded_length(2147483648ul) == 2147483648ul);
-    REQUIRE(osmium::memory::padded_length(2147483650ul) == 2147483656ul);
+    REQUIRE(osmium::memory::padded_length(2147483647UL) == 2147483648UL);
+    REQUIRE(osmium::memory::padded_length(2147483648UL) == 2147483648UL);
+    REQUIRE(osmium::memory::padded_length(2147483650UL) == 2147483656UL);
 
     // The following checks only make sense on a 64 bit system (with
     // sizeof(size_t) == 8), because the numbers are too large for 32 bit.
     // The casts to size_t do nothing on a 64 bit system, on a 32 bit system
     // they bring the numbers into the right range and everything still works.
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967295ull)) == static_cast<std::size_t>(4294967296ull));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967296ull)) == static_cast<std::size_t>(4294967296ull));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967297ull)) == static_cast<std::size_t>(4294967304ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967295ULL)) == static_cast<std::size_t>(4294967296ULL));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967296ULL)) == static_cast<std::size_t>(4294967296ULL));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(4294967297ULL)) == static_cast<std::size_t>(4294967304ULL));
 
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(7999999999ull)) == static_cast<std::size_t>(8000000000ull));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000000ull)) == static_cast<std::size_t>(8000000000ull));
-    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000001ull)) == static_cast<std::size_t>(8000000008ull));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(7999999999ULL)) == static_cast<std::size_t>(8000000000ULL));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000000ULL)) == static_cast<std::size_t>(8000000000ULL));
+    REQUIRE(osmium::memory::padded_length(static_cast<std::size_t>(8000000001ULL)) == static_cast<std::size_t>(8000000008ULL));
 }
 
diff --git a/third_party/libosmium/test/t/osm/test_area.cpp b/third_party/libosmium/test/t/osm/test_area.cpp
index ea60b2117..37744da5f 100644
--- a/third_party/libosmium/test/t/osm/test_area.cpp
+++ b/third_party/libosmium/test/t/osm/test_area.cpp
@@ -1,10 +1,12 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/area.hpp>
 #include <osmium/osm/crc.hpp>
 
-#include <boost/crc.hpp>
+#include <string>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
@@ -71,7 +73,7 @@ TEST_CASE("Build area") {
     REQUIRE(outer == 1);
     REQUIRE(inner == 1);
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(area);
     REQUIRE(crc32().checksum() == 0x2b2b7fa0);
 
diff --git a/third_party/libosmium/test/t/osm/test_box.cpp b/third_party/libosmium/test/t/osm/test_box.cpp
index 324330435..03cdb3eec 100644
--- a/third_party/libosmium/test/t/osm/test_box.cpp
+++ b/third_party/libosmium/test/t/osm/test_box.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/geom/relations.hpp>
 #include <osmium/osm/box.hpp>
 #include <osmium/osm/crc.hpp>
 
-#include <boost/crc.hpp>
-
 #include <sstream>
 
 TEST_CASE("Default constructor creates invalid box") {
@@ -14,7 +14,7 @@ TEST_CASE("Default constructor creates invalid box") {
     REQUIRE_FALSE(b);
     REQUIRE_FALSE(b.bottom_left());
     REQUIRE_FALSE(b.top_right());
-    REQUIRE_THROWS_AS(b.size(), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(b.size(), osmium::invalid_location);
 }
 
 TEST_CASE("Extend box with undefined") {
@@ -64,7 +64,7 @@ TEST_CASE("Extend box with valid") {
     REQUIRE(b.contains(loc2));
     REQUIRE(b.contains(loc3));
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(b);
     REQUIRE(crc32().checksum() == 0xd381a838);
 }
@@ -114,6 +114,10 @@ TEST_CASE("Create box from locations") {
     REQUIRE(!!b);
     REQUIRE(b.bottom_left() == (osmium::Location{1.23, 2.34}));
     REQUIRE(b.top_right() == (osmium::Location{3.45, 4.56}));
+    REQUIRE(b.top() == Approx(4.56));
+    REQUIRE(b.bottom() == Approx(2.34));
+    REQUIRE(b.left() == Approx(1.23));
+    REQUIRE(b.right() == Approx(3.45));
 }
 
 TEST_CASE("Create box from doubles") {
diff --git a/third_party/libosmium/test/t/osm/test_changeset.cpp b/third_party/libosmium/test/t/osm/test_changeset.cpp
index 64c02667e..eb44f2604 100644
--- a/third_party/libosmium/test/t/osm/test_changeset.cpp
+++ b/third_party/libosmium/test/t/osm/test_changeset.cpp
@@ -1,15 +1,19 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/changeset.hpp>
 #include <osmium/osm/crc.hpp>
 
-#include <boost/crc.hpp>
+#include <string>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
+constexpr const std::size_t test_buffer_size = 1024UL * 10UL;
+
 TEST_CASE("Build changeset") {
-    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::memory::Buffer buffer{test_buffer_size};
 
     osmium::builder::add_changeset(buffer,
         _cid(42),
@@ -29,12 +33,12 @@ TEST_CASE("Build changeset") {
     REQUIRE(7 == cs1.num_changes());
     REQUIRE(3 == cs1.num_comments());
     REQUIRE(cs1.closed());
-    REQUIRE(osmium::Timestamp(100) == cs1.created_at());
-    REQUIRE(osmium::Timestamp(200) == cs1.closed_at());
+    REQUIRE(osmium::Timestamp{100} == cs1.created_at());
+    REQUIRE(osmium::Timestamp{200} == cs1.closed_at());
     REQUIRE(1 == cs1.tags().size());
     REQUIRE(std::string("user") == cs1.user());
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(cs1);
     REQUIRE(crc32().checksum() == 0x502e8c0e);
 
@@ -58,8 +62,8 @@ TEST_CASE("Build changeset") {
     REQUIRE(21 == cs2.num_changes());
     REQUIRE(0 == cs2.num_comments());
     REQUIRE_FALSE(cs2.closed());
-    REQUIRE(osmium::Timestamp(120) == cs2.created_at());
-    REQUIRE(osmium::Timestamp() == cs2.closed_at());
+    REQUIRE(osmium::Timestamp{120} == cs2.created_at());
+    REQUIRE(osmium::Timestamp{} == cs2.closed_at());
     REQUIRE(2 == cs2.tags().size());
     REQUIRE(std::string("user") == cs2.user());
 
@@ -73,13 +77,13 @@ TEST_CASE("Build changeset") {
     auto cit = cs2.discussion().begin();
 
     REQUIRE(cit != cs2.discussion().end());
-    REQUIRE(cit->date() == osmium::Timestamp(300));
+    REQUIRE(cit->date() == osmium::Timestamp{300});
     REQUIRE(cit->uid() == 10);
     REQUIRE(std::string("user2") == cit->user());
     REQUIRE(std::string("foo") == cit->text());
 
     REQUIRE(++cit != cs2.discussion().end());
-    REQUIRE(cit->date() == osmium::Timestamp(400));
+    REQUIRE(cit->date() == osmium::Timestamp{400});
     REQUIRE(cit->uid() == 9);
     REQUIRE(std::string("user") == cit->user());
     REQUIRE(std::string("bar") == cit->text());
@@ -88,7 +92,7 @@ TEST_CASE("Build changeset") {
 }
 
 TEST_CASE("Create changeset without helper") {
-    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::memory::Buffer buffer{test_buffer_size};
     {
         osmium::builder::ChangesetBuilder builder{buffer};
 
@@ -107,9 +111,9 @@ TEST_CASE("Create changeset without helper") {
         }
 
         osmium::builder::ChangesetDiscussionBuilder disc_builder{builder};
-        disc_builder.add_comment(osmium::Timestamp(300), 10, "user2");
+        disc_builder.add_comment(osmium::Timestamp{300}, 10, "user2");
         disc_builder.add_comment_text("foo");
-        disc_builder.add_comment(osmium::Timestamp(400), 9, "user");
+        disc_builder.add_comment(osmium::Timestamp{400}, 9, "user");
         disc_builder.add_comment_text("bar");
     }
 
@@ -120,21 +124,21 @@ TEST_CASE("Create changeset without helper") {
     REQUIRE(7 == cs.num_changes());
     REQUIRE(2 == cs.num_comments());
     REQUIRE(cs.closed());
-    REQUIRE(osmium::Timestamp(100) == cs.created_at());
-    REQUIRE(osmium::Timestamp(200) == cs.closed_at());
+    REQUIRE(osmium::Timestamp{100} == cs.created_at());
+    REQUIRE(osmium::Timestamp{200} == cs.closed_at());
     REQUIRE(2 == cs.tags().size());
     REQUIRE(std::string("user") == cs.user());
 
     auto cit = cs.discussion().begin();
 
     REQUIRE(cit != cs.discussion().end());
-    REQUIRE(cit->date() == osmium::Timestamp(300));
+    REQUIRE(cit->date() == osmium::Timestamp{300});
     REQUIRE(cit->uid() == 10);
     REQUIRE(std::string("user2") == cit->user());
     REQUIRE(std::string("foo") == cit->text());
 
     REQUIRE(++cit != cs.discussion().end());
-    REQUIRE(cit->date() == osmium::Timestamp(400));
+    REQUIRE(cit->date() == osmium::Timestamp{400});
     REQUIRE(cit->uid() == 9);
     REQUIRE(std::string("user") == cit->user());
     REQUIRE(std::string("bar") == cit->text());
@@ -142,3 +146,45 @@ TEST_CASE("Create changeset without helper") {
     REQUIRE(++cit == cs.discussion().end());
 }
 
+TEST_CASE("Change changeset") {
+    osmium::memory::Buffer buffer{test_buffer_size};
+
+    osmium::builder::add_changeset(buffer,
+        _cid(42),
+        _created_at(time_t(100)),
+        _closed_at(time_t(200)),
+        _num_changes(7),
+        _num_comments(3),
+        _uid(9),
+        _user("user"),
+        _tag("comment", "foo")
+    );
+
+    auto& cs = buffer.get<osmium::Changeset>(0);
+
+    cs.set_id(12);
+    cs.set_created_at(time_t(200));
+    cs.set_closed_at(time_t(300));
+    cs.set_num_changes(3);
+    cs.set_num_comments(4);
+    cs.set_uid(10);
+    cs.clear_user();
+
+    REQUIRE(12 == cs.id());
+    REQUIRE(10 == cs.uid());
+    REQUIRE(3 == cs.num_changes());
+    REQUIRE(4 == cs.num_comments());
+    REQUIRE(cs.closed());
+    REQUIRE(osmium::Timestamp{200} == cs.created_at());
+    REQUIRE(osmium::Timestamp{300} == cs.closed_at());
+    REQUIRE(1 == cs.tags().size());
+    REQUIRE(std::string("") == cs.user());
+    REQUIRE(cs.tags().size() == 1);
+
+    auto it = cs.tags().begin();
+    REQUIRE(it->key() == std::string{"comment"});
+    REQUIRE(it->value() == std::string{"foo"});
+    ++it;
+    REQUIRE(it == cs.tags().end());
+}
+
diff --git a/third_party/libosmium/test/t/osm/test_crc.cpp b/third_party/libosmium/test/t/osm/test_crc.cpp
index 6f304c1ff..dd9c0079e 100644
--- a/third_party/libosmium/test/t/osm/test_crc.cpp
+++ b/third_party/libosmium/test/t/osm/test_crc.cpp
@@ -1,11 +1,11 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/osm/crc.hpp>
 
-#include <boost/crc.hpp>
-
 TEST_CASE("CRC of bool") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     crc32.update_bool(true);
     crc32.update_bool(false);
@@ -14,7 +14,7 @@ TEST_CASE("CRC of bool") {
 }
 
 TEST_CASE("CRC of char") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     crc32.update_int8('x');
     crc32.update_int8('y');
@@ -23,7 +23,7 @@ TEST_CASE("CRC of char") {
 }
 
 TEST_CASE("CRC of int16") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     crc32.update_int16(0x0123U);
     crc32.update_int16(0x1234U);
@@ -32,7 +32,7 @@ TEST_CASE("CRC of int16") {
 }
 
 TEST_CASE("CRC of int32") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     crc32.update_int32(0x01234567UL);
     crc32.update_int32(0x12345678UL);
@@ -41,7 +41,7 @@ TEST_CASE("CRC of int32") {
 }
 
 TEST_CASE("CRC of int64") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     crc32.update_int64(0x0123456789abcdefULL);
     crc32.update_int64(0x123456789abcdef0ULL);
@@ -50,7 +50,7 @@ TEST_CASE("CRC of int64") {
 }
 
 TEST_CASE("CRC of string") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     const char* str = "foobar";
     crc32.update_string(str);
@@ -59,7 +59,7 @@ TEST_CASE("CRC of string") {
 }
 
 TEST_CASE("CRC of Timestamp") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     const osmium::Timestamp t{"2015-07-12T13:10:46Z"};
     crc32.update(t);
@@ -68,7 +68,7 @@ TEST_CASE("CRC of Timestamp") {
 }
 
 TEST_CASE("CRC of Location") {
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
 
     const osmium::Location loc{3.46, 2.001};
     crc32.update(loc);
diff --git a/third_party/libosmium/test/t/osm/test_location.cpp b/third_party/libosmium/test/t/osm/test_location.cpp
index 7d5043192..7d2967a02 100644
--- a/third_party/libosmium/test/t/osm/test_location.cpp
+++ b/third_party/libosmium/test/t/osm/test_location.cpp
@@ -2,8 +2,12 @@
 
 #include <osmium/osm/location.hpp>
 
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
 #include <limits>
 #include <sstream>
+#include <string>
 #include <type_traits>
 
 // fails on MSVC and doesn't really matter
@@ -14,8 +18,8 @@ TEST_CASE("Location instantiation with default parameters") {
     REQUIRE_FALSE(loc);
     REQUIRE_FALSE(loc.is_defined());
     REQUIRE(loc.is_undefined());
-    REQUIRE_THROWS_AS(loc.lon(), const osmium::invalid_location&);
-    REQUIRE_THROWS_AS(loc.lat(), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(loc.lon(), osmium::invalid_location);
+    REQUIRE_THROWS_AS(loc.lat(), osmium::invalid_location);
 }
 
 TEST_CASE("Location instantiation with double parameters") {
@@ -109,7 +113,7 @@ TEST_CASE("Location output to iterator check precision") {
 TEST_CASE("Location output to iterator undefined location") {
     char buffer[100];
     const osmium::Location loc;
-    REQUIRE_THROWS_AS(loc.as_string(buffer, ','), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(loc.as_string(buffer, ','), osmium::invalid_location);
 }
 
 TEST_CASE("Location output to string comman separator") {
@@ -136,7 +140,7 @@ TEST_CASE("Location output to string check precision") {
 TEST_CASE("Location output to string undefined location") {
     std::string s;
     const osmium::Location loc;
-    REQUIRE_THROWS_AS(loc.as_string(std::back_inserter(s), ','), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(loc.as_string(std::back_inserter(s), ','), osmium::invalid_location);
 }
 
 TEST_CASE("Location output defined") {
@@ -172,8 +176,8 @@ TEST_CASE("Location hash") {
 void C(const char* s, int32_t v, const char* r = "") {
     std::string strm{"-"};
     strm += s;
-    REQUIRE(std::atof(strm.c_str() + 1) == Approx( v / 10000000.0)); // NOLINT(cert-err34-c)
-    REQUIRE(std::atof(strm.c_str()    ) == Approx(-v / 10000000.0)); // NOLINT(cert-err34-c)
+    REQUIRE(std::atof(strm.c_str() + 1) == Approx( v / 10000000.0).scale(1.0)); // NOLINT(cert-err34-c)
+    REQUIRE(std::atof(strm.c_str()    ) == Approx(-v / 10000000.0).scale(1.0)); // NOLINT(cert-err34-c)
     const char* x = strm.c_str() + 1;
     const char** data = &x;
     REQUIRE(osmium::detail::string_to_location_coordinate(data) == v);
@@ -189,10 +193,10 @@ void F(const char* s) {
     strm += s;
     const char* x = strm.c_str();
     const char** data = &x;
-    REQUIRE_THROWS_AS(osmium::detail::string_to_location_coordinate(data), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(osmium::detail::string_to_location_coordinate(data), osmium::invalid_location);
     ++x;
     data = &x;
-    REQUIRE_THROWS_AS(osmium::detail::string_to_location_coordinate(data), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(osmium::detail::string_to_location_coordinate(data), osmium::invalid_location);
 }
 
 TEST_CASE("Parsing coordinates from strings") {
@@ -410,8 +414,8 @@ TEST_CASE("set lon/lat from string") {
 
 TEST_CASE("set lon/lat from string with trailing characters") {
     osmium::Location loc;
-    REQUIRE_THROWS_AS(loc.set_lon("1.2x"), const osmium::invalid_location&);
-    REQUIRE_THROWS_AS(loc.set_lat("3.4e1 "), const osmium::invalid_location&);
+    REQUIRE_THROWS_AS(loc.set_lon("1.2x"), osmium::invalid_location);
+    REQUIRE_THROWS_AS(loc.set_lat("3.4e1 "), osmium::invalid_location);
 }
 
 TEST_CASE("set lon/lat from string with trailing characters using partial") {
diff --git a/third_party/libosmium/test/t/osm/test_metadata.cpp b/third_party/libosmium/test/t/osm/test_metadata.cpp
index c192b386c..37121332c 100644
--- a/third_party/libosmium/test/t/osm/test_metadata.cpp
+++ b/third_party/libosmium/test/t/osm/test_metadata.cpp
@@ -5,6 +5,8 @@
 #include <osmium/osm/metadata_options.hpp>
 #include <osmium/osm/object.hpp>
 
+#include <stdexcept>
+
 TEST_CASE("Metadata options: default") {
     const osmium::metadata_options m{};
     REQUIRE_FALSE(m.none());
@@ -90,11 +92,11 @@ TEST_CASE("Metadata options: timestamp,uid,user") {
 }
 
 TEST_CASE("Metadata options: fail") {
-    REQUIRE_THROWS_AS(osmium::metadata_options{"timestamp+foo"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::metadata_options{"timestamp+foo"}, std::invalid_argument);
 }
 
 TEST_CASE("Metdata options: constructor using OSMObject") {
-    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::memory::Buffer buffer{10UL * 1024UL};
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
     SECTION("only version") {
diff --git a/third_party/libosmium/test/t/osm/test_node.cpp b/third_party/libosmium/test/t/osm/test_node.cpp
index 06b6dcbe5..42081fbe8 100644
--- a/third_party/libosmium/test/t/osm/test_node.cpp
+++ b/third_party/libosmium/test/t/osm/test_node.cpp
@@ -1,10 +1,12 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/node.hpp>
 
-#include <boost/crc.hpp>
+#include <string>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
@@ -29,8 +31,8 @@ TEST_CASE("Build node") {
     REQUIRE(osmium::item_type::node == node.type());
     REQUIRE(node.type_is_in(osmium::osm_entity_bits::node));
     REQUIRE(node.type_is_in(osmium::osm_entity_bits::nwr));
-    REQUIRE(17l == node.id());
-    REQUIRE(17ul == node.positive_id());
+    REQUIRE(17L == node.id());
+    REQUIRE(17UL == node.positive_id());
     REQUIRE(3 == node.version());
     REQUIRE(node.visible());
     REQUIRE_FALSE(node.deleted());
@@ -41,13 +43,16 @@ TEST_CASE("Build node") {
     REQUIRE(osmium::Location(3.5, 4.7) == node.location());
     REQUIRE(2 == node.tags().size());
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(node);
     REQUIRE(crc32().checksum() == 0x7dc553f9);
 
     node.set_visible(false);
     REQUIRE_FALSE(node.visible());
     REQUIRE(node.deleted());
+
+    node.remove_tags();
+    REQUIRE(node.tags().empty());
 }
 
 TEST_CASE("default values for node attributes") {
@@ -56,8 +61,8 @@ TEST_CASE("default values for node attributes") {
     osmium::builder::add_node(buffer, _id(0));
 
     const osmium::Node& node = buffer.get<osmium::Node>(0);
-    REQUIRE(0l == node.id());
-    REQUIRE(0ul == node.positive_id());
+    REQUIRE(0L == node.id());
+    REQUIRE(0UL == node.positive_id());
     REQUIRE(0 == node.version());
     REQUIRE(node.visible());
     REQUIRE(0 == node.changeset());
@@ -81,8 +86,8 @@ TEST_CASE("set node attributes from strings") {
         .set_timestamp("2014-03-17T16:23:08Z")
         .set_uid("21");
 
-    REQUIRE(-17l == node.id());
-    REQUIRE(17ul == node.positive_id());
+    REQUIRE(-17L == node.id());
+    REQUIRE(17UL == node.positive_id());
     REQUIRE(3 == node.version());
     REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
@@ -103,8 +108,8 @@ TEST_CASE("set node attributes from strings using set_attribute()") {
         .set_attribute("timestamp", "2014-03-17T16:23:08Z")
         .set_attribute("uid", "21");
 
-    REQUIRE(-17l == node.id());
-    REQUIRE(17ul == node.positive_id());
+    REQUIRE(-17L == node.id());
+    REQUIRE(17UL == node.positive_id());
     REQUIRE(3 == node.version());
     REQUIRE(node.visible());
     REQUIRE(333 == node.changeset());
@@ -133,7 +138,7 @@ TEST_CASE("Setting attributes from bad data on strings should fail") {
 TEST_CASE("set large id") {
     osmium::memory::Buffer buffer{10000};
 
-    const int64_t id = 3000000000l;
+    const int64_t id = 3000000000L;
     osmium::builder::add_node(buffer, _id(id));
 
     auto& node = buffer.get<osmium::Node>(0);
diff --git a/third_party/libosmium/test/t/osm/test_object_comparisons.cpp b/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
index 3db92842d..2254ce41d 100644
--- a/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
+++ b/third_party/libosmium/test/t/osm/test_object_comparisons.cpp
@@ -11,6 +11,8 @@
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
+constexpr const std::size_t test_buffer_size = 1024UL * 10UL;
+
 TEST_CASE("Object ID comparisons") {
     const osmium::object_id_type a =   0;
     const osmium::object_id_type b =  -1;
@@ -77,9 +79,75 @@ TEST_CASE("Object ID comparisons") {
     REQUIRE_FALSE(osmium::id_order{}(g, g));
 }
 
+TEST_CASE("Object ID comparisons - the other way around") {
+    const osmium::object_id_type a =   0;
+    const osmium::object_id_type b =  -1;
+    const osmium::object_id_type c = -10;
+    const osmium::object_id_type d = -11;
+    const osmium::object_id_type e =   1;
+    const osmium::object_id_type f =  11;
+    const osmium::object_id_type g =  12;
+
+    REQUIRE_FALSE(osmium::id_order{}(a, a));
+    REQUIRE_FALSE(osmium::id_order{}(b, a));
+    REQUIRE_FALSE(osmium::id_order{}(c, a));
+    REQUIRE_FALSE(osmium::id_order{}(d, a));
+    REQUIRE_FALSE(osmium::id_order{}(e, a));
+    REQUIRE_FALSE(osmium::id_order{}(f, a));
+    REQUIRE_FALSE(osmium::id_order{}(g, a));
+
+    REQUIRE(osmium::id_order{}(a, b));
+    REQUIRE_FALSE(osmium::id_order{}(b, b));
+    REQUIRE_FALSE(osmium::id_order{}(c, b));
+    REQUIRE_FALSE(osmium::id_order{}(d, b));
+    REQUIRE_FALSE(osmium::id_order{}(e, b));
+    REQUIRE_FALSE(osmium::id_order{}(f, b));
+    REQUIRE_FALSE(osmium::id_order{}(g, b));
+
+    REQUIRE(osmium::id_order{}(a, c));
+    REQUIRE(osmium::id_order{}(b, c));
+    REQUIRE_FALSE(osmium::id_order{}(c, c));
+    REQUIRE_FALSE(osmium::id_order{}(d, c));
+    REQUIRE_FALSE(osmium::id_order{}(e, c));
+    REQUIRE_FALSE(osmium::id_order{}(f, c));
+    REQUIRE_FALSE(osmium::id_order{}(g, c));
+
+    REQUIRE(osmium::id_order{}(a, d));
+    REQUIRE(osmium::id_order{}(b, d));
+    REQUIRE(osmium::id_order{}(c, d));
+    REQUIRE_FALSE(osmium::id_order{}(d, d));
+    REQUIRE_FALSE(osmium::id_order{}(e, d));
+    REQUIRE_FALSE(osmium::id_order{}(f, d));
+    REQUIRE_FALSE(osmium::id_order{}(g, d));
+
+    REQUIRE(osmium::id_order{}(a, e));
+    REQUIRE(osmium::id_order{}(b, e));
+    REQUIRE(osmium::id_order{}(c, e));
+    REQUIRE(osmium::id_order{}(d, e));
+    REQUIRE_FALSE(osmium::id_order{}(e, e));
+    REQUIRE_FALSE(osmium::id_order{}(f, e));
+    REQUIRE_FALSE(osmium::id_order{}(g, e));
+
+    REQUIRE(osmium::id_order{}(a, f));
+    REQUIRE(osmium::id_order{}(b, f));
+    REQUIRE(osmium::id_order{}(c, f));
+    REQUIRE(osmium::id_order{}(d, f));
+    REQUIRE(osmium::id_order{}(e, f));
+    REQUIRE_FALSE(osmium::id_order{}(f, f));
+    REQUIRE_FALSE(osmium::id_order{}(g, f));
+
+    REQUIRE(osmium::id_order{}(a, g));
+    REQUIRE(osmium::id_order{}(b, g));
+    REQUIRE(osmium::id_order{}(c, g));
+    REQUIRE(osmium::id_order{}(d, g));
+    REQUIRE(osmium::id_order{}(e, g));
+    REQUIRE(osmium::id_order{}(f, g));
+    REQUIRE_FALSE(osmium::id_order{}(g, g));
+}
+
 TEST_CASE("Node comparisons") {
 
-    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::vector<std::reference_wrapper<osmium::Node>> nodes;
 
     SECTION("nodes are ordered by id, version, and timestamp") {
@@ -90,7 +158,7 @@ TEST_CASE("Node comparisons") {
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           12), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           12), _version(2), _timestamp("2016-01-01T00:01:00Z"))));
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           15), _version(1), _timestamp("2016-01-01T00:00:00Z"))));
-        nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(10000000000ll), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
+        nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(10000000000LL), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
 
         REQUIRE(std::is_sorted(nodes.cbegin(), nodes.cend()));
     }
@@ -122,7 +190,7 @@ TEST_CASE("Node comparisons") {
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           12), _version(2), _timestamp("2016-01-01T00:01:00Z"))));
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           12), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
         nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(           15), _version(1), _timestamp("2016-01-01T00:00:00Z"))));
-        nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(10000000000ll), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
+        nodes.emplace_back(buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(10000000000LL), _version(2), _timestamp("2016-01-01T00:00:00Z"))));
 
         REQUIRE(std::is_sorted(nodes.cbegin(), nodes.cend(), osmium::object_order_type_id_reverse_version{}));
     }
@@ -130,7 +198,7 @@ TEST_CASE("Node comparisons") {
 }
 
 TEST_CASE("Object comparisons: types are ordered nodes, then ways, then relations") {
-    osmium::memory::Buffer buffer{10 * 1000};
+    osmium::memory::Buffer buffer{test_buffer_size};
     std::vector<std::reference_wrapper<osmium::OSMObject>> objects;
 
     objects.emplace_back(buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer, _id(3))));
@@ -141,11 +209,9 @@ TEST_CASE("Object comparisons: types are ordered nodes, then ways, then relation
 }
 
 TEST_CASE("Object comparisons with partially missing timestamp") {
-    osmium::memory::Buffer buffer{10 * 1000};
-    osmium::OSMObject& obj1 = buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer,
-            _id(3), _version(2), _timestamp(("2016-01-01T00:00:00Z"))));
-    osmium::OSMObject& obj2 = buffer.get<osmium::Node>(    osmium::builder::add_node(    buffer,
-            _id(3), _version(2)));
+    osmium::memory::Buffer buffer{test_buffer_size};
+    const osmium::OSMObject& obj1 = buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(3), _version(2), _timestamp(("2016-01-01T00:00:00Z"))));
+    const osmium::OSMObject& obj2 = buffer.get<osmium::Node>(osmium::builder::add_node(buffer, _id(3), _version(2)));
 
     SECTION("OSMObject::operator<") {
         REQUIRE_FALSE(obj1 < obj2);
diff --git a/third_party/libosmium/test/t/osm/test_relation.cpp b/third_party/libosmium/test/t/osm/test_relation.cpp
index cde348892..0170e9625 100644
--- a/third_party/libosmium/test/t/osm/test_relation.cpp
+++ b/third_party/libosmium/test/t/osm/test_relation.cpp
@@ -1,10 +1,12 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/builder/attr.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/relation.hpp>
 
-#include <boost/crc.hpp>
+#include <string>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
@@ -39,7 +41,7 @@ TEST_CASE("Build relation") {
     REQUIRE(3 == relation.members().size());
 
     int n=1;
-    for (auto& member : relation.members()) {
+    for (const auto& member : relation.members()) {
         REQUIRE(osmium::item_type::way == member.type());
         REQUIRE(n == member.ref());
         switch (n) {
@@ -58,7 +60,7 @@ TEST_CASE("Build relation") {
         ++n;
     }
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(relation);
     REQUIRE(crc32().checksum() == 0x2c2352e);
 }
diff --git a/third_party/libosmium/test/t/osm/test_timestamp.cpp b/third_party/libosmium/test/t/osm/test_timestamp.cpp
index 97546dc13..57fead6eb 100644
--- a/third_party/libosmium/test/t/osm/test_timestamp.cpp
+++ b/third_party/libosmium/test/t/osm/test_timestamp.cpp
@@ -3,6 +3,7 @@
 #include <osmium/osm/timestamp.hpp>
 
 #include <sstream>
+#include <stdexcept>
 #include <string>
 #include <vector>
 
@@ -10,6 +11,7 @@ TEST_CASE("Timestamp can be default initialized to invalid value") {
     const osmium::Timestamp t{};
     REQUIRE(0 == uint32_t(t));
     REQUIRE(t.to_iso().empty());
+    REQUIRE(t.to_iso_all() == "1970-01-01T00:00:00Z");
     REQUIRE_FALSE(t.valid());
 }
 
@@ -17,6 +19,7 @@ TEST_CASE("Timestamp invalid value is zero") {
     const osmium::Timestamp t{static_cast<time_t>(0)};
     REQUIRE(0 == uint32_t(t));
     REQUIRE(t.to_iso().empty());
+    REQUIRE(t.to_iso_all() == "1970-01-01T00:00:00Z");
     REQUIRE_FALSE(t.valid());
 }
 
@@ -41,7 +44,7 @@ TEST_CASE("Timestamp can be initialized from string") {
 }
 
 TEST_CASE("Timestamp throws if initialized from bad string") {
-    REQUIRE_THROWS_AS(osmium::Timestamp("x"), const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp("x"), std::invalid_argument);
 }
 
 TEST_CASE("Timestamp can be explicitly cast to time_t") {
@@ -119,31 +122,32 @@ TEST_CASE("Valid timestamps") {
     for (const auto& tc : test_cases) {
         const osmium::Timestamp t{tc};
         REQUIRE(tc == t.to_iso());
+        REQUIRE(tc == t.to_iso_all());
     }
 }
 
 TEST_CASE("Invalid timestamps") {
-    REQUIRE_THROWS_AS(osmium::Timestamp{""}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"x"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"xxxxxxxxxxxxxxxxxxxx"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp{""}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"x"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"xxxxxxxxxxxxxxxxxxxx"}, std::invalid_argument);
 
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01x00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00:00x"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01x00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00:00x"}, std::invalid_argument);
 
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000x01-01T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01x01T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00x00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00x00Z"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000x01-01T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01x01T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00x00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00x00Z"}, std::invalid_argument);
 
-    REQUIRE_THROWS_AS(osmium::Timestamp{"0000-00-01T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-00-01T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-00T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T24:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:60:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00:61Z"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"0000-00-01T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-00-01T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-00T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T24:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:60:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-01T00:00:61Z"}, std::invalid_argument);
 
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-32T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-02-30T00:00:00Z"}, const std::invalid_argument&);
-    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-03-32T00:00:00Z"}, const std::invalid_argument&);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-01-32T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-02-30T00:00:00Z"}, std::invalid_argument);
+    REQUIRE_THROWS_AS(osmium::Timestamp{"2000-03-32T00:00:00Z"}, std::invalid_argument);
 }
 
diff --git a/third_party/libosmium/test/t/osm/test_types_from_string.cpp b/third_party/libosmium/test/t/osm/test_types_from_string.cpp
index 1cc7c3a89..3a2d3ff44 100644
--- a/third_party/libosmium/test/t/osm/test_types_from_string.cpp
+++ b/third_party/libosmium/test/t/osm/test_types_from_string.cpp
@@ -3,19 +3,21 @@
 #include <osmium/osm/types.hpp>
 #include <osmium/osm/types_from_string.hpp>
 
+#include <stdexcept>
+
 TEST_CASE("set ID from string") {
     REQUIRE(osmium::string_to_object_id("0") == 0);
     REQUIRE(osmium::string_to_object_id("17") == 17);
     REQUIRE(osmium::string_to_object_id("-17") == -17);
     REQUIRE(osmium::string_to_object_id("01") == 1);
 
-    REQUIRE_THROWS_AS(osmium::string_to_object_id(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("0x1"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("12a"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("12345678901234567890"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id(""), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id(" "), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id(" 22"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("x"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("0x1"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("12a"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("12345678901234567890"), std::range_error);
 }
 
 TEST_CASE("set type and ID from string") {
@@ -43,12 +45,12 @@ TEST_CASE("set type and ID from string") {
     REQUIRE(n3.first == osmium::item_type::node);
     REQUIRE(n3.second == 3);
 
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("", osmium::osm_entity_bits::nwr), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("n", osmium::osm_entity_bits::nwr), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("x3", osmium::osm_entity_bits::nwr), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("nx3", osmium::osm_entity_bits::nwr), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("n3", osmium::osm_entity_bits::way), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_id("n3a", osmium::osm_entity_bits::nwr), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("", osmium::osm_entity_bits::nwr), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("n", osmium::osm_entity_bits::nwr), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("x3", osmium::osm_entity_bits::nwr), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("nx3", osmium::osm_entity_bits::nwr), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("n3", osmium::osm_entity_bits::way), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_id("n3a", osmium::osm_entity_bits::nwr), std::range_error);
 }
 
 TEST_CASE("set object version from string") {
@@ -57,13 +59,13 @@ TEST_CASE("set object version from string") {
     REQUIRE(osmium::string_to_object_version("-1") == 0);
     REQUIRE(osmium::string_to_object_version("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_object_version("-2"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version("4294967295"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_object_version("999999999999"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("-2"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version(""), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version(" "), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version(" 22"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("x"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("4294967295"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_object_version("999999999999"), std::range_error);
 }
 
 TEST_CASE("set changeset id from string") {
@@ -72,29 +74,13 @@ TEST_CASE("set changeset id from string") {
     REQUIRE(osmium::string_to_changeset_id("-1") == 0);
     REQUIRE(osmium::string_to_changeset_id("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("-2"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("4294967295"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("999999999999"), const std::range_error&);
-}
-
-TEST_CASE("set user id from string") {
-    REQUIRE(osmium::string_to_user_id("0") == 0);
-    REQUIRE(osmium::string_to_user_id("1") == 1);
-    REQUIRE(osmium::string_to_user_id("-1") == -1);
-    REQUIRE(osmium::string_to_user_id("2147483647") == 2147483647);
-
-    REQUIRE_THROWS_AS(osmium::string_to_user_id("-2"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id("2147483648"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id("4294967295"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_user_id("999999999999"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("-2"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(""), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" "), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id(" 22"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("x"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("4294967295"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_changeset_id("999999999999"), std::range_error);
 }
 
 TEST_CASE("set uid from string") {
@@ -103,13 +89,13 @@ TEST_CASE("set uid from string") {
     REQUIRE(osmium::string_to_uid("-1") == 0);
     REQUIRE(osmium::string_to_uid("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_uid("-2"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid("4294967295"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_uid("999999999999"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("-2"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(""), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(" "), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid(" 22"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("x"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("4294967295"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_uid("999999999999"), std::range_error);
 }
 
 TEST_CASE("set num changes from string") {
@@ -118,12 +104,12 @@ TEST_CASE("set num changes from string") {
     REQUIRE(osmium::string_to_num_changes("-1") == 0);
     REQUIRE(osmium::string_to_num_changes("4294967294") == 4294967294);
 
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes("-2"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes(""), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes(" "), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes(" 22"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes("x"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes("4294967295"), const std::range_error&);
-    REQUIRE_THROWS_AS(osmium::string_to_num_changes("999999999999"), const std::range_error&);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("-2"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes(""), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes(" "), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes(" 22"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("x"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("4294967295"), std::range_error);
+    REQUIRE_THROWS_AS(osmium::string_to_num_changes("999999999999"), std::range_error);
 }
 
diff --git a/third_party/libosmium/test/t/osm/test_way.cpp b/third_party/libosmium/test/t/osm/test_way.cpp
index d91a731df..b7bd087fd 100644
--- a/third_party/libosmium/test/t/osm/test_way.cpp
+++ b/third_party/libosmium/test/t/osm/test_way.cpp
@@ -1,11 +1,13 @@
 #include "catch.hpp"
 
+#include "test_crc.hpp"
+
 #include <osmium/builder/attr.hpp>
 #include <osmium/builder/osm_object_builder.hpp>
 #include <osmium/osm/crc.hpp>
 #include <osmium/osm/way.hpp>
 
-#include <boost/crc.hpp>
+#include <string>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
@@ -25,7 +27,7 @@ TEST_CASE("Build way") {
         _nodes({1, 3, 2})
     );
 
-    const osmium::Way& way = buffer.get<osmium::Way>(0);
+    auto& way = buffer.get<osmium::Way>(0);
 
     REQUIRE(osmium::item_type::way == way.type());
     REQUIRE(way.type_is_in(osmium::osm_entity_bits::way));
@@ -44,9 +46,13 @@ TEST_CASE("Build way") {
     REQUIRE(2 == way.nodes()[2].ref());
     REQUIRE_FALSE(way.is_closed());
 
-    osmium::CRC<boost::crc_32_type> crc32;
+    osmium::CRC<crc_type> crc32;
     crc32.update(way);
     REQUIRE(crc32().checksum() == 0x65f6ba91);
+
+    way.remove_tags();
+    REQUIRE(way.tags().empty());
+    REQUIRE(3 == way.nodes().size());
 }
 
 TEST_CASE("build closed way") {
diff --git a/third_party/libosmium/test/t/relations/missing_members.osm b/third_party/libosmium/test/t/relations/missing_members.osm
new file mode 100644
index 000000000..a6c0cb0e0
--- /dev/null
+++ b/third_party/libosmium/test/t/relations/missing_members.osm
@@ -0,0 +1,38 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<osm version="0.6" generator="testdata" upload="false">
+    <node id="10" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.0"/>
+    <node id="11" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.1"/>
+    <node id="12" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.2"/>
+    <node id="13" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.3"/>
+    <node id="14" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1" lat="1.0" lon="1.4">
+      <tag k="amenity" v="bench" />
+    </node>
+    <way id="20" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="public_transport" v="platform"/>
+        <nd ref="10"/>
+        <nd ref="11"/>
+    </way>
+    <way id="21" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="public_transport" v="platform"/>
+        <nd ref="13"/>
+        <nd ref="12"/>
+    </way>
+    <relation id="31" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="public_transport"/>
+        <tag k="public_transport" v="stop_area"/>
+        <member type="way" ref="20" role="platform"/>
+        <member type="way" ref="21" role="platform"/>
+        <member type="node" ref="14" role=""/>
+        <member type="relation" ref="30" role="building"/>
+        <member type="node" ref="15" role=""/>
+        <member type="relation" ref="32" role="building"/>
+        <member type="relation" ref="33" role="building"/>
+        <member type="way" ref="22" role="platform"/>
+    </relation>
+    <relation id="32" version="1" timestamp="2014-01-01T00:00:00Z" uid="1" user="test" changeset="1">
+        <tag k="type" v="multipolygon"/>
+        <tag k="public_transport" v="platform"/>
+        <member type="way" ref="23" role="outer"/>
+        <member type="way" ref="24" role="inner"/>
+    </relation>
+</osm>
diff --git a/third_party/libosmium/test/t/relations/test_members_database.cpp b/third_party/libosmium/test/t/relations/test_members_database.cpp
index 3aea66699..9bca8c976 100644
--- a/third_party/libosmium/test/t/relations/test_members_database.cpp
+++ b/third_party/libosmium/test/t/relations/test_members_database.cpp
@@ -8,7 +8,7 @@
 
 osmium::memory::Buffer fill_buffer() {
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-    osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+    osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
         _id(20),
@@ -99,7 +99,7 @@ TEST_CASE("Fill member database") {
 
 TEST_CASE("Member database with duplicate member in relation") {
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-    osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+    osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
         _id(20),
diff --git a/third_party/libosmium/test/t/relations/test_relations_database.cpp b/third_party/libosmium/test/t/relations/test_relations_database.cpp
index 7443490e7..2fe9db4ab 100644
--- a/third_party/libosmium/test/t/relations/test_relations_database.cpp
+++ b/third_party/libosmium/test/t/relations/test_relations_database.cpp
@@ -5,9 +5,11 @@
 #include <osmium/relations/relations_database.hpp>
 #include <osmium/storage/item_stash.hpp>
 
+#include <vector>
+
 osmium::memory::Buffer fill_buffer() {
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
-    osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+    osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
     osmium::builder::add_relation(buffer,
         _id(1),
@@ -51,7 +53,7 @@ TEST_CASE("Fill relation database") {
     int n = 0;
     rdb.for_each_relation([&](const osmium::relations::RelationHandle& rel_handle) {
         ++n;
-        REQUIRE(rel_handle->members().size() == (*rel_handle).id());
+        REQUIRE(rel_handle->members().size() == static_cast<std::size_t>(rel_handle->id()));
     });
     REQUIRE(n == 3);
 }
diff --git a/third_party/libosmium/test/t/relations/test_relations_manager.cpp b/third_party/libosmium/test/t/relations/test_relations_manager.cpp
index 954cbb85c..f5d34941c 100644
--- a/third_party/libosmium/test/t/relations/test_relations_manager.cpp
+++ b/third_party/libosmium/test/t/relations/test_relations_manager.cpp
@@ -6,6 +6,8 @@
 #include <osmium/osm/relation.hpp>
 #include <osmium/relations/relations_manager.hpp>
 
+#include <iterator>
+
 struct EmptyRM : public osmium::relations::RelationsManager<EmptyRM, true, true, true> {
 };
 
@@ -74,15 +76,15 @@ struct CallbackRM : public osmium::relations::RelationsManager<CallbackRM, true,
 
     std::size_t count_nodes = 0;
 
-    bool new_relation(const osmium::Relation& /*relation*/) noexcept {
+    static bool new_relation(const osmium::Relation& /*relation*/) noexcept {
         return true;
     }
 
-    bool new_member(const osmium::Relation& /*relation*/, const osmium::RelationMember& member, std::size_t /*n*/) noexcept {
+    static bool new_member(const osmium::Relation& /*relation*/, const osmium::RelationMember& member, std::size_t /*n*/) noexcept {
         return member.type() == osmium::item_type::node;
     }
 
-    void complete_relation(const osmium::Relation& relation) noexcept {
+    void complete_relation(const osmium::Relation& relation) {
         for (const auto& member : relation.members()) {
             if (member.type() == osmium::item_type::node) {
                 ++count_nodes;
@@ -96,6 +98,16 @@ struct CallbackRM : public osmium::relations::RelationsManager<CallbackRM, true,
 
 };
 
+struct AnyRM : public osmium::relations::RelationsManager<AnyRM, true, true, true> {
+    static bool new_relation(const osmium::Relation& /*relation*/) noexcept {
+        return true;
+    }
+
+    static bool new_member(const osmium::Relation& /*relation*/, const osmium::RelationMember& /*member*/, std::size_t /*n*/) noexcept {
+        return true;
+    }
+};
+
 TEST_CASE("Use RelationsManager without any overloaded functions in derived class") {
     osmium::io::File file{with_data_dir("t/relations/data.osm")};
 
@@ -134,7 +146,7 @@ TEST_CASE("Relations manager derived class") {
 
     bool callback_called = false;
     osmium::io::Reader reader{file};
-    osmium::apply(reader, manager.handler([&](osmium::memory::Buffer&&) {
+    osmium::apply(reader, manager.handler([&](osmium::memory::Buffer&& /*unused*/) {
         callback_called = true;
     }));
     reader.close();
@@ -247,3 +259,64 @@ TEST_CASE("Handle duplicate members correctly") {
     REQUIRE(manager.count_not_in_any    == 2); // 2 relations
 }
 
+TEST_CASE("Check handling of missing members") {
+    osmium::io::File file{with_data_dir("t/relations/missing_members.osm")};
+
+    AnyRM manager;
+
+    osmium::relations::read_relations(file, manager);
+
+    osmium::io::Reader reader{file};
+    osmium::apply(reader, manager.handler());
+    reader.close();
+
+
+    size_t nodes = 0;
+    size_t ways = 0;
+    size_t relations = 0;
+    size_t missing_nodes = 0;
+    size_t missing_ways = 0;
+    size_t missing_relations = 0;
+
+    manager.for_each_incomplete_relation([&](const osmium::relations::RelationHandle& handle){
+        if (handle->id() != 31) {
+            // count relation 31 only
+            return;
+        }
+        for (const auto& member : handle->members()) {
+            // RelationMember::ref() is supposed to returns 0 if we are interested in the member.
+            // RelationsManagerBase::get_member_object() is supposed to return a nullptr if the
+            // member is not available (missing in the input file).
+            const osmium::OSMObject* object = manager.get_member_object(member);
+            switch (member.type()) {
+            case osmium::item_type::node :
+                ++nodes;
+                if (member.ref() != 0 && !object) {
+                    ++missing_nodes;
+                }
+                break;
+            case osmium::item_type::way :
+                ++ways;
+                if (member.ref() != 0 && !object) {
+                    ++missing_ways;
+                }
+                break;
+            case osmium::item_type::relation :
+                ++relations;
+                if (member.ref() != 0 && !object) {
+                    ++missing_relations;
+                }
+                break;
+            default:
+                break;
+            }
+        }
+    });
+    REQUIRE(nodes == 2);
+    REQUIRE(ways == 3);
+    REQUIRE(relations == 3);
+    REQUIRE(missing_nodes == 1);
+    REQUIRE(missing_ways == 1);
+    REQUIRE(missing_relations == 2);
+}
+
diff --git a/third_party/libosmium/test/t/storage/test_item_stash.cpp b/third_party/libosmium/test/t/storage/test_item_stash.cpp
index c6fabf2fb..873a01e23 100644
--- a/third_party/libosmium/test/t/storage/test_item_stash.cpp
+++ b/third_party/libosmium/test/t/storage/test_item_stash.cpp
@@ -4,11 +4,13 @@
 #include <osmium/storage/item_stash.hpp>
 
 #include <sstream>
+#include <string>
+#include <vector>
 
 osmium::memory::Buffer generate_test_data() {
     using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
 
-    osmium::memory::Buffer buffer{1024 * 1024, osmium::memory::Buffer::auto_grow::yes};
+    osmium::memory::Buffer buffer{1024UL * 1024UL, osmium::memory::Buffer::auto_grow::yes};
 
     const osmium::object_id_type num_nodes     = 100;
     const osmium::object_id_type num_ways      =  50;
@@ -56,7 +58,7 @@ TEST_CASE("Item stash") {
     REQUIRE(stash.size() == 180);
     REQUIRE(stash.count_removed() == 0);
 
-    REQUIRE(stash.used_memory() > 1024 * 1024);
+    REQUIRE(stash.used_memory() > 1024UL * 1024UL);
 
     osmium::object_id_type id = 1;
     for (auto& handle : handles) { // must be reference because we will change it!
@@ -139,7 +141,7 @@ TEST_CASE("Fill item stash until it garbage collects") {
     const auto& node = buffer.get<osmium::Node>(0);
 
     std::vector<osmium::ItemStash::handle_type> handles;
-    std::size_t num_items = 6 * 1000 * 1000;
+    std::size_t num_items = 6UL * 1000UL * 1000UL;
     for (std::size_t i = 0; i < num_items; ++i) {
         auto handle = stash.add_item(node);
         handles.push_back(handle);
diff --git a/third_party/libosmium/test/t/tags/test_filter.cpp b/third_party/libosmium/test/t/tags/test_filter.cpp
index 0d0eddf50..c504bc459 100644
--- a/third_party/libosmium/test/t/tags/test_filter.cpp
+++ b/third_party/libosmium/test/t/tags/test_filter.cpp
@@ -8,6 +8,11 @@
 #include <osmium/tags/taglist.hpp>
 
 #include <algorithm>
+#include <initializer_list>
+#include <iterator>
+#include <regex>
+#include <utility>
+#include <vector>
 
 template <class TFilter>
 void check_filter(const osmium::TagList& tag_list,
@@ -183,39 +188,37 @@ TEST_CASE("KeyValueFilter") {
 
 }
 
-TEST_CASE("RegexFilter") {
+TEST_CASE("RegexFilter matches some tags") {
     osmium::memory::Buffer buffer{10240};
 
-    SECTION("RegexFilter matches some tags") {
-        osmium::tags::RegexFilter filter{false};
-        filter.add(true, "highway", std::regex{".*_link"});
+    osmium::tags::RegexFilter filter{false};
+    filter.add(true, "highway", std::regex{".*_link"});
 
-        const osmium::TagList& tag_list1 = make_tag_list(buffer, {
-            { "highway", "primary_link" },
-            { "source", "GPS" }
-        });
-        const osmium::TagList& tag_list2 = make_tag_list(buffer, {
-            { "highway", "primary" },
-            { "source", "GPS" }
-        });
+    const osmium::TagList& tag_list1 = make_tag_list(buffer, {
+        { "highway", "primary_link" },
+        { "source", "GPS" }
+    });
+    const osmium::TagList& tag_list2 = make_tag_list(buffer, {
+        { "highway", "primary" },
+        { "source", "GPS" }
+    });
 
-        check_filter(tag_list1, filter, {true, false});
-        check_filter(tag_list2, filter, {false, false});
-    }
+    check_filter(tag_list1, filter, {true, false});
+    check_filter(tag_list2, filter, {false, false});
+}
 
-    SECTION("RegexFilter matches some tags with lvalue regex") {
-        osmium::tags::RegexFilter filter{false};
-        std::regex r{".*straße"};
-        filter.add(true, "name", r);
+TEST_CASE("RegexFilter matches some tags with lvalue regex") {
+    osmium::memory::Buffer buffer{10240};
+    osmium::tags::RegexFilter filter{false};
+    std::regex r{".*straße"};
+    filter.add(true, "name", r);
 
-        const osmium::TagList& tag_list = make_tag_list(buffer, {
-            { "highway", "primary" },
-            { "name", "Hauptstraße" }
-        });
-
-        check_filter(tag_list, filter, {false, true});
-    }
+    const osmium::TagList& tag_list = make_tag_list(buffer, {
+        { "highway", "primary" },
+        { "name", "Hauptstraße" }
+    });
 
+    check_filter(tag_list, filter, {false, true});
 }
 
 TEST_CASE("KeyPrefixFilter matches some keys") {
diff --git a/third_party/libosmium/test/t/tags/test_tag_list.cpp b/third_party/libosmium/test/t/tags/test_tag_list.cpp
index e9612c9eb..9adbb5503 100644
--- a/third_party/libosmium/test/t/tags/test_tag_list.cpp
+++ b/third_party/libosmium/test/t/tags/test_tag_list.cpp
@@ -1,11 +1,12 @@
 #include "catch.hpp"
 
 #include <osmium/builder/attr.hpp>
-#include <osmium/builder/builder_helper.hpp>
 #include <osmium/memory/buffer.hpp>
 #include <osmium/osm/tag.hpp>
 
 #include <map>
+#include <string>
+#include <utility>
 #include <vector>
 
 using namespace osmium::builder::attr; // NOLINT(google-build-using-namespace)
@@ -153,7 +154,7 @@ TEST_CASE("create tag list") {
     }
 
     SECTION("with add_tag_list from map") {
-        std::map<const char*, const char*> m{
+        std::map<std::string, std::string> m{
             { "highway", "primary" },
             { "name", "Main Street" }
         };
diff --git a/third_party/libosmium/test/t/tags/test_tag_matcher.cpp b/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
index a1f6b7c27..4adf3a03f 100644
--- a/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
+++ b/third_party/libosmium/test/t/tags/test_tag_matcher.cpp
@@ -4,7 +4,10 @@
 #include <osmium/memory/buffer.hpp>
 #include <osmium/tags/matcher.hpp>
 
+#include <iterator>
+#include <string>
 #include <type_traits>
+#include <utility>
 
 static_assert(std::is_default_constructible<osmium::TagMatcher>::value, "TagMatcher should be default constructible");
 static_assert(std::is_copy_constructible<osmium::TagMatcher>::value, "TagMatcher should be copy constructible");
diff --git a/third_party/libosmium/test/t/tags/test_tags_filter.cpp b/third_party/libosmium/test/t/tags/test_tags_filter.cpp
index 1b8f36396..55d7e0721 100644
--- a/third_party/libosmium/test/t/tags/test_tags_filter.cpp
+++ b/third_party/libosmium/test/t/tags/test_tags_filter.cpp
@@ -5,6 +5,8 @@
 #include <osmium/tags/tags_filter.hpp>
 
 #include <functional>
+#include <iterator>
+#include <string>
 
 TEST_CASE("Tags filter") {
     osmium::memory::Buffer buffer{10240};
@@ -67,11 +69,104 @@ TEST_CASE("Tags filter") {
         REQUIRE(2 == std::distance(it, end));
 
         REQUIRE(it != end);
-        REQUIRE(std::string("highway") == it->key());
-        REQUIRE(std::string("primary") == it->value());
+        REQUIRE(std::string{"highway"} == it->key());
+        REQUIRE(std::string{"primary"} == it->value());
         ++it;
-        REQUIRE(std::string("source") == it->key());
-        REQUIRE(std::string("GPS") == it->value());
+        REQUIRE(std::string{"source"} == it->key());
+        REQUIRE(std::string{"GPS"} == it->value());
+        REQUIRE(++it == end);
+    }
+
+}
+
+struct result_type {
+
+    int v = 0;
+    bool b = false;
+
+    result_type() noexcept = default;
+
+    result_type(int v_, bool b_) noexcept :
+        v(v_),
+        b(b_) {
+    }
+
+    explicit operator bool() const noexcept {
+        return b;
+    }
+
+}; // struct result_type
+
+bool operator==(const result_type& lhs, const result_type& rhs) noexcept {
+    return lhs.v == rhs.v && lhs.b == rhs.b;
+}
+
+TEST_CASE("TagsFilterBase") {
+    osmium::memory::Buffer buffer{10240};
+
+    const auto pos1 = osmium::builder::add_tag_list(buffer,
+        osmium::builder::attr::_tags({
+            { "highway", "primary" },
+            { "name", "Main Street" },
+            { "source", "GPS" }
+    }));
+    const auto pos2 = osmium::builder::add_tag_list(buffer,
+        osmium::builder::attr::_tags({
+            { "amenity", "restaurant" },
+            { "name", "The Golden Goose" }
+    }));
+    const osmium::TagList& tag_list1 = buffer.get<osmium::TagList>(pos1);
+    const osmium::TagList& tag_list2 = buffer.get<osmium::TagList>(pos2);
+
+    SECTION("Filter based on key only: okay") {
+        osmium::TagsFilterBase<result_type> filter;
+        filter.add_rule(result_type{1, true}, osmium::TagMatcher{osmium::StringMatcher::equal{"highway"}});
+        filter.add_rule(result_type{2, true}, osmium::TagMatcher{osmium::StringMatcher::equal{"amenity"}});
+        REQUIRE(filter(*tag_list1.begin()) == result_type(1, true));
+        REQUIRE(filter(*tag_list2.begin()) == result_type(2, true));
+        REQUIRE(filter(*std::next(tag_list1.begin())) == result_type(0, false));
+        REQUIRE(filter(*std::next(tag_list2.begin())) == result_type(0, false));
+    }
+
+    SECTION("Filter based string: shortcut") {
+        osmium::TagsFilterBase<result_type> filter;
+        filter.add_rule({3, true}, "highway");
+        filter.add_rule({4, true}, "amenity", "restaurant");
+        REQUIRE(filter(*tag_list1.begin()) == result_type(3, true));
+        REQUIRE(filter(*tag_list2.begin()) == result_type(4, true));
+        REQUIRE(filter(*std::next(tag_list1.begin())) == result_type(0, false));
+        REQUIRE(filter(*std::next(tag_list2.begin())) == result_type(0, false));
+    }
+
+    SECTION("Filter based on key only: fail") {
+        osmium::TagsFilterBase<result_type> filter;
+        filter.add_rule({5, true}, osmium::StringMatcher::equal{"foo"});
+        filter.add_rule({6, true}, osmium::StringMatcher::equal{"bar"});
+        REQUIRE(filter(*tag_list1.begin()) == result_type(0, false));
+        REQUIRE(filter(*tag_list2.begin()) == result_type(0, false));
+        REQUIRE(filter(*std::next(tag_list1.begin())) == result_type(0, false));
+        REQUIRE(filter(*std::next(tag_list2.begin())) == result_type(0, false));
+    }
+
+    SECTION("KeyFilter iterator filters tags") {
+        osmium::TagsFilterBase<result_type> filter;
+        filter.add_rule({7, true}, osmium::StringMatcher::equal{"highway"})
+              .add_rule({8, true}, osmium::StringMatcher::equal{"source"});
+
+        using iterator = osmium::TagsFilterBase<result_type>::iterator;
+
+        iterator it{std::cref(filter), tag_list1.begin(), tag_list1.end()};
+
+        const iterator end{std::cref(filter), tag_list1.end(), tag_list1.end()};
+
+        REQUIRE(2 == std::distance(it, end));
+
+        REQUIRE(it != end);
+        REQUIRE(std::string{"highway"} == it->key());
+        REQUIRE(std::string{"primary"} == it->value());
+        ++it;
+        REQUIRE(std::string{"source"} == it->key());
+        REQUIRE(std::string{"GPS"} == it->value());
         REQUIRE(++it == end);
     }
 
diff --git a/third_party/libosmium/test/t/thread/test_pool.cpp b/third_party/libosmium/test/t/thread/test_pool.cpp
index e2b1075ee..94ed371b4 100644
--- a/third_party/libosmium/test/t/thread/test_pool.cpp
+++ b/third_party/libosmium/test/t/thread/test_pool.cpp
@@ -1,11 +1,8 @@
 #include "catch.hpp"
 
 #include <osmium/thread/pool.hpp>
-#include <osmium/util/compatibility.hpp>
 
-#include <chrono>
 #include <stdexcept>
-#include <thread>
 
 struct test_job_with_result {
     int operator()() const {
@@ -14,7 +11,7 @@ struct test_job_with_result {
 };
 
 struct test_job_throw {
-    OSMIUM_NORETURN void operator()() const {
+    [[noreturn]] void operator()() const {
         throw std::runtime_error{"exception in pool thread"};
     }
 };
@@ -68,51 +65,42 @@ TEST_CASE("if outlier positive number of threads requested, threads configured")
     REQUIRE(pool.num_threads() > 0);
 }
 
-TEST_CASE("thread") {
-
+TEST_CASE("can get access to default thread pool") {
     auto& pool = osmium::thread::Pool::default_instance();
-
-    SECTION("can get access to thread pool") {
-        REQUIRE(pool.queue_empty());
-    }
-
-    SECTION("can send job to thread pool") {
-        auto future = pool.submit(test_job_with_result{});
-
-        REQUIRE(future.get() == 42);
-    }
-
-    SECTION("can throw from job in thread pool") {
-        auto future = pool.submit(test_job_throw{});
-
-        REQUIRE_THROWS_AS(future.get(), const std::runtime_error&);
-    }
-
+    REQUIRE(pool.queue_empty());
 }
 
-TEST_CASE("thread (user-provided pool)") {
+TEST_CASE("can send job to default thread pool") {
+    auto& pool = osmium::thread::Pool::default_instance();
+    auto future = pool.submit(test_job_with_result{});
+    REQUIRE(future.get() == 42);
+}
 
+TEST_CASE("can throw from job in default thread pool") {
+    auto& pool = osmium::thread::Pool::default_instance();
+    auto future = pool.submit(test_job_throw{});
+    REQUIRE_THROWS_AS(future.get(), std::runtime_error);
+}
+
+TEST_CASE("can get access to user provided thread pool") {
     osmium::thread::Pool pool{7};
-
-    SECTION("can get access to thread pool") {
-        REQUIRE(pool.queue_empty());
-    }
-
-    SECTION("can access user-provided number of threads") {
-        REQUIRE(pool.num_threads() == 7);
-    }
-
-    SECTION("can send job to thread pool") {
-        auto future = pool.submit(test_job_with_result{});
-
-        REQUIRE(future.get() == 42);
-    }
-
-    SECTION("can throw from job in thread pool") {
-        auto future = pool.submit(test_job_throw{});
-
-        REQUIRE_THROWS_AS(future.get(), const std::runtime_error&);
-    }
-
+    REQUIRE(pool.queue_empty());
+}
+
+TEST_CASE("can access user-provided number of threads from pool") {
+    osmium::thread::Pool pool{7};
+    REQUIRE(pool.num_threads() == 7);
+}
+
+TEST_CASE("can send job to user provided thread pool") {
+    osmium::thread::Pool pool{7};
+    auto future = pool.submit(test_job_with_result{});
+    REQUIRE(future.get() == 42);
+}
+
+TEST_CASE("can throw from job in user provided thread pool") {
+    osmium::thread::Pool pool{7};
+    auto future = pool.submit(test_job_throw{});
+    REQUIRE_THROWS_AS(future.get(), std::runtime_error);
 }
 
diff --git a/third_party/libosmium/test/t/thread/test_queue.cpp b/third_party/libosmium/test/t/thread/test_queue.cpp
index 227642391..66df9c17a 100644
--- a/third_party/libosmium/test/t/thread/test_queue.cpp
+++ b/third_party/libosmium/test/t/thread/test_queue.cpp
@@ -18,3 +18,30 @@ TEST_CASE("Queue can have max elements and can be named") {
     osmium::thread::Queue<int> queue{100, "Queue of max size 100"};
 }
 
+TEST_CASE("When queue is shut down, nothing goes in or out") {
+    osmium::thread::Queue<std::string> queue;
+    REQUIRE(queue.in_use());
+    REQUIRE(queue.empty());
+    queue.push("foo");
+    queue.push("bar");
+    queue.push("baz");
+    REQUIRE(queue.size() == 3);
+
+    std::string value;
+
+    queue.wait_and_pop(value);
+    REQUIRE(value == "foo");
+    REQUIRE(queue.size() == 2);
+    REQUIRE(queue.in_use());
+    queue.shutdown();
+    REQUIRE_FALSE(queue.in_use());
+    REQUIRE(queue.empty());
+    queue.push("lost");
+    REQUIRE(queue.empty());
+
+    value.clear();
+    queue.try_pop(value);
+    REQUIRE(value.empty());
+    queue.wait_and_pop(value);
+    REQUIRE(value.empty());
+}
diff --git a/third_party/libosmium/test/t/thread/test_util.cpp b/third_party/libosmium/test/t/thread/test_util.cpp
index ecdd237ee..ad165e985 100644
--- a/third_party/libosmium/test/t/thread/test_util.cpp
+++ b/third_party/libosmium/test/t/thread/test_util.cpp
@@ -2,6 +2,7 @@
 
 #include <osmium/thread/util.hpp>
 
+#include <future>
 #include <stdexcept>
 #include <type_traits>
 
@@ -33,7 +34,7 @@ TEST_CASE("check_for_exception with exception") {
         p.set_exception(std::current_exception());
     }
 
-    REQUIRE_THROWS_AS(osmium::thread::check_for_exception(f), const std::runtime_error&);
+    REQUIRE_THROWS_AS(osmium::thread::check_for_exception(f), std::runtime_error);
 }
 
 static_assert(std::is_nothrow_move_constructible<osmium::thread::thread_handler>::value, "thread_handler must have noexcept move constructor");
@@ -42,7 +43,7 @@ TEST_CASE("empty thread_handler") {
     osmium::thread::thread_handler th;
 }
 
-int foo;
+int foo; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void test_func(int value) {
     foo = value;
diff --git a/third_party/libosmium/test/t/util/test_cast_with_assert.cpp b/third_party/libosmium/test/t/util/test_cast_with_assert.cpp
deleted file mode 100644
index e9aaef7c7..000000000
--- a/third_party/libosmium/test/t/util/test_cast_with_assert.cpp
+++ /dev/null
@@ -1,84 +0,0 @@
-#include "catch.hpp"
-
-// Define assert() to throw this error. This enables the tests to check that
-// the assert() fails.
-struct assert_error : public std::runtime_error {
-    explicit assert_error(const char* what_arg) : std::runtime_error(what_arg) {
-    }
-};
-#define assert(x) if (!(x)) { throw assert_error{#x}; }
-
-#include <osmium/util/cast.hpp>
-
-TEST_CASE("static_cast_with_assert: same types is always okay") {
-    const int f = 10;
-    const auto t = osmium::static_cast_with_assert<int>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: casting to larger type is always okay") {
-    const int16_t f = 10;
-    const auto t = osmium::static_cast_with_assert<int32_t>(f);
-    REQUIRE(t == f);
-}
-
-
-TEST_CASE("static_cast_with_assert: cast int32_t -> int16_t should not trigger assert for small int") {
-    const int32_t f = 100;
-    const auto t = osmium::static_cast_with_assert<int16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast int32_t -> int16_t should trigger assert for large int") {
-    const int32_t f = 100000;
-    REQUIRE_THROWS_AS(osmium::static_cast_with_assert<int16_t>(f), const assert_error&);
-}
-
-
-TEST_CASE("static_cast_with_assert: cast int16_t -> uint16_t should not trigger assert for zero") {
-    const int16_t f = 0;
-    const auto t = osmium::static_cast_with_assert<uint16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast int16_t -> uint16_t should not trigger assert for positive int") {
-    const int16_t f = 1;
-    const auto t = osmium::static_cast_with_assert<uint16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast int16_t -> uint16_t should trigger assert for negative int") {
-    const int16_t f = -1;
-    REQUIRE_THROWS_AS(osmium::static_cast_with_assert<uint16_t>(f), const assert_error&);
-}
-
-
-TEST_CASE("static_cast_with_assert: cast uint32_t -> uint16_t should not trigger assert for zero") {
-    const uint32_t f = 0;
-    const auto t = osmium::static_cast_with_assert<uint16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast uint32_t -> uint16_t should not trigger assert for small int") {
-    const uint32_t f = 100;
-    const auto t = osmium::static_cast_with_assert<uint16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast uint32_t -> uint16_t should trigger assert for large int") {
-    const uint32_t f = 100000;
-    REQUIRE_THROWS_AS(osmium::static_cast_with_assert<uint16_t>(f), const assert_error&);
-}
-
-
-TEST_CASE("static_cast_with_assert: cast uint16_t -> int16_t should not trigger assert for small int") {
-    const uint16_t f = 1;
-    const auto t = osmium::static_cast_with_assert<int16_t>(f);
-    REQUIRE(t == f);
-}
-
-TEST_CASE("static_cast_with_assert: cast uint16_t -> int16_t should trigger assert for large int") {
-    const uint16_t f = 65000;
-    REQUIRE_THROWS_AS(osmium::static_cast_with_assert<int16_t>(f), const assert_error&);
-}
-
diff --git a/third_party/libosmium/test/t/util/test_config.cpp b/third_party/libosmium/test/t/util/test_config.cpp
index a062f73c7..41d6e89b0 100644
--- a/third_party/libosmium/test/t/util/test_config.cpp
+++ b/third_party/libosmium/test/t/util/test_config.cpp
@@ -7,8 +7,9 @@ namespace osmium {
 
     namespace detail {
 
-        const char* env = nullptr;
-        std::string name;
+        static const char* env = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+        static std::string name; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
+
 
         inline const char* getenv_wrapper(const char* var) noexcept {
             name = var;
@@ -68,7 +69,7 @@ TEST_CASE("use_pool_threads_for_pbf_parsing") {
 
 TEST_CASE("get_max_queue_size") {
     osmium::detail::env = nullptr;
-    REQUIRE(osmium::config::get_max_queue_size("NAME", 0) == 0);
+    REQUIRE(osmium::config::get_max_queue_size("NAME", 0) == 2);
     REQUIRE(osmium::detail::name == "OSMIUM_MAX_NAME_QUEUE_SIZE");
 
     REQUIRE(osmium::config::get_max_queue_size("NAME", 7) == 7);
diff --git a/third_party/libosmium/test/t/util/test_delta.cpp b/third_party/libosmium/test/t/util/test_delta.cpp
index 88c52daf7..d50f3dec7 100644
--- a/third_party/libosmium/test/t/util/test_delta.cpp
+++ b/third_party/libosmium/test/t/util/test_delta.cpp
@@ -35,10 +35,14 @@ TEST_CASE("delta decode int") {
     osmium::DeltaDecode<int> x;
 
     REQUIRE(x.update(17) == 17);
+    REQUIRE(x.value() == 17);
     REQUIRE(x.update(10) == 27);
+    REQUIRE(x.value() == 27);
     REQUIRE(x.update(-40) == -13);
+    REQUIRE(x.value() == -13);
     x.clear();
     REQUIRE(x.update(17) == 17);
+    REQUIRE(x.value() == 17);
 }
 
 TEST_CASE("delta decode int with int32") {
diff --git a/third_party/libosmium/test/t/util/test_double.cpp b/third_party/libosmium/test/t/util/test_double.cpp
index 87c78d016..d239684d9 100644
--- a/third_party/libosmium/test/t/util/test_double.cpp
+++ b/third_party/libosmium/test/t/util/test_double.cpp
@@ -2,6 +2,8 @@
 
 #include <osmium/util/double.hpp>
 
+#include <string>
+
 TEST_CASE("Check double2string function") {
     std::string s1;
     osmium::double2string(s1, 1.123, 7);
diff --git a/third_party/libosmium/test/t/util/test_file.cpp b/third_party/libosmium/test/t/util/test_file.cpp
index 71cc2f3c3..8a6f06a00 100644
--- a/third_party/libosmium/test/t/util/test_file.cpp
+++ b/third_party/libosmium/test/t/util/test_file.cpp
@@ -5,6 +5,9 @@
 #include <osmium/io/detail/read_write.hpp>
 #include <osmium/util/file.hpp>
 
+#include <stdexcept>
+#include <string>
+
 TEST_CASE("file_size(int) and file_offset() of known file") {
     std::string file_name{with_data_dir("t/util/known_file_size")};
     const int fd = osmium::io::detail::open_for_reading(file_name);
@@ -25,25 +28,25 @@ TEST_CASE("file_size(const char*) of known file") {
 }
 
 TEST_CASE("file_size() with illegal fd should throw") {
-    REQUIRE_THROWS_AS(osmium::file_size(-1), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size(-1), std::system_error);
 }
 
 TEST_CASE("file_size() with unused fd should throw") {
     // its unlikely that fd 1000 is open...
-    REQUIRE_THROWS_AS(osmium::file_size(1000), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size(1000), std::system_error);
 }
 
 TEST_CASE("file_size() of unknown file should throw") {
-    REQUIRE_THROWS_AS(osmium::file_size("unknown file"), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::file_size("unknown file"), std::system_error);
 }
 
 TEST_CASE("resize_file() with illegal fd should throw") {
-    REQUIRE_THROWS_AS(osmium::resize_file(-1, 10), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::resize_file(-1, 10), std::system_error);
 }
 
 TEST_CASE("resize_file() with unused fd should throw") {
     // its unlikely that fd 1000 is open...
-    REQUIRE_THROWS_AS(osmium::resize_file(1000, 10), const std::system_error&);
+    REQUIRE_THROWS_AS(osmium::resize_file(1000, 10), std::system_error);
 }
 
 TEST_CASE("get_pagesize()") {
diff --git a/third_party/libosmium/test/t/util/test_memory.cpp b/third_party/libosmium/test/t/util/test_memory.cpp
index fe3a309b8..736bbce44 100644
--- a/third_party/libosmium/test/t/util/test_memory.cpp
+++ b/third_party/libosmium/test/t/util/test_memory.cpp
@@ -2,31 +2,13 @@
 
 #include <osmium/util/memory.hpp>
 
+#include <vector>
+
 TEST_CASE("Check memory usage") {
 #ifdef __linux__
-    const int size_in_mbytes = 10;
-
     osmium::MemoryUsage m1;
     REQUIRE(m1.current() > 1);
     REQUIRE(m1.peak() > 1);
-
-// Memory reporting on M68k architecture doesn't work properly.
-# ifndef __m68k__
-    {
-        std::vector<int> v;
-        v.reserve(size_in_mbytes * 1024 * 1024);
-
-        osmium::MemoryUsage m2;
-        REQUIRE(m2.current() >= m1.current() + size_in_mbytes);
-        REQUIRE(m2.peak() >= m1.peak() + size_in_mbytes);
-        REQUIRE(m2.peak() - m2.current() <= 1);
-    }
-
-    osmium::MemoryUsage m3;
-    REQUIRE(m3.current() > 1);
-    REQUIRE(m3.current() <= m3.peak());
-    REQUIRE(m3.peak() >= m1.peak() + size_in_mbytes);
-# endif
 #else
     osmium::MemoryUsage m;
     REQUIRE(m.current() == 0);
diff --git a/third_party/libosmium/test/t/util/test_memory_mapping.cpp b/third_party/libosmium/test/t/util/test_memory_mapping.cpp
index 52e95a1db..4adfba5be 100644
--- a/third_party/libosmium/test/t/util/test_memory_mapping.cpp
+++ b/third_party/libosmium/test/t/util/test_memory_mapping.cpp
@@ -11,8 +11,6 @@
 #include "win_mkstemp.hpp"
 #endif
 
-static const size_t huge = std::numeric_limits<size_t>::max();
-
 TEST_CASE("Anonymous mapping: simple memory mapping should work") {
     osmium::MemoryMapping mapping{1000, osmium::MemoryMapping::mapping_mode::write_private};
     REQUIRE(mapping.get_addr() != nullptr);
@@ -46,7 +44,7 @@ TEST_CASE("Anonymous mapping: moving a memory mapping should work") {
     osmium::MemoryMapping mapping2{std::move(mapping1)};
     REQUIRE(!!mapping2);
     REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
-    mapping1.unmap();
+    mapping1.unmap(); // NOLINT(clang-analyzer-cplusplus.Move) okay here, we are checking our own code
 
     const auto* addr2 = mapping2.get_addr<int>();
     REQUIRE(*addr2 == 42);
@@ -67,6 +65,7 @@ TEST_CASE("Anonymous mapping: move assignment should work") {
 
     mapping2 = std::move(mapping1);
     REQUIRE(!!mapping2);
+    // cppcheck-suppress accessMoved
     REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
 
     const auto* addr2 = mapping2.get_addr<int>();
@@ -271,9 +270,9 @@ TEST_CASE("Typed anonymous mapping: moving a memory mapping should work") {
     osmium::TypedMemoryMapping<uint32_t> mapping2{std::move(mapping1)};
     REQUIRE(!!mapping2);
     REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
-    mapping1.unmap();
+    mapping1.unmap(); // NOLINT(clang-analyzer-cplusplus.Move) okay here, we are checking our own code
 
-    const auto addr2 = mapping2.begin();
+    const auto* const addr2 = mapping2.begin();
     REQUIRE(*addr2 == 42);
 
     mapping2.unmap();
@@ -287,14 +286,15 @@ TEST_CASE("Typed anonymous mapping: move assignment should work") {
     REQUIRE(!!mapping1);
     REQUIRE(!!mapping2);
 
-    auto addr1 = mapping1.begin();
+    auto* const addr1 = mapping1.begin();
     *addr1 = 42;
 
     mapping2 = std::move(mapping1);
     REQUIRE(!!mapping2);
+    // cppcheck-suppress accessMoved
     REQUIRE(!mapping1); // NOLINT(bugprone-use-after-move,misc-use-after-move) okay here, we are checking our own code
 
-    const auto addr2 = mapping2.begin();
+    const auto* const addr2 = mapping2.begin();
     REQUIRE(*addr2 == 42);
 
     mapping2.unmap();
@@ -306,12 +306,12 @@ TEST_CASE("Typed anonymous mapping: remapping to larger size should work") {
     osmium::TypedMemoryMapping<uint32_t> mapping{1000};
     REQUIRE(mapping.size() >= 1000);
 
-    auto addr1 = mapping.begin();
+    auto* const addr1 = mapping.begin();
     *addr1 = 42;
 
     mapping.resize(8000);
 
-    const auto addr2 = mapping.begin();
+    const auto* const addr2 = mapping.begin();
     REQUIRE(*addr2 == 42);
 }
 
@@ -319,12 +319,12 @@ TEST_CASE("Typed anonymous mapping: remapping to smaller size should work") {
     osmium::TypedMemoryMapping<uint32_t> mapping{8000};
     REQUIRE(mapping.size() >= 8000);
 
-    auto addr1 = mapping.begin();
+    auto* const addr1 = mapping.begin();
     *addr1 = 42;
 
     mapping.resize(500);
 
-    const auto addr2 = mapping.begin();
+    const auto* const addr2 = mapping.begin();
     REQUIRE(*addr2 == 42);
 }
 #endif
diff --git a/third_party/libosmium/test/t/util/test_minmax.cpp b/third_party/libosmium/test/t/util/test_minmax.cpp
index f9ca637de..f5f963a94 100644
--- a/third_party/libosmium/test/t/util/test_minmax.cpp
+++ b/third_party/libosmium/test/t/util/test_minmax.cpp
@@ -3,6 +3,8 @@
 #include <osmium/osm/timestamp.hpp>
 #include <osmium/util/minmax.hpp>
 
+#include <limits>
+
 TEST_CASE("min_op numeric") {
     osmium::min_op<int> x;
     REQUIRE(x() == std::numeric_limits<int>::max());
diff --git a/third_party/libosmium/test/t/util/test_misc.cpp b/third_party/libosmium/test/t/util/test_misc.cpp
index ef5be02d4..695684103 100644
--- a/third_party/libosmium/test/t/util/test_misc.cpp
+++ b/third_party/libosmium/test/t/util/test_misc.cpp
@@ -46,22 +46,22 @@ TEST_CASE("string to integer conversion") {
     REQUIRE(osmium::detail::str_to_int<uint16_t>("65536") == 0);
 
     test_conv<int32_t>();
-    REQUIRE(osmium::detail::str_to_int<int32_t>("2147483646") == 2147483646ll);
+    REQUIRE(osmium::detail::str_to_int<int32_t>("2147483646") == 2147483646LL);
     REQUIRE(osmium::detail::str_to_int<int32_t>("2147483647") == 0);
     REQUIRE(osmium::detail::str_to_int<int32_t>("2147483648") == 0);
 
     test_conv<uint32_t>();
-    REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967294") == 4294967294ull);
+    REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967294") == 4294967294ULL);
     REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967295") == 0);
     REQUIRE(osmium::detail::str_to_int<uint32_t>("4294967296") == 0);
 
     test_conv<int64_t>();
-    REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775806") == 9223372036854775806ll);
+    REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775806") == 9223372036854775806LL);
     REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775807") == 0);
     REQUIRE(osmium::detail::str_to_int<int64_t>("9223372036854775808") == 0);
 
     test_conv<uint64_t>();
-    REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775806") == 9223372036854775806ull);
+    REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775806") == 9223372036854775806ULL);
     REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775807") == 0);
     REQUIRE(osmium::detail::str_to_int<uint64_t>("9223372036854775808") == 0);
 }
diff --git a/third_party/libosmium/test/t/util/test_options.cpp b/third_party/libosmium/test/t/util/test_options.cpp
index 30772692a..a2f668f70 100644
--- a/third_party/libosmium/test/t/util/test_options.cpp
+++ b/third_party/libosmium/test/t/util/test_options.cpp
@@ -5,6 +5,8 @@
 TEST_CASE("Set a single option value from string") {
     osmium::Options o;
 
+    REQUIRE(o.empty());
+
     o.set("foo", "bar");
     REQUIRE("bar" == o.get("foo"));
     REQUIRE(o.get("empty").empty());
@@ -17,6 +19,7 @@ TEST_CASE("Set a single option value from string") {
     REQUIRE(o.is_not_false("empty"));
 
     REQUIRE(1 == o.size());
+    REQUIRE_FALSE(o.empty());
 }
 
 TEST_CASE("Set option values from booleans") {
diff --git a/third_party/libosmium/test/t/util/test_string.cpp b/third_party/libosmium/test/t/util/test_string.cpp
index a0aa76e50..4c4afa527 100644
--- a/third_party/libosmium/test/t/util/test_string.cpp
+++ b/third_party/libosmium/test/t/util/test_string.cpp
@@ -2,6 +2,9 @@
 
 #include <osmium/util/string.hpp>
 
+#include <string>
+#include <vector>
+
 TEST_CASE("split_string string") {
     const std::string str{"foo,baramba,baz"};
     const std::vector<std::string> result = {"foo", "baramba", "baz"};
diff --git a/third_party/libosmium/test/t/util/test_string_matcher.cpp b/third_party/libosmium/test/t/util/test_string_matcher.cpp
index 2e2e3056a..2debd9f24 100644
--- a/third_party/libosmium/test/t/util/test_string_matcher.cpp
+++ b/third_party/libosmium/test/t/util/test_string_matcher.cpp
@@ -3,7 +3,13 @@
 #include <osmium/util/string_matcher.hpp>
 
 #include <sstream>
+#include <string>
 #include <type_traits>
+#include <vector>
+
+#ifdef OSMIUM_WITH_REGEX
+#include <regex>
+#endif
 
 static_assert(std::is_default_constructible<osmium::StringMatcher>::value, "StringMatcher should be default constructible");
 static_assert(std::is_copy_constructible<osmium::StringMatcher>::value, "StringMatcher should be copy constructible");
diff --git a/third_party/sol2-3.3.0/include/sol/config.hpp b/third_party/sol2-3.3.0/include/sol/config.hpp
new file mode 100644
index 000000000..3b7ef023f
--- /dev/null
+++ b/third_party/sol2-3.3.0/include/sol/config.hpp
@@ -0,0 +1,53 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.336233 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_CONFIG_HPP
+#define SOL_SINGLE_CONFIG_HPP
+
+// beginning of sol/config.hpp
+
+/* Base, empty configuration file!
+
+     To override, place a file in your include paths of the form:
+
+. (your include path here)
+| sol (directory, or equivalent)
+  | config.hpp (your config.hpp file)
+
+     So that when sol2 includes the file
+
+#include <sol/config.hpp>
+
+     it gives you the configuration values you desire. Configuration values can be
+seen in the safety.rst of the doc/src, or at
+https://sol2.readthedocs.io/en/latest/safety.html ! You can also pass them through
+the build system, or the command line options of your compiler.
+
+*/
+
+// end of sol/config.hpp
+
+#endif // SOL_SINGLE_CONFIG_HPP
diff --git a/third_party/sol2-3.3.0/include/sol/forward.hpp b/third_party/sol2-3.3.0/include/sol/forward.hpp
new file mode 100644
index 000000000..869069087
--- /dev/null
+++ b/third_party/sol2-3.3.0/include/sol/forward.hpp
@@ -0,0 +1,1321 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.328625 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_FORWARD_HPP
+#define SOL_SINGLE_INCLUDE_FORWARD_HPP
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+#endif // SOL_SINGLE_INCLUDE_FORWARD_HPP
diff --git a/third_party/sol2-3.3.0/include/sol/sol.hpp b/third_party/sol2-3.3.0/include/sol/sol.hpp
new file mode 100644
index 000000000..8b0b7d36e
--- /dev/null
+++ b/third_party/sol2-3.3.0/include/sol/sol.hpp
@@ -0,0 +1,28907 @@
+// The MIT License (MIT)
+
+// Copyright (c) 2013-2020 Rapptz, ThePhD and contributors
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy of
+// this software and associated documentation files (the "Software"), to deal in
+// the Software without restriction, including without limitation the rights to
+// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+// the Software, and to permit persons to whom the Software is furnished to do so,
+// subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// This file was generated with a script.
+// Generated 2022-06-25 08:14:19.151876 UTC
+// This header was generated with sol v3.3.0 (revision eba86625)
+// https://github.com/ThePhD/sol2
+
+#ifndef SOL_SINGLE_INCLUDE_HPP
+#define SOL_SINGLE_INCLUDE_HPP
+
+// beginning of sol/sol.hpp
+
+#ifndef SOL_HPP
+#define SOL_HPP
+
+// beginning of sol/version.hpp
+
+#include <sol/config.hpp>
+
+#define SOL_VERSION_MAJOR 3
+#define SOL_VERSION_MINOR 2
+#define SOL_VERSION_PATCH 3
+#define SOL_VERSION_STRING "3.2.3"
+#define SOL_VERSION ((SOL_VERSION_MAJOR * 100000) + (SOL_VERSION_MINOR * 100) + (SOL_VERSION_PATCH))
+
+#define SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN) #_TOKEN
+#define SOL_TOKEN_TO_STRING_I_(_TOKEN) SOL_TOKEN_TO_STRING_POST_EXPANSION_I_(_TOKEN)
+
+#define SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT) _LEFT##_RIGHT
+#define SOL_CONCAT_TOKENS_I_(_LEFT, _RIGHT) SOL_CONCAT_TOKENS_POST_EXPANSION_I_(_LEFT, _RIGHT)
+
+#define SOL_RAW_IS_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) != 0)
+#define SOL_RAW_IS_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3) == 0)
+#define SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL) ((3 OP_SYMBOL 3) > 3)
+#define SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL) ((3 OP_SYMBOL 3 OP_SYMBOL 3) < 0)
+
+#define SOL_IS_ON(OP_SYMBOL) SOL_RAW_IS_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_OFF(OP_SYMBOL) SOL_RAW_IS_OFF(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_ON(OP_SYMBOL) SOL_RAW_IS_DEFAULT_ON(OP_SYMBOL ## _I_)
+#define SOL_IS_DEFAULT_OFF(OP_SYMBOL) SOL_RAW_IS_DEFAULT_OFF(OP_SYMBOL ## _I_)
+
+#define SOL_ON          |
+#define SOL_OFF         ^
+#define SOL_DEFAULT_ON  +
+#define SOL_DEFAULT_OFF -
+
+#if defined(SOL_BUILD_CXX_MODE)
+	#if (SOL_BUILD_CXX_MODE != 0)
+		#define SOL_BUILD_CXX_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_CXX_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__cplusplus)
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_CXX_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_BUILD_C_MODE)
+	#if (SOL_BUILD_C_MODE != 0)
+		#define SOL_BUILD_C_MODE_I_ SOL_ON
+	#else
+		#define SOL_BUILD_C_MODE_I_ SOL_OFF
+	#endif
+#elif defined(__STDC__)
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_BUILD_C_MODE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_C_MODE)
+	#include <stddef.h>
+	#include <stdint.h>
+	#include <limits.h>
+#else
+	#include <cstddef>
+	#include <cstdint>
+	#include <climits>
+#endif
+
+#if defined(SOL_COMPILER_VCXX)
+	#if defined(SOL_COMPILER_VCXX != 0)
+		#define SOL_COMPILER_VCXX_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_VCXX_I_ SOL_OFF
+	#endif
+#elif defined(_MSC_VER)
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_VCXX_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_GCC)
+	#if defined(SOL_COMPILER_GCC != 0)
+		#define SOL_COMPILER_GCC_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_GCC_I_ SOL_OFF
+	#endif
+#elif defined(__GNUC__)
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_GCC_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_CLANG)
+	#if defined(SOL_COMPILER_CLANG != 0)
+		#define SOL_COMPILER_CLANG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_CLANG_I_ SOL_OFF
+	#endif
+#elif defined(__clang__)
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_CLANG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_EDG)
+	#if defined(SOL_COMPILER_EDG != 0)
+		#define SOL_COMPILER_EDG_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_EDG_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_COMPILER_EDG_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_COMPILER_MINGW)
+	#if (SOL_COMPILER_MINGW != 0)
+		#define SOL_COMPILER_MINGW_I_ SOL_ON
+	#else
+		#define SOL_COMPILER_MINGW_I_ SOL_OFF
+	#endif
+#elif defined(__MINGW32__)
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_COMPILER_MINGW_I_ SOL_DEFAULT_OFF
+#endif
+
+#if SIZE_MAX <= 0xFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_ON
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#elif SIZE_MAX <= 0xFFFFFFFFULL
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_ON
+	#define SOL_PLATFORM_X64_I_ SOL_OFF
+#else
+	#define SOL_PLATFORM_X16_I_ SOL_OFF
+	#define SOL_PLATFORM_X86_I_ SOL_OFF
+	#define SOL_PLATFORM_X64_I_ SOL_ON
+#endif
+
+#define SOL_PLATFORM_ARM32_I_ SOL_OFF
+#define SOL_PLATFORM_ARM64_I_ SOL_OFF
+
+#if defined(SOL_PLATFORM_WINDOWS)
+	#if (SOL_PLATFORM_WINDOWS != 0)
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_WINDOWS_I_ SOL_OFF
+	#endif
+#elif defined(_WIN32)
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_WINDOWS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_CYGWIN)
+	#if (SOL_PLATFORM_CYGWIN != 0)
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_CYGWIN_I_ SOL_ON
+	#endif
+#elif defined(__CYGWIN__)
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_CYGWIN_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_APPLE)
+	#if (SOL_PLATFORM_APPLE != 0)
+		#define SOL_PLATFORM_APPLE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_APPLE_I_ SOL_OFF
+	#endif
+#elif defined(__APPLE__)
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_PLATFORM_APPLE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_UNIX)
+	#if (SOL_PLATFORM_UNIX != 0)
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_UNIXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__unix__)
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_UNIXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_PLATFORM_LINUX)
+	#if (SOL_PLATFORM_LINUX != 0)
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_ON
+	#else
+		#define SOL_PLATFORM_LINUXLIKE_I_ SOL_OFF
+	#endif
+#elif defined(__LINUX__)
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAUKT_ON
+#else
+	#define SOL_PLATFORM_LINUXLIKE_I_ SOL_DEFAULT_OFF
+#endif
+
+#define SOL_PLATFORM_APPLE_IPHONE_I_ SOL_OFF
+#define SOL_PLATFORM_BSDLIKE_I_      SOL_OFF
+
+#if defined(SOL_IN_DEBUG_DETECTED)
+	#if SOL_IN_DEBUG_DETECTED != 0
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#elif !defined(NDEBUG)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX) && defined(_DEBUG)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#elif (SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)) && !defined(__OPTIMIZE__)
+		#define SOL_DEBUG_BUILD_I_ SOL_ON
+	#else
+		#define SOL_DEBUG_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEBUG_BUILD_I_ SOL_DEFAULT_OFF
+#endif // We are in a debug mode of some sort
+
+#if defined(SOL_NO_EXCEPTIONS)
+	#if (SOL_NO_EXCEPTIONS != 0)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPUNWIND)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__EXCEPTIONS)
+		#define SOL_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_EXCEPTIONS_I_ SOL_ON
+	#endif
+#else
+	#define SOL_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_RTTI)
+	#if (SOL_NO_RTTI != 0)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	#if !defined(_CPPRTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG) || SOL_IS_ON(SOL_COMPILER_GCC)
+	#if !defined(__GXX_RTTI)
+		#define SOL_RTTI_I_ SOL_OFF
+	#else
+		#define SOL_RTTI_I_ SOL_ON
+	#endif
+#else
+	#define SOL_RTTI_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_NO_THREAD_LOCAL)
+	#if SOL_NO_THREAD_LOCAL != 0
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_OFF
+	#else
+		#define SOL_USE_THREAD_LOCAL_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_THREAD_LOCAL_I_ SOL_DEFAULT_ON
+#endif // thread_local keyword is bjorked on some platforms
+
+#if defined(SOL_ALL_SAFETIES_ON)
+	#if SOL_ALL_SAFETIES_ON != 0
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_ON
+	#else
+		#define SOL_ALL_SAFETIES_ON_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_ALL_SAFETIES_ON_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_GETTER)
+	#if SOL_SAFE_GETTER != 0
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_GETTER_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_GETTER_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_USERTYPE)
+	#if SOL_SAFE_USERTYPE != 0
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_USERTYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_USERTYPE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_REFERENCES)
+	#if SOL_SAFE_REFERENCES != 0
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_REFERENCES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_REFERENCES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTIONS)
+	#if SOL_SAFE_FUNCTIONS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#elif defined (SOL_SAFE_FUNCTION_OBJECTS)
+	#if SOL_SAFE_FUNCTION_OBJECTS != 0
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_OBJECTS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_FUNCTION_CALLS)
+	#if SOL_SAFE_FUNCTION_CALLS != 0
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_FUNCTION_CALLS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_PROXIES)
+	#if SOL_SAFE_PROXIES != 0
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_PROXIES_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_PROXIES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_SAFE_NUMERICS)
+	#if SOL_SAFE_NUMERICS != 0
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_NUMERICS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_NUMERICS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_ALL_INTEGER_VALUES_FIT)
+	#if (SOL_ALL_INTEGER_VALUES_FIT != 0)
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_ON
+	#else
+		#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_OFF
+	#endif
+#elif !SOL_IS_DEFAULT_OFF(SOL_SAFE_NUMERICS) && SOL_IS_OFF(SOL_SAFE_NUMERICS)
+	// if numerics is intentionally turned off, flip this on
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_ON
+#else
+	// default to off
+	#define SOL_ALL_INTEGER_VALUES_FIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_SAFE_STACK_CHECK)
+	#if SOL_SAFE_STACK_CHECK != 0
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_SAFE_STACK_CHECK_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_CHECK_NUMBER_PRECISION)
+	#if SOL_NO_CHECK_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#elif defined(SOL_NO_CHECKING_NUMBER_PRECISION)
+	#if SOL_NO_CHECKING_NUMBER_PRECISION != 0
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_OFF
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_SAFE_NUMERICS)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_NUMBER_PRECISION_CHECKS_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_STRINGS_ARE_NUMBERS)
+	#if (SOL_STRINGS_ARE_NUMBERS != 0)
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_ON
+	#else
+		#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_STRINGS_ARE_NUMBERS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_ENABLE_INTEROP)
+	#if SOL_ENABLE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_INTEROP)
+	#if SOL_USE_INTEROP != 0
+		#define SOL_USE_INTEROP_I_ SOL_ON
+	#else
+		#define SOL_USE_INTEROP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_INTEROP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_NIL)
+	#if (SOL_NO_NIL != 0)
+		#define SOL_NIL_I_ SOL_OFF
+	#else
+		#define SOL_NIL_I_ SOL_ON
+	#endif
+#elif defined(__MAC_OS_X_VERSION_MAX_ALLOWED) || defined(__OBJC__) || defined(nil)
+	#define SOL_NIL_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_NIL_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USERTYPE_TYPE_BINDING_INFO)
+	#if (SOL_USERTYPE_TYPE_BINDING_INFO != 0)
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_ON
+	#else
+		#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USERTYPE_TYPE_BINDING_INFO_I_ SOL_DEFAULT_ON
+#endif // We should generate a my_type.__type table with lots of class information for usertypes
+
+#if defined(SOL_AUTOMAGICAL_TYPES_BY_DEFAULT)
+	#if (SOL_AUTOMAGICAL_TYPES_BY_DEFAULT != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#elif defined(SOL_DEFAULT_AUTOMAGICAL_USERTYPES)
+	#if (SOL_DEFAULT_AUTOMAGICAL_USERTYPES != 0)
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_AUTOMAGICAL_USERTYPES_I_ SOL_DEFAULT_ON
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_STD_VARIANT)
+	#if (SOL_STD_VARIANT != 0)
+		#define SOL_STD_VARIANT_I_ SOL_ON
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_COMPILER_CLANG) && SOL_IS_ON(SOL_PLATFORM_APPLE)
+		#if defined(__has_include)
+			#if __has_include(<variant>)
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+			#else
+				#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+			#endif
+		#else
+			#define SOL_STD_VARIANT_I_ SOL_DEFAULT_OFF
+		#endif
+	#else
+		#define SOL_STD_VARIANT_I_ SOL_DEFAULT_ON
+	#endif
+#endif // make is_automagical on/off by default
+
+#if defined(SOL_NOEXCEPT_FUNCTION_TYPE)
+	#if (SOL_NOEXCEPT_FUNCTION_TYPE != 0)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_noexcept_function_type)
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(_MSVC_LANG) && (_MSVC_LANG < 201403L))
+		// There is a bug in the VC++ compiler??
+		// on /std:c++latest under x86 conditions (VS 15.5.2),
+		// compiler errors are tossed for noexcept markings being on function types
+		// that are identical in every other way to their non-noexcept marked types function types...
+		// VS 2019: There is absolutely a bug.
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_OFF
+	#else
+		#define SOL_USE_NOEXCEPT_FUNCTION_TYPE_I_ SOL_DEFAULT_ON
+	#endif
+#endif // noexcept is part of a function's type
+
+#if defined(SOL_STACK_STRING_OPTIMIZATION_SIZE) && SOL_STACK_STRING_OPTIMIZATION_SIZE > 0
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ SOL_STACK_STRING_OPTIMIZATION_SIZE
+#else
+	#define SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_ 1024
+#endif
+
+#if defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_ID_SIZE_I_ SOL_ID_SIZE
+#else
+	#define SOL_ID_SIZE_I_ 512
+#endif
+
+#if defined(LUA_IDSIZE) && LUA_IDSIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ LUA_IDSIZE
+#elif defined(SOL_ID_SIZE) && SOL_ID_SIZE > 0
+	#define SOL_FILE_ID_SIZE_I_ SOL_FILE_ID_SIZE
+#else
+	#define SOL_FILE_ID_SIZE_I_ 2048
+#endif
+
+#if defined(SOL_PRINT_ERRORS)
+	#if (SOL_PRINT_ERRORS != 0)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_ALL_SAFETIES_ON)
+		#define SOL_PRINT_ERRORS_I_ SOL_ON
+	#elif SOL_IS_ON(SOL_DEBUG_BUILD)
+		#define SOL_PRINT_ERRORS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PRINT_ERRORS_I_ SOL_OFF
+	#endif
+#endif
+
+#if defined(SOL_DEFAULT_PASS_ON_ERROR)
+	#if (SOL_DEFAULT_PASS_ON_ERROR != 0)
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_ON
+	#else
+		#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_DEFAULT_PASS_ON_ERROR_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUA)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUA)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUA_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUA_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUA_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USING_CXX_LUAJIT)
+	#if (SOL_USING_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(SOL_USE_CXX_LUAJIT)
+	#if (SOL_USE_CXX_LUA != 0)
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_CXX_LUAJIT_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_CXX_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_NO_LUA_HPP)
+	#if (SOL_NO_LUA_HPP != 0)
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#endif
+#elif defined(SOL_USING_CXX_LUA)
+	#define SOL_USE_LUA_HPP_I_ SOL_OFF
+#elif defined(__has_include)
+	#if __has_include(<lua.hpp>)
+		#define SOL_USE_LUA_HPP_I_ SOL_ON
+	#else
+		#define SOL_USE_LUA_HPP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_LUA_HPP_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_CONTAINERS_START)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START
+#elif defined(SOL_CONTAINERS_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINERS_START_INDEX
+#elif defined(SOL_CONTAINER_START_INDEX)
+	#define SOL_CONTAINER_START_INDEX_I_ SOL_CONTAINER_START_INDEX
+#else
+	#define SOL_CONTAINER_START_INDEX_I_ 1
+#endif
+
+#if defined (SOL_NO_MEMORY_ALIGNMENT)
+	#if (SOL_NO_MEMORY_ALIGNMENT != 0)
+		#define SOL_ALIGN_MEMORY_I_ SOL_OFF
+	#else
+		#define SOL_ALIGN_MEMORY_I_ SOL_ON
+	#endif
+#else
+	#define SOL_ALIGN_MEMORY_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_USE_BOOST)
+	#if (SOL_USE_BOOST != 0)
+		#define SOL_USE_BOOST_I_ SOL_ON
+	#else
+		#define SOL_USE_BOOST_I_ SOL_OFF
+	#endif
+#else
+		#define SOL_USE_BOOST_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_USE_UNSAFE_BASE_LOOKUP)
+	#if (SOL_USE_UNSAFE_BASE_LOOKUP != 0)
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_ON
+	#else
+		#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_USE_UNSAFE_BASE_LOOKUP_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_INSIDE_UNREAL)
+	#if (SOL_INSIDE_UNREAL != 0)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_OFF
+	#endif
+#else
+	#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_INSIDE_UNREAL_ENGINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_NO_COMPAT)
+	#if (SOL_NO_COMPAT != 0)
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_OFF
+	#else
+		#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_ON
+	#endif
+#else
+	#define SOL_USE_COMPATIBILITY_LAYER_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_GET_FUNCTION_POINTER_UNSAFE)
+	#if (SOL_GET_FUNCTION_POINTER_UNSAFE != 0)
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_ON
+	#else
+		#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_GET_FUNCTION_POINTER_UNSAFE_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	#if (SOL_FUNCTION_CALL_VALUE_SEMANTICS != 0)
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_ON
+	#else
+		#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_FUNCTION_CALL_VALUE_SEMANTICS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_MINGW_CCTYPE_IS_POISONED)
+	#if (SOL_MINGW_CCTYPE_IS_POISONED != 0)
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_ON
+	#else
+		#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_MINGW) && defined(__GNUC__) && (__GNUC__ < 6)
+	// MinGW is off its rocker in some places...
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_MINGW_CCTYPE_IS_POISONED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_CHAR8_T)
+	#if (SOL_CHAR8_T != 0)
+		#define SOL_CHAR8_T_I_ SOL_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_OFF
+	#endif
+#else
+	#if defined(__cpp_char8_t)
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_CHAR8_T_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	#include <boost/version.hpp>
+
+	#if BOOST_VERSION >= 107500 // Since Boost 1.75.0 boost::none is constexpr
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+	#else
+		#define SOL_BOOST_NONE_CONSTEXPR_I_ const
+	#endif // BOOST_VERSION
+#else
+	// assume boost isn't using a garbage version
+	#define SOL_BOOST_NONE_CONSTEXPR_I_ constexpr
+#endif
+
+#if defined(SOL2_CI)
+	#if (SOL2_CI != 0)
+		#define SOL2_CI_I_ SOL_ON
+	#else
+		#define SOL2_CI_I_ SOL_OFF
+	#endif
+#else
+	#define SOL2_CI_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_C_ASSERT)
+	#define SOL_USER_C_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_C_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_M_ASSERT)
+	#define SOL_USER_M_ASSERT_I_ SOL_ON
+#else
+	#define SOL_USER_M_ASSERT_I_ SOL_DEFAULT_OFF
+#endif
+
+// beginning of sol/prologue.hpp
+
+#if defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue was already included in translation unit and not properly ended with an epilogue."
+#endif
+
+#define SOL_PROLOGUE_I_ 1
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#define _FWD(...) static_cast<decltype( __VA_ARGS__ )&&>( __VA_ARGS__ )
+
+	#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define _MOVE(...) static_cast<__typeof( __VA_ARGS__ )&&>( __VA_ARGS__ )
+	#else
+		#include <type_traits>
+		
+		#define _MOVE(...) static_cast<::std::remove_reference_t<( __VA_ARGS__ )>&&>( __VA_OPT__(,) )
+	#endif
+#endif
+
+// end of sol/prologue.hpp
+
+// beginning of sol/epilogue.hpp
+
+#if !defined(SOL_PROLOGUE_I_)
+	#error "[sol2] Library Prologue is missing from this translation unit."
+#else
+	#undef SOL_PROLOGUE_I_
+#endif
+
+#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+	#undef _FWD
+	#undef _MOVE
+#endif
+
+// end of sol/epilogue.hpp
+
+// beginning of sol/detail/build_version.hpp
+
+#if defined(SOL_DLL)
+	#if (SOL_DLL != 0)
+		#define SOL_DLL_I_ SOL_ON
+	#else
+		#define SOL_DLL_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_COMPILER_VCXX) && (defined(DLL_) || defined(_DLL))
+	#define SOL_DLL_I_ SOL_DEFAULT_ON
+#else
+	#define SOL_DLL_I_ SOL_DEFAULT_OFF
+#endif // DLL definition
+
+#if defined(SOL_HEADER_ONLY)
+	#if (SOL_HEADER_ONLY != 0)
+		#define SOL_HEADER_ONLY_I_ SOL_ON
+	#else
+		#define SOL_HEADER_ONLY_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_HEADER_ONLY_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_BUILD)
+	#if (SOL_BUILD != 0)
+		#define SOL_BUILD_I_ SOL_ON
+	#else
+		#define SOL_BUILD_I_ SOL_OFF
+	#endif
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_BUILD_I_ SOL_DEFAULT_OFF
+#else
+	#define SOL_BUILD_I_ SOL_DEFAULT_ON
+#endif
+
+#if defined(SOL_UNITY_BUILD)
+	#if (SOL_UNITY_BUILD != 0)
+		#define SOL_UNITY_BUILD_I_ SOL_ON
+	#else
+		#define SOL_UNITY_BUILD_I_ SOL_OFF
+	#endif
+#else
+	#define SOL_UNITY_BUILD_I_ SOL_DEFAULT_OFF
+#endif // Header only library
+
+#if defined(SOL_C_FUNCTION_LINKAGE)
+	#define SOL_C_FUNCTION_LINKAGE_I_ SOL_C_FUNCTION_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+		// C++
+		#define SOL_C_FUNCTION_LINKAGE_I_ extern "C"
+	#else
+		// normal
+		#define SOL_C_FUNCTION_LINKAGE_I_
+	#endif // C++ or not
+#endif // Linkage specification for C functions
+
+#if defined(SOL_API_LINKAGE)
+	#define SOL_API_LINKAGE_I_ SOL_API_LINKAGE
+#else
+	#if SOL_IS_ON(SOL_DLL)
+		#if SOL_IS_ON(SOL_COMPILER_VCXX) || SOL_IS_ON(SOL_PLATFORM_WINDOWS) || SOL_IS_ON(SOL_PLATFORM_CYGWIN)
+			// MSVC Compiler; or, Windows, or Cygwin platforms
+			#if SOL_IS_ON(SOL_BUILD)
+				// Building the library
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					// Using GCC
+					#define SOL_API_LINKAGE_I_ __attribute__((dllexport))
+				#else
+					// Using Clang, MSVC, etc...
+					#define SOL_API_LINKAGE_I_ __declspec(dllexport)
+				#endif
+			#else
+				#if SOL_IS_ON(SOL_COMPILER_GCC)
+					#define SOL_API_LINKAGE_I_ __attribute__((dllimport))
+				#else
+					#define SOL_API_LINKAGE_I_ __declspec(dllimport)
+				#endif
+			#endif
+		#else
+			// extern if building normally on non-MSVC
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#elif SOL_IS_ON(SOL_UNITY_BUILD)
+		// Built-in library, like how stb typical works
+		#if SOL_IS_ON(SOL_HEADER_ONLY)
+			// Header only, so functions are defined "inline"
+			#define SOL_API_LINKAGE_I_ inline
+		#else
+			// Not header only, so seperately compiled files
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#else
+		// Normal static library
+		#if SOL_IS_ON(SOL_BUILD_CXX_MODE)
+			#define SOL_API_LINKAGE_I_
+		#else
+			#define SOL_API_LINKAGE_I_ extern
+		#endif
+	#endif // DLL or not
+#endif // Build definitions
+
+#if defined(SOL_PUBLIC_FUNC_DECL)
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_PUBLIC_FUNC_DECL
+#else
+	#define SOL_PUBLIC_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DECL_)
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_INTERNAL_FUNC_DECL_
+#else
+	#define SOL_INTERNAL_FUNC_DECL_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_PUBLIC_FUNC_DEF)
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_PUBLIC_FUNC_DEF
+#else
+	#define SOL_PUBLIC_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_INTERNAL_FUNC_DEF)
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_INTERNAL_FUNC_DEF
+#else
+	#define SOL_INTERNAL_FUNC_DEF_I_ SOL_API_LINKAGE_I_
+#endif
+
+#if defined(SOL_FUNC_DECL)
+	#define SOL_FUNC_DECL_I_ SOL_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_FUNC_DEFN)
+	#define SOL_FUNC_DEFN_I_ SOL_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_FUNC_DEFN_I_ __declspec(dllexport)
+		#else
+			#define SOL_FUNC_DEFN_I_ __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_FUNC_DEFN_I_ __attribute__((visibility("default")))
+	#else
+		#define SOL_FUNC_DEFN_I_
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DECL)
+	#define SOL_HIDDEN_FUNC_DECL_I_ SOL_HIDDEN_FUNC_DECL
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DECL_I_ 
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllexport)
+		#else
+			#define SOL_HIDDEN_FUNC_DECL_I_ extern __declspec(dllimport)
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern __attribute__((visibility("default")))
+	#else
+		#define SOL_HIDDEN_FUNC_DECL_I_ extern
+	#endif
+#endif
+
+#if defined(SOL_HIDDEN_FUNC_DEFN)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ SOL_HIDDEN_FUNC_DEFN
+#elif SOL_IS_ON(SOL_HEADER_ONLY)
+	#define SOL_HIDDEN_FUNC_DEFN_I_ inline
+#elif SOL_IS_ON(SOL_DLL)
+	#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		#if SOL_IS_ON(SOL_BUILD)
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#else
+			#define SOL_HIDDEN_FUNC_DEFN_I_ 
+		#endif
+	#elif SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+		#define SOL_HIDDEN_FUNC_DEFN_I_ __attribute__((visibility("hidden")))
+	#else
+		#define SOL_HIDDEN_FUNC_DEFN_I_
+	#endif
+#endif
+
+// end of sol/detail/build_version.hpp
+
+// end of sol/version.hpp
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#ifdef check
+#pragma push_macro("check")
+#undef check
+#endif
+#endif // Unreal Engine 4 Bullshit
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#pragma GCC diagnostic ignored "-Wconversion"
+#if __GNUC__ > 6
+#pragma GCC diagnostic ignored "-Wnoexcept-type"
+#endif
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(push)
+#pragma warning(disable : 4505) // unreferenced local function has been removed GEE THANKS
+#endif                          // clang++ vs. g++ vs. VC++
+
+// beginning of sol/forward.hpp
+
+#ifndef SOL_FORWARD_HPP
+#define SOL_FORWARD_HPP
+
+#include <utility>
+#include <type_traits>
+#include <string_view>
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+struct lua_State;
+#else
+extern "C" {
+struct lua_State;
+}
+#endif // C++ Mangling for Lua vs. Not
+
+namespace sol {
+
+	enum class type;
+
+	class stateless_reference;
+	template <bool b>
+	class basic_reference;
+	using reference = basic_reference<false>;
+	using main_reference = basic_reference<true>;
+	class stateless_stack_reference;
+	class stack_reference;
+
+	template <typename A>
+	class basic_bytecode;
+
+	struct lua_value;
+
+	struct proxy_base_tag;
+	template <typename>
+	struct proxy_base;
+	template <typename, typename>
+	struct table_proxy;
+
+	template <bool, typename>
+	class basic_table_core;
+	template <bool b>
+	using table_core = basic_table_core<b, reference>;
+	template <bool b>
+	using main_table_core = basic_table_core<b, main_reference>;
+	template <bool b>
+	using stack_table_core = basic_table_core<b, stack_reference>;
+	template <typename base_type>
+	using basic_table = basic_table_core<false, base_type>;
+	using table = table_core<false>;
+	using global_table = table_core<true>;
+	using main_table = main_table_core<false>;
+	using main_global_table = main_table_core<true>;
+	using stack_table = stack_table_core<false>;
+	using stack_global_table = stack_table_core<true>;
+
+	template <typename>
+	struct basic_lua_table;
+	using lua_table = basic_lua_table<reference>;
+	using stack_lua_table = basic_lua_table<stack_reference>;
+
+	template <typename T, typename base_type>
+	class basic_usertype;
+	template <typename T>
+	using usertype = basic_usertype<T, reference>;
+	template <typename T>
+	using stack_usertype = basic_usertype<T, stack_reference>;
+
+	template <typename base_type>
+	class basic_metatable;
+	using metatable = basic_metatable<reference>;
+	using stack_metatable = basic_metatable<stack_reference>;
+
+	template <typename base_t>
+	struct basic_environment;
+	using environment = basic_environment<reference>;
+	using main_environment = basic_environment<main_reference>;
+	using stack_environment = basic_environment<stack_reference>;
+
+	template <typename T, bool>
+	class basic_function;
+	template <typename T, bool, typename H>
+	class basic_protected_function;
+	using unsafe_function = basic_function<reference, false>;
+	using safe_function = basic_protected_function<reference, false, reference>;
+	using main_unsafe_function = basic_function<main_reference, false>;
+	using main_safe_function = basic_protected_function<main_reference, false, reference>;
+	using stack_unsafe_function = basic_function<stack_reference, false>;
+	using stack_safe_function = basic_protected_function<stack_reference, false, reference>;
+	using stack_aligned_unsafe_function = basic_function<stack_reference, true>;
+	using stack_aligned_safe_function = basic_protected_function<stack_reference, true, reference>;
+	using protected_function = safe_function;
+	using main_protected_function = main_safe_function;
+	using stack_protected_function = stack_safe_function;
+	using stack_aligned_protected_function = stack_aligned_safe_function;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function = protected_function;
+	using main_function = main_protected_function;
+	using stack_function = stack_protected_function;
+	using stack_aligned_function = stack_aligned_safe_function;
+#else
+	using function = unsafe_function;
+	using main_function = main_unsafe_function;
+	using stack_function = stack_unsafe_function;
+	using stack_aligned_function = stack_aligned_unsafe_function;
+#endif
+	using stack_aligned_stack_handler_function = basic_protected_function<stack_reference, true, stack_reference>;
+
+	struct unsafe_function_result;
+	struct protected_function_result;
+	using safe_function_result = protected_function_result;
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+	using function_result = safe_function_result;
+#else
+	using function_result = unsafe_function_result;
+#endif
+
+	template <typename base_t>
+	class basic_object_base;
+	template <typename base_t>
+	class basic_object;
+	template <typename base_t>
+	class basic_userdata;
+	template <typename base_t>
+	class basic_lightuserdata;
+	template <typename base_t>
+	class basic_coroutine;
+	template <typename base_t>
+	class basic_packaged_coroutine;
+	template <typename base_t>
+	class basic_thread;
+
+	using object = basic_object<reference>;
+	using userdata = basic_userdata<reference>;
+	using lightuserdata = basic_lightuserdata<reference>;
+	using thread = basic_thread<reference>;
+	using coroutine = basic_coroutine<reference>;
+	using packaged_coroutine = basic_packaged_coroutine<reference>;
+	using main_object = basic_object<main_reference>;
+	using main_userdata = basic_userdata<main_reference>;
+	using main_lightuserdata = basic_lightuserdata<main_reference>;
+	using main_coroutine = basic_coroutine<main_reference>;
+	using stack_object = basic_object<stack_reference>;
+	using stack_userdata = basic_userdata<stack_reference>;
+	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
+	using stack_thread = basic_thread<stack_reference>;
+	using stack_coroutine = basic_coroutine<stack_reference>;
+
+	struct stack_proxy_base;
+	struct stack_proxy;
+	struct variadic_args;
+	struct variadic_results;
+	struct stack_count;
+	struct this_state;
+	struct this_main_state;
+	struct this_environment;
+
+	class state_view;
+	class state;
+
+	template <typename T>
+	struct as_table_t;
+	template <typename T>
+	struct as_container_t;
+	template <typename T>
+	struct nested;
+	template <typename T>
+	struct light;
+	template <typename T>
+	struct user;
+	template <typename T>
+	struct as_args_t;
+	template <typename T>
+	struct protect_t;
+	template <typename F, typename... Policies>
+	struct policy_wrapper;
+
+	template <typename T>
+	struct usertype_traits;
+	template <typename T>
+	struct unique_usertype_traits;
+
+	template <typename... Args>
+	struct types {
+		typedef std::make_index_sequence<sizeof...(Args)> indices;
+		static constexpr std::size_t size() {
+			return sizeof...(Args);
+		}
+	};
+
+	template <typename T>
+	struct derive : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct base : std::false_type {
+		typedef types<> type;
+	};
+
+	template <typename T>
+	struct weak_derive {
+		static bool value;
+	};
+
+	template <typename T>
+	bool weak_derive<T>::value = false;
+
+	namespace stack {
+		struct record;
+	}
+
+#if SOL_IS_OFF(SOL_USE_BOOST)
+	template <class T>
+	class optional;
+
+	template <class T>
+	class optional<T&>;
+#endif
+
+	using check_handler_type = int(lua_State*, int, type, type, const char*);
+
+} // namespace sol
+
+#define SOL_BASE_CLASSES(T, ...)                       \
+	namespace sol {                                   \
+		template <>                                  \
+		struct base<T> : std::true_type {            \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+#define SOL_DERIVED_CLASSES(T, ...)                    \
+	namespace sol {                                   \
+		template <>                                  \
+		struct derive<T> : std::true_type {          \
+			typedef ::sol::types<__VA_ARGS__> type; \
+		};                                           \
+	}                                                 \
+	void a_sol3_detail_function_decl_please_no_collide()
+
+#endif // SOL_FORWARD_HPP
+// end of sol/forward.hpp
+
+// beginning of sol/forward_detail.hpp
+
+#ifndef SOL_FORWARD_DETAIL_HPP
+#define SOL_FORWARD_DETAIL_HPP
+
+// beginning of sol/traits.hpp
+
+// beginning of sol/tuple.hpp
+
+// beginning of sol/base_traits.hpp
+
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct unchecked_t { };
+		const unchecked_t unchecked = unchecked_t {};
+	} // namespace detail
+
+	namespace meta {
+		using sfinae_yes_t = std::true_type;
+		using sfinae_no_t = std::false_type;
+
+		template <typename...>
+		using void_t = void;
+
+		template <typename T>
+		using unqualified = std::remove_cv<std::remove_reference_t<T>>;
+
+		template <typename T>
+		using unqualified_t = typename unqualified<T>::type;
+
+		namespace meta_detail {
+			template <typename T>
+			struct unqualified_non_alias : unqualified<T> { };
+
+			template <template <class...> class Test, class, class... Args>
+			struct is_detected : std::false_type { };
+
+			template <template <class...> class Test, class... Args>
+			struct is_detected<Test, void_t<Test<Args...>>, Args...> : std::true_type { };
+		} // namespace meta_detail
+
+		template <template <class...> class Trait, class... Args>
+		using is_detected = typename meta_detail::is_detected<Trait, void, Args...>::type;
+
+		template <template <class...> class Trait, class... Args>
+		constexpr inline bool is_detected_v = is_detected<Trait, Args...>::value;
+
+		template <std::size_t I>
+		using index_value = std::integral_constant<std::size_t, I>;
+
+		template <bool>
+		struct conditional {
+			template <typename T, typename U>
+			using type = T;
+		};
+
+		template <>
+		struct conditional<false> {
+			template <typename T, typename U>
+			using type = U;
+		};
+
+		template <bool B, typename T, typename U>
+		using conditional_t = typename conditional<B>::template type<T, U>;
+
+		namespace meta_detail {
+			template <typename T, template <typename...> class Templ>
+			struct is_specialization_of : std::false_type { };
+			template <typename... T, template <typename...> class Templ>
+			struct is_specialization_of<Templ<T...>, Templ> : std::true_type { };
+		} // namespace meta_detail
+
+		template <typename T, template <typename...> class Templ>
+		using is_specialization_of = meta_detail::is_specialization_of<std::remove_cv_t<T>, Templ>;
+
+		template <typename T, template <typename...> class Templ>
+		inline constexpr bool is_specialization_of_v = is_specialization_of<std::remove_cv_t<T>, Templ>::value;
+
+		template <typename T>
+		struct identity {
+			typedef T type;
+		};
+
+		template <typename T>
+		using identity_t = typename identity<T>::type;
+
+		template <typename T>
+		using is_builtin_type = std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value>;
+
+		namespace meta_detail {
+			template <typename T, typename = void>
+			struct has_internal_marker_impl : std::false_type { };
+			template <typename T>
+			struct has_internal_marker_impl<T, void_t<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>> : std::true_type { };
+
+			template <typename T>
+			using has_internal_marker = has_internal_marker_impl<T>;
+
+			template <typename T>
+			constexpr inline bool has_internal_marker_v = has_internal_marker<T>::value;
+		} // namespace meta_detail
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/base_traits.hpp
+
+#include <tuple>
+#include <cstddef>
+
+namespace sol {
+	namespace detail {
+		using swallow = std::initializer_list<int>;
+	} // namespace detail
+
+	namespace meta {
+		template <typename T>
+		using is_tuple = is_specialization_of<T, std::tuple>;
+
+		template <typename T>
+		constexpr inline bool is_tuple_v = is_tuple<T>::value;
+
+		namespace detail {
+			template <typename... Args>
+			struct tuple_types_ {
+				typedef types<Args...> type;
+			};
+
+			template <typename... Args>
+			struct tuple_types_<std::tuple<Args...>> {
+				typedef types<Args...> type;
+			};
+		} // namespace detail
+
+		template <typename... Args>
+		using tuple_types = typename detail::tuple_types_<Args...>::type;
+
+		template <typename Arg>
+		struct pop_front_type;
+
+		template <typename Arg>
+		using pop_front_type_t = typename pop_front_type<Arg>::type;
+
+		template <typename... Args>
+		struct pop_front_type<types<Args...>> {
+			typedef void front_type;
+			typedef types<Args...> type;
+		};
+
+		template <typename Arg, typename... Args>
+		struct pop_front_type<types<Arg, Args...>> {
+			typedef Arg front_type;
+			typedef types<Args...> type;
+		};
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element = std::tuple_element<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using tuple_element_t = std::tuple_element_t<N, std::remove_reference_t<Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
+
+		template <std::size_t N, typename Tuple>
+		using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
+
+	} // namespace meta
+} // namespace sol
+
+// end of sol/tuple.hpp
+
+// beginning of sol/bind_traits.hpp
+
+namespace sol { namespace meta {
+	namespace meta_detail {
+		template <typename F>
+		using detect_deducible_signature = decltype(&F::operator());
+	} // namespace meta_detail
+
+	template <typename F>
+	using call_operator_deducible = typename is_detected<meta_detail::detect_deducible_signature, F>::type;
+
+	template <typename F>
+	constexpr inline bool call_operator_deducible_v = call_operator_deducible<F>::value;
+
+	namespace meta_detail {
+
+		template <std::size_t I, typename T>
+		struct void_tuple_element : meta::tuple_element<I, T> { };
+
+		template <std::size_t I>
+		struct void_tuple_element<I, std::tuple<>> {
+			typedef void type;
+		};
+
+		template <std::size_t I, typename T>
+		using void_tuple_element_t = typename void_tuple_element<I, T>::type;
+
+		template <bool it_is_noexcept, bool has_c_variadic, typename T, typename R, typename... Args>
+		struct basic_traits {
+		private:
+			using first_type = meta::conditional_t<std::is_void<T>::value, int, T>&;
+
+		public:
+			inline static constexpr const bool is_noexcept = it_is_noexcept;
+			inline static constexpr bool is_member_function = std::is_void<T>::value;
+			inline static constexpr bool has_c_var_arg = has_c_variadic;
+			inline static constexpr std::size_t arity = sizeof...(Args);
+			inline static constexpr std::size_t free_arity = sizeof...(Args) + static_cast<std::size_t>(!std::is_void<T>::value);
+			typedef types<Args...> args_list;
+			typedef std::tuple<Args...> args_tuple;
+			typedef T object_type;
+			typedef R return_type;
+			typedef tuple_types<R> returns_list;
+			typedef R(function_type)(Args...);
+			typedef meta::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
+			typedef meta::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
+			typedef meta::conditional_t<std::is_void<T>::value, R (*)(Args...), R (*)(first_type, Args...)> free_function_pointer_type;
+			typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+		template <typename Signature, bool b = call_operator_deducible<Signature>::value>
+		struct fx_traits : public basic_traits<false, false, void, void> { };
+
+		// Free Functions
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...), false> : public basic_traits<false, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...);
+		};
+
+		// Member Functions
+		/* C-Style Variadics */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...), false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&&, false> : public basic_traits<false, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (*)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R (*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) & noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...)&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) && noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};
+
+#endif // noexcept is part of a function's type
+
+#if SOL_IS_ON(SOL_COMPILER_VCXX) && SOL_IS_ON(SOL_PLATFORM_X86)
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...), false> : public basic_traits<false, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...);
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...), false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...);
+		};
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile;
+		};
+
+		/* Member Function Qualifiers */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) &&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&&;
+		};
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&&, false> : public basic_traits<false, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&&;
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+
+		template <typename R, typename... Args>
+		struct fx_traits<R __stdcall(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R(__stdcall*)(Args...) noexcept, false> : public basic_traits<true, false, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall cannot be applied to functions with varargs*/
+		/*template <typename R, typename... Args>
+		struct fx_traits<__stdcall R(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};
+
+		template <typename R, typename... Args>
+		struct fx_traits<R (__stdcall *)(Args..., ...) noexcept, false> : public basic_traits<true, true, void, R, Args...> {
+			typedef R(__stdcall* function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) noexcept;
+		};*/
+
+		/* Const Volatile */
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) & noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) & noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) & noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...)&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) && noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) && noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) && noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const&& noexcept;
+		};*/
+
+		template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args...) const volatile&& noexcept, false> : public basic_traits<true, false, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args...) const volatile&& noexcept;
+		};
+
+		/* __stdcall does not work with varargs */
+		/*template <typename T, typename R, typename... Args>
+		struct fx_traits<R (__stdcall T::*)(Args..., ...) const volatile&& noexcept, false> : public basic_traits<true, true, T, R, Args...> {
+			typedef R (__stdcall T::*function_pointer_type)(Args..., ...) const volatile&& noexcept;
+		};*/
+#endif // noexcept is part of a function's type
+#endif // __stdcall x86 VC++ bug
+
+		template <typename Signature>
+		struct fx_traits<Signature, true> : public fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> { };
+
+		template <typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
+		struct callable_traits : public fx_traits<std::decay_t<Signature>> { };
+
+		template <typename R, typename T>
+		struct callable_traits<R(T::*), true> {
+			typedef meta::conditional_t<std::is_array_v<R>, std::add_lvalue_reference_t<R>, R> return_type;
+			typedef return_type Arg;
+			typedef T object_type;
+			using signature_type = R(T::*);
+			inline static constexpr bool is_noexcept = false;
+			inline static constexpr bool is_member_function = false;
+			inline static constexpr std::size_t arity = 1;
+			inline static constexpr std::size_t free_arity = 2;
+			typedef std::tuple<Arg> args_tuple;
+			typedef types<Arg> args_list;
+			typedef types<T, Arg> free_args_list;
+			typedef meta::tuple_types<return_type> returns_list;
+			typedef return_type(function_type)(T&, return_type);
+			typedef return_type (*function_pointer_type)(T&, Arg);
+			typedef return_type (*free_function_pointer_type)(T&, Arg);
+			template <std::size_t i>
+			using arg_at = void_tuple_element_t<i, args_tuple>;
+		};
+
+	} // namespace meta_detail
+
+	template <typename Signature>
+	using bind_traits = meta_detail::callable_traits<Signature>;
+
+	namespace meta_detail {
+		template <typename, bool>
+		struct is_probably_stateless_lambda : std::false_type { };
+
+		template <typename T>
+		struct is_probably_stateless_lambda<T, true> : std::is_convertible<T, typename bind_traits<T>::function_type*>::type { };
+	} // namespace meta_detail
+
+	template <typename T>
+	using is_probably_stateless_lambda = typename meta_detail::is_probably_stateless_lambda<T, std::is_empty_v<T> && call_operator_deducible_v<T>>::type;
+
+	template <typename T>
+	inline constexpr bool is_probably_stateless_lambda_v = is_probably_stateless_lambda<T>::value;
+
+	template <typename Signature>
+	using function_args_t = typename bind_traits<Signature>::args_list;
+
+	template <typename Signature>
+	using function_signature_t = typename bind_traits<Signature>::signature_type;
+
+	template <typename Signature>
+	using function_return_t = typename bind_traits<Signature>::return_type;
+}} // namespace sol::meta
+
+// end of sol/bind_traits.hpp
+
+// beginning of sol/pointer_like.hpp
+
+#include <utility>
+#include <type_traits>
+#include <memory>
+
+namespace sol {
+
+	namespace meta {
+		namespace meta_detail {
+			template <typename T>
+			using is_dereferenceable_test = decltype(*std::declval<T>());
+
+			template <typename T>
+			using is_explicitly_dereferenceable_test = decltype(std::declval<T>().operator*());
+		} // namespace meta_detail
+
+		template <typename T>
+		using is_pointer_like = std::integral_constant<bool,
+		     !std::is_array_v<T> && (std::is_pointer_v<T> || is_detected_v<meta_detail::is_explicitly_dereferenceable_test, T>)>;
+
+		template <typename T>
+		constexpr inline bool is_pointer_like_v = is_pointer_like<T>::value;
+	} // namespace meta
+
+	namespace detail {
+
+		template <typename T>
+		auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
+			return std::forward<T>(item);
+		}
+
+		template <typename T>
+		T& unwrap(std::reference_wrapper<T> arg) {
+			return arg.get();
+		}
+
+		template <typename T>
+		inline decltype(auto) deref(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline decltype(auto) deref_move_only(T&& item) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_pointer_like_v<Tu> && !std::is_pointer_v<Tu> && !std::is_copy_constructible_v<Tu>) {
+				return *std::forward<T>(item);
+			}
+			else {
+				return std::forward<T>(item);
+			}
+		}
+
+		template <typename T>
+		inline T* ptr(T& val) {
+			return std::addressof(val);
+		}
+
+		template <typename T>
+		inline T* ptr(std::reference_wrapper<T> val) {
+			return std::addressof(val.get());
+		}
+
+		template <typename T>
+		inline T* ptr(T* val) {
+			return val;
+		}
+	} // namespace detail
+} // namespace sol
+
+// end of sol/pointer_like.hpp
+
+// beginning of sol/string_view.hpp
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <functional>
+
+namespace sol {
+	template <typename C, typename T = std::char_traits<C>>
+	using basic_string_view = std::basic_string_view<C, T>;
+
+	typedef std::string_view string_view;
+	typedef std::wstring_view wstring_view;
+	typedef std::u16string_view u16string_view;
+	typedef std::u32string_view u32string_view;
+	typedef std::hash<std::string_view> string_view_hash;
+} // namespace sol
+
+// end of sol/string_view.hpp
+
+#include <type_traits>
+#include <cstdint>
+#include <memory>
+#include <functional>
+#include <array>
+#include <iterator>
+#include <iosfwd>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant is weird on XCode, thanks XCode
+
+namespace sol { namespace meta {
+	template <typename T>
+	struct unwrapped {
+		typedef T type;
+	};
+
+	template <typename T>
+	struct unwrapped<std::reference_wrapper<T>> {
+		typedef T type;
+	};
+
+	template <typename T>
+	using unwrapped_t = typename unwrapped<T>::type;
+
+	template <typename T>
+	struct unwrap_unqualified : unwrapped<unqualified_t<T>> { };
+
+	template <typename T>
+	using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
+
+	template <typename T>
+	struct remove_member_pointer;
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*> {
+		typedef R type;
+	};
+
+	template <typename R, typename T>
+	struct remove_member_pointer<R T::*const> {
+		typedef R type;
+	};
+
+	template <typename T>
+	using remove_member_pointer_t = remove_member_pointer<T>;
+
+	template <typename T, typename...>
+	struct all_same : std::true_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct all_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value && all_same<T, Args...>::value> { };
+
+	template <typename T, typename...>
+	struct any_same : std::false_type { };
+
+	template <typename T, typename U, typename... Args>
+	struct any_same<T, U, Args...> : std::integral_constant<bool, std::is_same<T, U>::value || any_same<T, Args...>::value> { };
+
+	template <typename T, typename... Args>
+	constexpr inline bool any_same_v = any_same<T, Args...>::value;
+
+	template <bool B>
+	using boolean = std::integral_constant<bool, B>;
+
+	template <bool B>
+	constexpr inline bool boolean_v = boolean<B>::value;
+
+	template <typename T>
+	using neg = boolean<!T::value>;
+
+	template <typename T>
+	constexpr inline bool neg_v = neg<T>::value;
+
+	template <typename... Args>
+	struct all : boolean<true> { };
+
+	template <typename T, typename... Args>
+	struct all<T, Args...> : std::conditional_t<T::value, all<Args...>, boolean<false>> { };
+
+	template <typename... Args>
+	struct any : boolean<false> { };
+
+	template <typename T, typename... Args>
+	struct any<T, Args...> : std::conditional_t<T::value, boolean<true>, any<Args...>> { };
+
+	template <typename... Args>
+	constexpr inline bool all_v = all<Args...>::value;
+
+	template <typename... Args>
+	constexpr inline bool any_v = any<Args...>::value;
+
+	enum class enable_t { _ };
+
+	constexpr const auto enabler = enable_t::_;
+
+	template <bool value, typename T = void>
+	using disable_if_t = std::enable_if_t<!value, T>;
+
+	template <typename... Args>
+	using enable = std::enable_if_t<all<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
+
+	template <typename... Args>
+	using enable_any = std::enable_if_t<any<Args...>::value, enable_t>;
+
+	template <typename... Args>
+	using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
+
+	template <typename V, typename... Vs>
+	struct find_in_pack_v : boolean<false> { };
+
+	template <typename V, typename Vs1, typename... Vs>
+	struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
+
+	namespace meta_detail {
+		template <std::size_t I, typename T, typename... Args>
+		struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+		template <std::size_t I, typename T, typename T1, typename... Args>
+		struct index_in_pack<I, T, T1, Args...>
+		: conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> { };
+	} // namespace meta_detail
+
+	template <typename T, typename... Args>
+	struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <typename T, typename List>
+	struct index_in : meta_detail::index_in_pack<0, T, List> { };
+
+	template <typename T, typename... Args>
+	struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> { };
+
+	template <std::size_t I, typename... Args>
+	struct at_in_pack { };
+
+	template <std::size_t I, typename... Args>
+	using at_in_pack_t = typename at_in_pack<I, Args...>::type;
+
+	template <std::size_t I, typename Arg, typename... Args>
+	struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> { };
+
+	template <typename Arg, typename... Args>
+	struct at_in_pack<0, Arg, Args...> {
+		typedef Arg type;
+	};
+
+	namespace meta_detail {
+		template <typename, typename TI>
+		using on_even = meta::boolean<(TI::value % 2) == 0>;
+
+		template <typename, typename TI>
+		using on_odd = meta::boolean<(TI::value % 2) == 1>;
+
+		template <typename, typename>
+		using on_always = std::true_type;
+
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename... Ts>
+		struct count_when_for_pack : std::integral_constant<std::size_t, 0> { };
+		template <template <typename...> class When, std::size_t Limit, std::size_t I, template <typename...> class Pred, typename T, typename... Ts>
+			          struct count_when_for_pack<When, Limit, I, Pred, T, Ts...> : conditional_t < sizeof...(Ts)
+			     == 0
+			|| Limit<2, std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
+			     count_when_for_pack<When, Limit - static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value),
+			          I + static_cast<std::size_t>(When<T, std::integral_constant<std::size_t, I>>::value&& Pred<T>::value), Pred, Ts...>> { };
+	} // namespace meta_detail
+
+	template <template <typename...> class Pred, typename... Ts>
+	struct count_for_pack : meta_detail::count_when_for_pack<meta_detail::on_always, sizeof...(Ts), 0, Pred, Ts...> { };
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_pack_v = count_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename List>
+	struct count_for;
+
+	template <template <typename...> class Pred, typename... Args>
+	struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_for_to_pack : meta_detail::count_when_for_pack<meta_detail::on_always, Limit, 0, Pred, Ts...> { };
+
+	template <std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_for_to_pack_v = count_for_to_pack<Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	struct count_when_for_to_pack : meta_detail::count_when_for_pack<When, Limit, 0, Pred, Ts...> { };
+
+	template <template <typename...> class When, std::size_t Limit, template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_when_for_to_pack_v = count_when_for_to_pack<When, Limit, Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_even_for_pack = count_when_for_to_pack<meta_detail::on_even, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_even_for_pack_v = count_even_for_pack<Pred, Ts...>::value;
+
+	template <template <typename...> class Pred, typename... Ts>
+	using count_odd_for_pack = count_when_for_to_pack<meta_detail::on_odd, sizeof...(Ts), Pred, Ts...>;
+
+	template <template <typename...> class Pred, typename... Ts>
+	inline constexpr std::size_t count_odd_for_pack_v = count_odd_for_pack<Pred, Ts...>::value;
+
+	template <typename... Args>
+	struct return_type {
+		typedef std::tuple<Args...> type;
+	};
+
+	template <typename T>
+	struct return_type<T> {
+		typedef T type;
+	};
+
+	template <>
+	struct return_type<> {
+		typedef void type;
+	};
+
+	template <typename... Args>
+	using return_type_t = typename return_type<Args...>::type;
+
+	namespace meta_detail {
+		template <typename>
+		struct always_true : std::true_type { };
+		struct is_invokable_tester {
+			template <typename Fun, typename... Args>
+			static always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+			template <typename...>
+			static std::false_type test(...);
+		};
+	} // namespace meta_detail
+
+	template <typename T>
+	struct is_invokable;
+	template <typename Fun, typename... Args>
+	struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) { };
+
+	namespace meta_detail {
+
+		template <typename T, typename = void>
+		struct is_invocable : std::is_function<std::remove_pointer_t<T>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_same<decltype(void(&T::operator())), void>::value>> { };
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F { };
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct is_invocable<T,
+			std::enable_if_t<!std::is_final<unqualified_t<T>>::value && std::is_class<unqualified_t<T>>::value
+			     && !std::is_destructible<unqualified_t<T>>::value>> {
+			struct F {
+				void operator()() {};
+			};
+			struct Derived : T, F {
+				~Derived() = delete;
+			};
+			template <typename U, U>
+			struct Check;
+
+			template <typename V>
+			static sfinae_no_t test(Check<void (F::*)(), &V::operator()>*);
+
+			template <typename>
+			static sfinae_yes_t test(...);
+
+			static constexpr bool value = std::is_same_v<decltype(test<Derived>(0)), sfinae_yes_t>;
+		};
+
+		struct has_begin_end_impl {
+			template <typename T, typename U = unqualified_t<T>, typename B = decltype(std::declval<U&>().begin()),
+				typename E = decltype(std::declval<U&>().end())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_type_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::key_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_comp_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().key_comp())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_load_factor_impl {
+			template <typename T, typename V = decltype(std::declval<unqualified_t<T>>().load_factor())>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_mapped_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::mapped_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_value_type_impl {
+			template <typename T, typename V = typename unqualified_t<T>::value_type>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_iterator_impl {
+			template <typename T, typename V = typename unqualified_t<T>::iterator>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		struct has_key_value_pair_impl {
+			template <typename T, typename U = unqualified_t<T>, typename V = typename U::value_type, typename F = decltype(std::declval<V&>().first),
+				typename S = decltype(std::declval<V&>().second)>
+			static std::true_type test(int);
+
+			template <typename...>
+			static std::false_type test(...);
+		};
+
+		template <typename T>
+		struct has_push_back_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_insert_with_iterator_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(
+				std::declval<std::add_rvalue_reference_t<typename C::iterator>>(), std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = !std::is_same_v<decltype(test<T>(0)), sfinae_no_t>;
+		};
+
+		template <typename T>
+		struct has_insert_after_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().insert_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(),
+				std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_max_size_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().max_size())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_to_string_test {
+		private:
+			template <typename C>
+			static sfinae_yes_t test(decltype(std::declval<C>().to_string())*);
+			template <typename C>
+			static sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), sfinae_yes_t>;
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_test<T, U, void_t<decltype(std::declval<T&>() < std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_equal_test<T, U, void_t<decltype(std::declval<T&>() == std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_less_equal_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_less_equal_test<T, U, void_t<decltype(std::declval<T&>() <= std::declval<U&>())>>
+		: public std::integral_constant<bool,
+#if SOL_IS_ON(SOL_STD_VARIANT)
+			  !is_specialization_of_v<unqualified_t<T>, std::variant> && !is_specialization_of_v<unqualified_t<U>, std::variant>
+#else
+			  true
+#endif
+			  > {
+		};
+
+		template <typename T, typename U, typename = void>
+		class supports_op_left_shift_test : public std::false_type { };
+		template <typename T, typename U>
+		class supports_op_left_shift_test<T, U, void_t<decltype(std::declval<T&>() << std::declval<U&>())>> : public std::true_type { };
+
+		template <typename T, typename = void>
+		class supports_adl_to_string_test : public std::false_type { };
+		template <typename T>
+		class supports_adl_to_string_test<T, void_t<decltype(to_string(std::declval<const T&>()))>> : public std::true_type { };
+
+		template <typename T, bool b>
+		struct is_matched_lookup_impl : std::false_type { };
+		template <typename T>
+		struct is_matched_lookup_impl<T, true> : std::is_same<typename T::key_type, typename T::value_type> { };
+
+		template <typename T>
+		using non_void_t = meta::conditional_t<std::is_void_v<T>, ::sol::detail::unchecked_t, T>;
+	} // namespace meta_detail
+
+	template <typename T, typename U = T>
+	class supports_op_less : public meta_detail::supports_op_less_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_equal : public meta_detail::supports_op_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_less_equal : public meta_detail::supports_op_less_equal_test<T, U> { };
+
+	template <typename T, typename U = T>
+	class supports_op_left_shift : public meta_detail::supports_op_left_shift_test<T, U> { };
+
+	template <typename T>
+	class supports_adl_to_string : public meta_detail::supports_adl_to_string_test<T> { };
+
+	template <typename T>
+	class supports_to_string_member : public meta::boolean<meta_detail::has_to_string_test<meta_detail::non_void_t<T>>::value> { };
+
+	template <typename T>
+	using is_invocable = boolean<meta_detail::is_invocable<T>::value>;
+
+	template <typename T>
+	constexpr inline bool is_invocable_v = is_invocable<T>::value;
+
+	template <typename T>
+	struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) { };
+
+	template <typename T>
+	constexpr inline bool has_begin_end_v = has_begin_end<T>::value;
+
+	template <typename T>
+	struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_type : decltype(meta_detail::has_key_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_key_comp : decltype(meta_detail::has_key_comp_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_load_factor : decltype(meta_detail::has_load_factor_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_mapped_type : decltype(meta_detail::has_mapped_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_iterator : decltype(meta_detail::has_iterator_impl::test<T>(0)) { };
+
+	template <typename T>
+	struct has_value_type : decltype(meta_detail::has_value_type_impl::test<T>(0)) { };
+
+	template <typename T>
+	using has_push_back = meta::boolean<meta_detail::has_push_back_test<T>::value>;
+
+	template <typename T>
+	using has_max_size = meta::boolean<meta_detail::has_max_size_test<T>::value>;
+
+	template <typename T>
+	using has_insert = meta::boolean<meta_detail::has_insert_test<T>::value>;
+
+	template <typename T>
+	using has_insert_with_iterator = meta::boolean<meta_detail::has_insert_with_iterator_test<T>::value>;
+
+	template <typename T>
+	using has_insert_after = meta::boolean<meta_detail::has_insert_after_test<T>::value>;
+
+	template <typename T>
+	using has_size = meta::boolean<meta_detail::has_size_test<T>::value>;
+
+	template <typename T>
+	using is_associative = meta::all<has_key_type<T>, has_key_value_pair<T>, has_mapped_type<T>>;
+
+	template <typename T>
+	using is_lookup = meta::all<has_key_type<T>, has_value_type<T>>;
+
+	template <typename T>
+	using is_ordered = meta::all<has_key_comp<T>, meta::neg<has_load_factor<T>>>;
+
+	template <typename T>
+	using is_matched_lookup = meta_detail::is_matched_lookup_impl<T, is_lookup<T>::value>;
+
+	template <typename T>
+	using is_initializer_list = meta::is_specialization_of<T, std::initializer_list>;
+
+	template <typename T>
+	constexpr inline bool is_initializer_list_v = is_initializer_list<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_literal_array_of = boolean<std::is_array_v<T> && std::is_same_v<std::remove_all_extents_t<T>, CharT>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_literal_array_of_v = is_string_literal_array_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_literal_array = boolean<std::is_array_v<T> && any_same_v<std::remove_all_extents_t<T>, char,
+#if SOL_IS_ON(SOL_CHAR8_T)
+	char8_t,
+#endif
+	char16_t, char32_t, wchar_t>>;
+
+	template <typename T>
+	constexpr inline bool is_string_literal_array_v = is_string_literal_array<T>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT, typename AllocT>
+	struct is_string_of<std::basic_string<CharT, TraitsT, AllocT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_of_v = is_string_of<T, CharT>::value;
+
+	template <typename T, typename CharT>
+	struct is_string_view_of : std::false_type { };
+
+	template <typename CharT, typename CharTargetT, typename TraitsT>
+	struct is_string_view_of<std::basic_string_view<CharT, TraitsT>, CharTargetT> : std::is_same<CharT, CharTargetT> { };
+
+	template <typename T, typename CharT>
+	constexpr inline bool is_string_view_of_v = is_string_view_of<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like
+		= meta::boolean<is_specialization_of_v<T, std::basic_string> || is_specialization_of_v<T, std::basic_string_view> || is_string_literal_array_v<T>>;
+
+	template <typename T>
+	constexpr inline bool is_string_like_v = is_string_like<T>::value;
+
+	template <typename T, typename CharT = char>
+	using is_string_constructible = meta::boolean<
+		is_string_literal_array_of_v<T,
+		     CharT> || std::is_same_v<T, const CharT*> || std::is_same_v<T, CharT> || is_string_of_v<T, CharT> || std::is_same_v<T, std::initializer_list<CharT>> || is_string_view_of_v<T, CharT> || std::is_null_pointer_v<T>>;
+
+	template <typename T, typename CharT = char>
+	constexpr inline bool is_string_constructible_v = is_string_constructible<T, CharT>::value;
+
+	template <typename T>
+	using is_string_like_or_constructible = meta::boolean<is_string_like_v<T> || is_string_constructible_v<T>>;
+
+	template <typename T>
+	struct is_pair : std::false_type { };
+
+	template <typename T1, typename T2>
+	struct is_pair<std::pair<T1, T2>> : std::true_type { };
+
+	template <typename T, typename Char>
+	using is_c_str_of = any<std::is_same<T, const Char*>, std::is_same<T, Char const* const>, std::is_same<T, Char*>, is_string_literal_array_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_of_v = is_c_str_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str = is_c_str_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_v = is_c_str<T>::value;
+
+	template <typename T, typename Char>
+	using is_c_str_or_string_of = any<is_c_str_of<T, Char>, is_string_of<T, Char>>;
+
+	template <typename T, typename Char>
+	constexpr inline bool is_c_str_or_string_of_v = is_c_str_or_string_of<T, Char>::value;
+
+	template <typename T>
+	using is_c_str_or_string = is_c_str_or_string_of<T, char>;
+
+	template <typename T>
+	constexpr inline bool is_c_str_or_string_v = is_c_str_or_string<T>::value;
+
+	template <typename T>
+	struct is_move_only : all<neg<std::is_reference<T>>, neg<std::is_copy_constructible<unqualified_t<T>>>, std::is_move_constructible<unqualified_t<T>>> { };
+
+	template <typename T>
+	using is_not_move_only = neg<is_move_only<T>>;
+
+	namespace meta_detail {
+		template <typename T>
+		decltype(auto) force_tuple(T&& x) {
+			if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>) {
+				return std::forward<T>(x);
+			}
+			else {
+				return std::tuple<T>(std::forward<T>(x));
+			}
+		}
+	} // namespace meta_detail
+
+	template <typename... X>
+	decltype(auto) tuplefy(X&&... x) {
+		return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
+	}
+
+	template <typename T, typename = void>
+	struct iterator_tag {
+		using type = std::input_iterator_tag;
+	};
+
+	template <typename T>
+	struct iterator_tag<T, conditional_t<false, typename std::iterator_traits<T>::iterator_category, void>> {
+		using type = typename std::iterator_traits<T>::iterator_category;
+	};
+
+}} // namespace sol::meta
+
+// end of sol/traits.hpp
+
+namespace sol {
+	namespace detail {
+		const bool default_safe_function_calls =
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_CALLS)
+		     true;
+#else
+		     false;
+#endif
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+	}} // namespace meta::meta_detail
+
+	namespace stack { namespace stack_detail {
+		using undefined_method_func = void (*)(stack_reference);
+
+		template <typename T>
+		void set_undefined_methods_on(stack_reference);
+
+		struct undefined_metatable;
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+#endif // SOL_FORWARD_DETAIL_HPP
+// end of sol/forward_detail.hpp
+
+// beginning of sol/assert.hpp
+
+#if SOL_IS_ON(SOL2_CI)
+
+struct pre_main {
+	pre_main() {
+#ifdef _MSC_VER
+		_set_abort_behavior(0, _WRITE_ABORT_MSG);
+#endif
+	}
+} inline sol2_ci_dont_lock_ci_please = {};
+
+#endif // Prevent lockup when doing Continuous Integration
+
+#if SOL_IS_ON(SOL_USER_C_ASSERT)
+	#define sol_c_assert(...) SOL_C_ASSERT(__VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+			#define sol_c_assert(...)                                                                                               \
+				do {                                                                                                               \
+					if (!(__VA_ARGS__)) {                                                                                           \
+						std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << std::endl; \
+						std::terminate();                                                                                        \
+					}                                                                                                             \
+				} while (false)
+	#else
+		#define sol_c_assert(...)           \
+			do {                           \
+				if (false) {              \
+					(void)(__VA_ARGS__); \
+				}                         \
+			} while (false)
+	#endif
+#endif
+
+#if SOL_IS_ON(SOL_USER_M_ASSERT)
+	#define sol_m_assert(message, ...) SOL_M_ASSERT(message, __VA_ARGS__)
+#else
+	#if SOL_IS_ON(SOL_DEBUG_BUILD)
+		#include <exception>
+		#include <iostream>
+		#include <cstdlib>
+
+		#define sol_m_assert(message, ...)                                                                                                         \
+			do {                                                                                                                                  \
+				if (!(__VA_ARGS__)) {                                                                                                              \
+					std::cerr << "Assertion `" #__VA_ARGS__ "` failed in " << __FILE__ << " line " << __LINE__ << ": " << message << std::endl; \
+					std::terminate();                                                                                                           \
+				}                                                                                                                                \
+			} while (false)
+	#else
+		#define sol_m_assert(message, ...)    \
+			do {                             \
+				if (false) {                \
+					(void)(__VA_ARGS__);   \
+					(void)sizeof(message); \
+				}                           \
+			} while (false)
+	#endif
+#endif
+
+// end of sol/assert.hpp
+
+// beginning of sol/bytecode.hpp
+
+// beginning of sol/compatibility.hpp
+
+// beginning of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA)
+	#include <lua.h>
+	#include <lualib.h>
+	#include <lauxlib.h>
+#elif SOL_IS_ON(SOL_USE_LUA_HPP)
+	#include <lua.hpp>
+#else
+	extern "C" {
+		#include <lua.h>
+		#include <lauxlib.h>
+		#include <lualib.h>
+	}
+#endif // C++ Mangling for Lua vs. Not
+
+#if defined(SOL_LUAJIT)
+	#if (SOL_LUAJIT != 0)
+		#define SOL_USE_LUAJIT_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_I_ SOL_OFF
+	#endif
+#elif defined(LUAJIT_VERSION)
+	#define SOL_USE_LUAJIT_I_ SOL_ON
+#else
+	#define SOL_USE_LUAJIT_I_ SOL_DEFAULT_OFF
+#endif // luajit
+
+#if SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+	#include <luajit.h>
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	extern "C" {
+		#include <luajit.h>
+	}
+#endif // C++ LuaJIT ... whatever that means
+
+#if defined(SOL_LUAJIT_VERSION)
+	#define SOL_LUAJIT_VERSION_I_ SOL_LUAJIT_VERSION
+#elif SOL_IS_ON(SOL_USE_LUAJIT)
+	#define SOL_LUAJIT_VERSION_I_ LUAJIT_VERSION_NUM
+#else
+	#define SOL_LUAJIT_VERSION_I_ 0
+#endif
+
+#if defined(SOL_LUAJIT_FFI_DISABLED)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#elif defined(LUAJIT_DISABLE_FFI)
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_ON
+#else
+	#define SOL_LUAJIT_FFI_DISABLED_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(MOONJIT_VERSION)
+	#define SOL_USE_MOONJIT_I_ SOL_ON
+#else
+	#define SOL_USE_MOONJIT_I_ SOL_OFF
+#endif
+
+#if !defined(SOL_LUA_VERSION)
+	#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+		#define SOL_LUA_VERSION LUA_VERSION_NUM
+	#elif !defined(LUA_VERSION_NUM) || !(LUA_VERSION_NUM)
+		// Definitely 5.0
+		#define SOL_LUA_VERSION 500
+	#else
+		// ??? Not sure, assume latest?
+		#define SOL_LUA_VERSION 504
+	#endif // Lua Version 503, 502, 501 || luajit, 500
+#endif // SOL_LUA_VERSION
+
+#if defined(SOL_LUA_VERSION)
+	#define SOL_LUA_VERSION_I_ SOL_LUA_VERSION
+#else
+	#define SOL_LUA_VERSION_I_ 504
+#endif
+
+#if defined(SOL_EXCEPTIONS_ALWAYS_UNSAFE)
+	#if (SOL_EXCEPTIONS_ALWAYS_UNSAFE != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#endif
+#elif defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
+	#if (SOL_EXCEPTIONS_SAFE_PROPAGATION != 0)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#elif SOL_LUAJIT_VERSION_I_ >= 20100
+	// LuaJIT 2.1.0-beta3 and better have exception support locked in for all platforms (mostly)
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+#elif SOL_LUAJIT_VERSION_I_ >= 20000
+	// LuaJIT 2.0.x have exception support only on x64 builds
+	#if SOL_IS_ON(SOL_PLATFORM_X64)
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_OFF
+	#endif
+#else
+	// otherwise, there is no exception safety for
+	// shoving exceptions through Lua and errors should
+	// always be serialized
+	#define SOL_PROPAGATE_EXCEPTIONS_I_ SOL_DEFAULT_OFF
+#endif
+
+#if defined(SOL_EXCEPTIONS_CATCH_ALL)
+	#if (SOL_EXCEPTIONS_CATCH_ALL != 0)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_ON
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#elif SOL_IS_ON(SOL_USE_CXX_LUA)
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_OFF
+	#else
+		#define SOL_EXCEPTIONS_CATCH_ALL_I_ SOL_DEFAULT_ON
+	#endif
+#endif
+
+#if defined(SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE)
+	#if (SOL_LUAJIT_USE_EXCEPTION_TRAMPOLINE != 0)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS) && SOL_IS_ON(SOL_USE_LUAJIT)
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_ON
+	#else
+		#define SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined(SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION)
+	#if (SOL_LUAL_STREAM_HAS_CLOSE_FUNCTION != 0)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_OFF
+	#endif
+#else
+	#if SOL_IS_OFF(SOL_USE_LUAJIT) && (SOL_LUA_VERSION > 501)
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_ON
+	#else
+		#define SOL_LUAL_STREAM_USE_CLOSE_FUNCTION_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_BIT32_LIB)
+	#if SOL_LUA_BIT32_LIB != 0
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_OFF
+	#endif
+#else
+	// Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
+	// Lua 5.2, or other versions of Lua with the compat flag, or Lua that is not 5.2 with the specific define (5.4.1 either removed it entirely or broke it)
+	#if (SOL_LUA_VERSION_I_ == 502) || (defined(LUA_COMPAT_BITLIB) && (LUA_COMPAT_BITLIB != 0)) || (SOL_LUA_VERSION_I_ < 504 && (defined(LUA_COMPAT_5_2) && (LUA_COMPAT_5_2 != 0)))
+		#define SOL_LUA_BIT32_LIB_I_ SOL_ON
+	#else
+		#define SOL_LUA_BIT32_LIB_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+#if defined (SOL_LUA_NIL_IN_TABLES)
+	#if SOL_LUA_NIL_IN_TABLES != 0
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_OFF
+	#endif
+#else
+	#if defined(LUA_NILINTABLE) && (LUA_NILINTABLE != 0)
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_ON
+	#else
+		#define SOL_LUA_NIL_IN_TABLES_I_ SOL_DEFAULT_OFF
+	#endif
+#endif
+
+// end of sol/compatibility/lua_version.hpp
+
+#if SOL_IS_ON(SOL_USE_COMPATIBILITY_LAYER)
+
+#if SOL_IS_ON(SOL_USE_CXX_LUA) || SOL_IS_ON(SOL_USE_CXX_LUAJIT)
+#ifndef COMPAT53_LUA_CPP
+#define COMPAT53_LUA_CPP 1
+#endif // Build Lua Compat layer as C++
+#endif
+#ifndef COMPAT53_INCLUDE_SOURCE
+#define COMPAT53_INCLUDE_SOURCE 1
+#endif // Build Compat Layer Inline
+
+// beginning of sol/compatibility/compat-5.3.h
+
+#ifndef KEPLER_PROJECT_COMPAT53_H_
+#define KEPLER_PROJECT_COMPAT53_H_
+
+#include <stddef.h>
+#include <limits.h>
+#include <string.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#ifndef COMPAT53_PREFIX
+/* we chose this name because many other lua bindings / libs have
+* their own compatibility layer, and that use the compat53 declaration
+* frequently, causing all kinds of linker / compiler issues
+*/
+#  define COMPAT53_PREFIX kp_compat53
+#endif // COMPAT53_PREFIX
+
+#ifndef COMPAT53_API
+#  if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE
+#    if defined(__GNUC__) || defined(__clang__)
+#      define COMPAT53_API __attribute__((__unused__)) static inline 
+#    else
+#      define COMPAT53_API static inline 
+#    endif /* Clang/GCC */
+#  else /* COMPAT53_INCLUDE_SOURCE */
+/* we are not including source, so everything is extern */
+#      define COMPAT53_API extern
+#  endif /* COMPAT53_INCLUDE_SOURCE */
+#endif /* COMPAT53_PREFIX */
+
+#define COMPAT53_CONCAT_HELPER(a, b) a##b
+#define COMPAT53_CONCAT(a, b) COMPAT53_CONCAT_HELPER(a, b)
+
+/* declarations for Lua 5.1 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+/* XXX not implemented:
+* lua_arith (new operators)
+* lua_upvalueid
+* lua_upvaluejoin
+* lua_version
+* lua_yieldk
+*/
+
+#ifndef LUA_OK
+#  define LUA_OK 0
+#endif
+#ifndef LUA_OPADD
+#  define LUA_OPADD 0
+#endif
+#ifndef LUA_OPSUB
+#  define LUA_OPSUB 1
+#endif
+#ifndef LUA_OPMUL
+#  define LUA_OPMUL 2
+#endif
+#ifndef LUA_OPDIV
+#  define LUA_OPDIV 3
+#endif
+#ifndef LUA_OPMOD
+#  define LUA_OPMOD 4
+#endif
+#ifndef LUA_OPPOW
+#  define LUA_OPPOW 5
+#endif
+#ifndef LUA_OPUNM
+#  define LUA_OPUNM 6
+#endif
+#ifndef LUA_OPEQ
+#  define LUA_OPEQ 0
+#endif
+#ifndef LUA_OPLT
+#  define LUA_OPLT 1
+#endif
+#ifndef LUA_OPLE
+#  define LUA_OPLE 2
+#endif
+
+/* LuaJIT/Lua 5.1 does not have the updated
+* error codes for thread status/function returns (but some patched versions do)
+* define it only if it's not found
+*/
+#if !defined(LUA_ERRGCMM)
+/* Use + 2 because in some versions of Lua (Lua 5.1)
+* LUA_ERRFILE is defined as (LUA_ERRERR+1)
+* so we need to avoid it (LuaJIT might have something at this
+* integer value too)
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#if !defined(MOONJIT_VERSION)
+typedef size_t lua_Unsigned;
+#endif
+
+typedef struct luaL_Buffer_53 {
+	luaL_Buffer b; /* make incorrect code crash! */
+	char *ptr;
+	size_t nelems;
+	size_t capacity;
+	lua_State *L2;
+} luaL_Buffer_53;
+#define luaL_Buffer luaL_Buffer_53
+
+/* In PUC-Rio 5.1, userdata is a simple FILE*
+* In LuaJIT, it's a struct where the first member is a FILE*
+* We can't support the `closef` member
+*/
+typedef struct luaL_Stream {
+	FILE *f;
+} luaL_Stream;
+
+#define lua_absindex COMPAT53_CONCAT(COMPAT53_PREFIX, _absindex)
+COMPAT53_API int lua_absindex(lua_State *L, int i);
+
+#define lua_arith COMPAT53_CONCAT(COMPAT53_PREFIX, _arith)
+COMPAT53_API void lua_arith(lua_State *L, int op);
+
+#define lua_compare COMPAT53_CONCAT(COMPAT53_PREFIX, _compare)
+COMPAT53_API int lua_compare(lua_State *L, int idx1, int idx2, int op);
+
+#define lua_copy COMPAT53_CONCAT(COMPAT53_PREFIX, _copy)
+COMPAT53_API void lua_copy(lua_State *L, int from, int to);
+
+#define lua_getuservalue(L, i) \
+  (lua_getfenv((L), (i)), lua_type((L), -1))
+#define lua_setuservalue(L, i) \
+  (luaL_checktype((L), -1, LUA_TTABLE), lua_setfenv((L), (i)))
+
+#define lua_len COMPAT53_CONCAT(COMPAT53_PREFIX, _len)
+COMPAT53_API void lua_len(lua_State *L, int i);
+
+#define lua_pushstring(L, s) \
+  (lua_pushstring((L), (s)), lua_tostring((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  ((((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len))), lua_tostring((L), -1))
+
+#ifndef luaL_newlibtable
+#  define luaL_newlibtable(L, l) \
+  (lua_createtable((L), 0, sizeof((l))/sizeof(*(l))-1))
+#endif
+#ifndef luaL_newlib
+#  define luaL_newlib(L, l) \
+  (luaL_newlibtable((L), (l)), luaL_register((L), NULL, (l)))
+#endif
+
+#ifndef lua_pushglobaltable
+#  define lua_pushglobaltable(L) \
+  lua_pushvalue((L), LUA_GLOBALSINDEX)
+#endif
+#define lua_rawgetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawgetp)
+COMPAT53_API int lua_rawgetp(lua_State *L, int i, const void *p);
+
+#define lua_rawsetp COMPAT53_CONCAT(COMPAT53_PREFIX, _rawsetp)
+COMPAT53_API void lua_rawsetp(lua_State *L, int i, const void *p);
+
+#define lua_rawlen(L, i) lua_objlen((L), (i))
+
+#define lua_tointeger(L, i) lua_tointegerx((L), (i), NULL)
+
+#define lua_tonumberx COMPAT53_CONCAT(COMPAT53_PREFIX, _tonumberx)
+COMPAT53_API lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
+
+#define luaL_checkversion COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkversion)
+COMPAT53_API void luaL_checkversion(lua_State *L);
+
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+COMPAT53_API int lua_load(lua_State *L, lua_Reader reader, void *data, const char* source, const char* mode);
+
+#define luaL_loadfilex COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadfilex)
+COMPAT53_API int luaL_loadfilex(lua_State *L, const char *filename, const char *mode);
+
+#define luaL_loadbufferx COMPAT53_CONCAT(COMPAT53_PREFIX, L_loadbufferx)
+COMPAT53_API int luaL_loadbufferx(lua_State *L, const char *buff, size_t sz, const char *name, const char *mode);
+
+#define luaL_checkstack COMPAT53_CONCAT(COMPAT53_PREFIX, L_checkstack_53)
+COMPAT53_API void luaL_checkstack(lua_State *L, int sp, const char *msg);
+
+#define luaL_getsubtable COMPAT53_CONCAT(COMPAT53_PREFIX, L_getsubtable)
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char *name);
+
+#define luaL_len COMPAT53_CONCAT(COMPAT53_PREFIX, L_len)
+COMPAT53_API lua_Integer luaL_len(lua_State *L, int i);
+
+#define luaL_setfuncs COMPAT53_CONCAT(COMPAT53_PREFIX, L_setfuncs)
+COMPAT53_API void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
+
+#define luaL_setmetatable COMPAT53_CONCAT(COMPAT53_PREFIX, L_setmetatable)
+COMPAT53_API void luaL_setmetatable(lua_State *L, const char *tname);
+
+#define luaL_testudata COMPAT53_CONCAT(COMPAT53_PREFIX, L_testudata)
+COMPAT53_API void *luaL_testudata(lua_State *L, int i, const char *tname);
+
+#define luaL_traceback COMPAT53_CONCAT(COMPAT53_PREFIX, L_traceback)
+COMPAT53_API void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
+
+#define luaL_fileresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_fileresult)
+COMPAT53_API int luaL_fileresult(lua_State *L, int stat, const char *fname);
+
+#define luaL_execresult COMPAT53_CONCAT(COMPAT53_PREFIX, L_execresult)
+COMPAT53_API int luaL_execresult(lua_State *L, int stat);
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_call((L), (na), (nr)))
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  ((void)(ctx), (void)(cont), lua_pcall((L), (na), (nr), (err)))
+
+#define lua_resume(L, from, nargs) \
+  ((void)(from), lua_resume((L), (nargs)))
+
+#define luaL_buffinit COMPAT53_CONCAT(COMPAT53_PREFIX, _buffinit_53)
+COMPAT53_API void luaL_buffinit(lua_State *L, luaL_Buffer_53 *B);
+
+#define luaL_prepbuffsize COMPAT53_CONCAT(COMPAT53_PREFIX, _prepbufsize_53)
+COMPAT53_API char *luaL_prepbuffsize(luaL_Buffer_53 *B, size_t s);
+
+#define luaL_addlstring COMPAT53_CONCAT(COMPAT53_PREFIX, _addlstring_53)
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53 *B, const char *s, size_t l);
+
+#define luaL_addvalue COMPAT53_CONCAT(COMPAT53_PREFIX, _addvalue_53)
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53 *B);
+
+#define luaL_pushresult COMPAT53_CONCAT(COMPAT53_PREFIX, _pushresult_53)
+COMPAT53_API void luaL_pushresult(luaL_Buffer_53 *B);
+
+#undef luaL_buffinitsize
+#define luaL_buffinitsize(L, B, s) \
+  (luaL_buffinit((L), (B)), luaL_prepbuffsize((B), (s)))
+
+#undef luaL_prepbuffer
+#define luaL_prepbuffer(B) \
+  luaL_prepbuffsize((B), LUAL_BUFFERSIZE)
+
+#undef luaL_addchar
+#define luaL_addchar(B, c) \
+  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize((B), 1)), \
+   ((B)->ptr[(B)->nelems++] = (c)))
+
+#undef luaL_addsize
+#define luaL_addsize(B, s) \
+  ((B)->nelems += (s))
+
+#undef luaL_addstring
+#define luaL_addstring(B, s) \
+  luaL_addlstring((B), (s), strlen((s)))
+
+#undef luaL_pushresultsize
+#define luaL_pushresultsize(B, s) \
+  (luaL_addsize((B), (s)), luaL_pushresult((B)))
+
+#if defined(LUA_COMPAT_APIINTCASTS)
+#define lua_pushunsigned(L, n) \
+  lua_pushinteger((L), (lua_Integer)(n))
+#define lua_tounsignedx(L, i, is) \
+  ((lua_Unsigned)lua_tointegerx((L), (i), (is)))
+#define lua_tounsigned(L, i) \
+  lua_tounsignedx((L), (i), NULL)
+#define luaL_checkunsigned(L, a) \
+  ((lua_Unsigned)luaL_checkinteger((L), (a)))
+#define luaL_optunsigned(L, a, d) \
+  ((lua_Unsigned)luaL_optinteger((L), (a), (lua_Integer)(d)))
+#endif
+
+#endif /* Lua 5.1 only */
+
+/* declarations for Lua 5.1 and 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+typedef int lua_KContext;
+
+typedef int(*lua_KFunction)(lua_State *L, int status, lua_KContext ctx);
+
+#define lua_dump(L, w, d, s) \
+  ((void)(s), lua_dump((L), (w), (d)))
+
+#define lua_getfield(L, i, k) \
+  (lua_getfield((L), (i), (k)), lua_type((L), -1))
+
+#define lua_gettable(L, i) \
+  (lua_gettable((L), (i)), lua_type((L), -1))
+
+#define lua_geti COMPAT53_CONCAT(COMPAT53_PREFIX, _geti)
+COMPAT53_API int lua_geti(lua_State *L, int index, lua_Integer i);
+
+#define lua_isinteger COMPAT53_CONCAT(COMPAT53_PREFIX, _isinteger)
+COMPAT53_API int lua_isinteger(lua_State *L, int index);
+
+#define lua_tointegerx COMPAT53_CONCAT(COMPAT53_PREFIX, _tointegerx_53)
+COMPAT53_API lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
+
+#define lua_numbertointeger(n, p) \
+  ((*(p) = (lua_Integer)(n)), 1)
+
+#define lua_rawget(L, i) \
+  (lua_rawget((L), (i)), lua_type((L), -1))
+
+#define lua_rawgeti(L, i, n) \
+  (lua_rawgeti((L), (i), (n)), lua_type((L), -1))
+
+#define lua_rotate COMPAT53_CONCAT(COMPAT53_PREFIX, _rotate)
+COMPAT53_API void lua_rotate(lua_State *L, int idx, int n);
+
+#define lua_seti COMPAT53_CONCAT(COMPAT53_PREFIX, _seti)
+COMPAT53_API void lua_seti(lua_State *L, int index, lua_Integer i);
+
+#define lua_stringtonumber COMPAT53_CONCAT(COMPAT53_PREFIX, _stringtonumber)
+COMPAT53_API size_t lua_stringtonumber(lua_State *L, const char *s);
+
+#define luaL_tolstring COMPAT53_CONCAT(COMPAT53_PREFIX, L_tolstring)
+COMPAT53_API const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
+
+#define luaL_getmetafield(L, o, e) \
+  (luaL_getmetafield((L), (o), (e)) ? lua_type((L), -1) : LUA_TNIL)
+
+#define luaL_newmetatable(L, tn) \
+  (luaL_newmetatable((L), (tn)) ? (lua_pushstring((L), (tn)), lua_setfield((L), -2, "__name"), 1) : 0)
+
+#define luaL_requiref COMPAT53_CONCAT(COMPAT53_PREFIX, L_requiref_53)
+COMPAT53_API void luaL_requiref(lua_State *L, const char *modname,
+	lua_CFunction openf, int glb);
+
+#endif /* Lua 5.1 and Lua 5.2 */
+
+/* declarations for Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 502
+
+/* XXX not implemented:
+* lua_isyieldable
+* lua_getextraspace
+* lua_arith (new operators)
+* lua_pushfstring (new formats)
+*/
+
+#define lua_getglobal(L, n) \
+  (lua_getglobal((L), (n)), lua_type((L), -1))
+
+#define lua_getuservalue(L, i) \
+  (lua_getuservalue((L), (i)), lua_type((L), -1))
+
+#define lua_pushlstring(L, s, len) \
+  (((len) == 0) ? lua_pushlstring((L), "", 0) : lua_pushlstring((L), (s), (len)))
+
+#define lua_rawgetp(L, i, p) \
+  (lua_rawgetp((L), (i), (p)), lua_type((L), -1))
+
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx); \
+  static int (_name ## _52)(lua_State *L) { \
+    lua_KContext ctx; \
+    int status = lua_getctx(L, &ctx); \
+    return (_name)(L, status, ctx); \
+  } \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+
+#define lua_pcallk(L, na, nr, err, ctx, cont) \
+  lua_pcallk((L), (na), (nr), (err), (ctx), cont ## _52)
+
+#define lua_callk(L, na, nr, ctx, cont) \
+  lua_callk((L), (na), (nr), (ctx), cont ## _52)
+
+#define lua_yieldk(L, nr, ctx, cont) \
+  lua_yieldk((L), (nr), (ctx), cont ## _52)
+
+#ifdef lua_call
+#  undef lua_call
+#  define lua_call(L, na, nr) \
+  (lua_callk)((L), (na), (nr), 0, NULL)
+#endif
+
+#ifdef lua_pcall
+#  undef lua_pcall
+#  define lua_pcall(L, na, nr, err) \
+  (lua_pcallk)((L), (na), (nr), (err), 0, NULL)
+#endif
+
+#ifdef lua_yield
+#  undef lua_yield
+#  define lua_yield(L, nr) \
+  (lua_yieldk)((L), (nr), 0, NULL)
+#endif
+
+#endif /* Lua 5.2 only */
+
+/* other Lua versions */
+#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 || LUA_VERSION_NUM > 504
+
+#  error "unsupported Lua version (i.e. not Lua 5.1, 5.2, 5.3, or 5.4)"
+
+#endif /* other Lua versions except 5.1, 5.2, 5.3, and 5.4 */
+
+/* helper macro for defining continuation functions (for every version
+* *except* Lua 5.2) */
+#ifndef LUA_KFUNCTION
+#define LUA_KFUNCTION(_name) \
+  static int (_name)(lua_State *L, int status, lua_KContext ctx)
+#endif
+
+#if defined(COMPAT53_INCLUDE_SOURCE) && COMPAT53_INCLUDE_SOURCE == 1
+// beginning of sol/compatibility/compat-5.3.c.h
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+
+/* don't compile it again if it already is included via compat53.h */
+#ifndef KEPLER_PROJECT_COMPAT53_C_
+#define KEPLER_PROJECT_COMPAT53_C_
+
+/* definitions for Lua 5.1 only */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
+
+#ifndef COMPAT53_FOPEN_NO_LOCK
+#if defined(_MSC_VER)
+#define COMPAT53_FOPEN_NO_LOCK 1
+#else /* otherwise */
+#define COMPAT53_FOPEN_NO_LOCK 0
+#endif /* VC++ only so far */
+#endif /* No-lock fopen_s usage if possible */
+
+#if defined(_MSC_VER) && COMPAT53_FOPEN_NO_LOCK
+#include <share.h>
+#endif /* VC++ _fsopen for share-allowed file read */
+
+#ifndef COMPAT53_HAVE_STRERROR_R
+#if defined(__GLIBC__) || defined(_POSIX_VERSION) || defined(__APPLE__) || (!defined(__MINGW32__) && defined(__GNUC__) && (__GNUC__ < 6))
+#define COMPAT53_HAVE_STRERROR_R 1
+#else /* none of the defines matched: define to 0 */
+#define COMPAT53_HAVE_STRERROR_R 0
+#endif /* have strerror_r of some form */
+#endif /* strerror_r */
+
+#ifndef COMPAT53_HAVE_STRERROR_S
+#if defined(_MSC_VER) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || (defined(__STDC_LIB_EXT1__) && __STDC_LIB_EXT1__)
+#define COMPAT53_HAVE_STRERROR_S 1
+#else /* not VC++ or C11 */
+#define COMPAT53_HAVE_STRERROR_S 0
+#endif /* strerror_s from VC++ or C11 */
+#endif /* strerror_s */
+
+#ifndef COMPAT53_LUA_FILE_BUFFER_SIZE
+#define COMPAT53_LUA_FILE_BUFFER_SIZE 4096
+#endif /* Lua File Buffer Size */
+
+static char* compat53_strerror(int en, char* buff, size_t sz) {
+#if COMPAT53_HAVE_STRERROR_R
+	/* use strerror_r here, because it's available on these specific platforms */
+	if (sz > 0) {
+		buff[0] = '\0';
+		/* we don't care whether the GNU version or the XSI version is used: */
+		if (strerror_r(en, buff, sz)) {
+			/* Yes, we really DO want to ignore the return value!
+			 * GCC makes that extra hard, not even a (void) cast will do. */
+		}
+		if (buff[0] == '\0') {
+			/* Buffer is unchanged, so we probably have called GNU strerror_r which
+			 * returned a static constant string. Chances are that strerror will
+			 * return the same static constant string and therefore be thread-safe. */
+			return strerror(en);
+		}
+	}
+	return buff; /* sz is 0 *or* strerror_r wrote into the buffer */
+#elif COMPAT53_HAVE_STRERROR_S
+	/* for MSVC and other C11 implementations, use strerror_s since it's
+	 * provided by default by the libraries */
+	strerror_s(buff, sz, en);
+	return buff;
+#else
+	/* fallback, but strerror is not guaranteed to be threadsafe due to modifying
+	 * errno itself and some impls not locking a static buffer for it ... but most
+	 * known systems have threadsafe errno: this might only change if the locale
+	 * is changed out from under someone while this function is being called */
+	(void)buff;
+	(void)sz;
+	return strerror(en);
+#endif
+}
+
+COMPAT53_API int lua_absindex(lua_State* L, int i) {
+	if (i < 0 && i > LUA_REGISTRYINDEX)
+		i += lua_gettop(L) + 1;
+	return i;
+}
+
+static void compat53_call_lua(lua_State* L, char const code[], size_t len, int nargs, int nret) {
+	lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
+	if (lua_type(L, -1) != LUA_TFUNCTION) {
+		lua_pop(L, 1);
+		if (luaL_loadbuffer(L, code, len, "=none"))
+			lua_error(L);
+		lua_pushvalue(L, -1);
+		lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
+	}
+	lua_insert(L, -nargs - 1);
+	lua_call(L, nargs, nret);
+}
+
+COMPAT53_API void lua_arith(lua_State* L, int op) {
+	static const char compat53_arith_code[]
+	     = "local op,a,b=...\n"
+	       "if op==0 then return a+b\n"
+	       "elseif op==1 then return a-b\n"
+	       "elseif op==2 then return a*b\n"
+	       "elseif op==3 then return a/b\n"
+	       "elseif op==4 then return a%b\n"
+	       "elseif op==5 then return a^b\n"
+	       "elseif op==6 then return -a\n"
+	       "end\n";
+
+	if (op < LUA_OPADD || op > LUA_OPUNM)
+		luaL_error(L, "invalid 'op' argument for lua_arith");
+	luaL_checkstack(L, 5, "not enough stack slots");
+	if (op == LUA_OPUNM)
+		lua_pushvalue(L, -1);
+	lua_pushnumber(L, op);
+	lua_insert(L, -3);
+	compat53_call_lua(L, compat53_arith_code, sizeof(compat53_arith_code) - 1, 3, 1);
+}
+
+COMPAT53_API int lua_compare(lua_State* L, int idx1, int idx2, int op) {
+	static const char compat53_compare_code[]
+	     = "local a,b=...\n"
+	       "return a<=b\n";
+
+	int result = 0;
+	switch (op) {
+	case LUA_OPEQ:
+		return lua_equal(L, idx1, idx2);
+	case LUA_OPLT:
+		return lua_lessthan(L, idx1, idx2);
+	case LUA_OPLE:
+		luaL_checkstack(L, 5, "not enough stack slots");
+		idx1 = lua_absindex(L, idx1);
+		idx2 = lua_absindex(L, idx2);
+		lua_pushvalue(L, idx1);
+		lua_pushvalue(L, idx2);
+		compat53_call_lua(L, compat53_compare_code, sizeof(compat53_compare_code) - 1, 2, 1);
+		result = lua_toboolean(L, -1);
+		lua_pop(L, 1);
+		return result;
+	default:
+		luaL_error(L, "invalid 'op' argument for lua_compare");
+	}
+	return 0;
+}
+
+COMPAT53_API void lua_copy(lua_State* L, int from, int to) {
+	int abs_to = lua_absindex(L, to);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushvalue(L, from);
+	lua_replace(L, abs_to);
+}
+
+COMPAT53_API void lua_len(lua_State* L, int i) {
+	switch (lua_type(L, i)) {
+	case LUA_TSTRING:
+		lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TTABLE:
+		if (!luaL_callmeta(L, i, "__len"))
+			lua_pushnumber(L, (lua_Number)lua_objlen(L, i));
+		break;
+	case LUA_TUSERDATA:
+		if (luaL_callmeta(L, i, "__len"))
+			break;
+		/* FALLTHROUGH */
+	default:
+		luaL_error(L, "attempt to get length of a %s value", lua_typename(L, lua_type(L, i)));
+	}
+}
+
+COMPAT53_API int lua_rawgetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	lua_pushlightuserdata(L, (void*)p);
+	lua_rawget(L, abs_i);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API void lua_rawsetp(lua_State* L, int i, const void* p) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_pushlightuserdata(L, (void*)p);
+	lua_insert(L, -2);
+	lua_rawset(L, abs_i);
+}
+
+COMPAT53_API lua_Number lua_tonumberx(lua_State* L, int i, int* isnum) {
+	lua_Number n = lua_tonumber(L, i);
+	if (isnum != NULL) {
+		*isnum = (n != 0 || lua_isnumber(L, i));
+	}
+	return n;
+}
+
+COMPAT53_API void luaL_checkversion(lua_State* L) {
+	(void)L;
+}
+
+COMPAT53_API void luaL_checkstack(lua_State* L, int sp, const char* msg) {
+	if (!lua_checkstack(L, sp + LUA_MINSTACK)) {
+		if (msg != NULL)
+			luaL_error(L, "stack overflow (%s)", msg);
+		else {
+			lua_pushliteral(L, "stack overflow");
+			lua_error(L);
+		}
+	}
+}
+
+COMPAT53_API int luaL_getsubtable(lua_State* L, int i, const char* name) {
+	int abs_i = lua_absindex(L, i);
+	luaL_checkstack(L, 3, "not enough stack slots");
+	lua_pushstring(L, name);
+	lua_gettable(L, abs_i);
+	if (lua_istable(L, -1))
+		return 1;
+	lua_pop(L, 1);
+	lua_newtable(L);
+	lua_pushstring(L, name);
+	lua_pushvalue(L, -2);
+	lua_settable(L, abs_i);
+	return 0;
+}
+
+COMPAT53_API lua_Integer luaL_len(lua_State* L, int i) {
+	lua_Integer res = 0;
+	int isnum = 0;
+	luaL_checkstack(L, 1, "not enough stack slots");
+	lua_len(L, i);
+	res = lua_tointegerx(L, -1, &isnum);
+	lua_pop(L, 1);
+	if (!isnum)
+		luaL_error(L, "object length is not an integer");
+	return res;
+}
+
+COMPAT53_API void luaL_setfuncs(lua_State* L, const luaL_Reg* l, int nup) {
+	luaL_checkstack(L, nup + 1, "too many upvalues");
+	for (; l->name != NULL; l++) { /* fill the table with given functions */
+		int i;
+		lua_pushstring(L, l->name);
+		for (i = 0; i < nup; i++) /* copy upvalues to the top */
+			lua_pushvalue(L, -(nup + 1));
+		lua_pushcclosure(L, l->func, nup); /* closure with those upvalues */
+		lua_settable(L, -(nup + 3));       /* table must be below the upvalues, the name and the closure */
+	}
+	lua_pop(L, nup); /* remove upvalues */
+}
+
+COMPAT53_API void luaL_setmetatable(lua_State* L, const char* tname) {
+	luaL_checkstack(L, 1, "not enough stack slots");
+	luaL_getmetatable(L, tname);
+	lua_setmetatable(L, -2);
+}
+
+COMPAT53_API void* luaL_testudata(lua_State* L, int i, const char* tname) {
+	void* p = lua_touserdata(L, i);
+	luaL_checkstack(L, 2, "not enough stack slots");
+	if (p == NULL || !lua_getmetatable(L, i))
+		return NULL;
+	else {
+		int res = 0;
+		luaL_getmetatable(L, tname);
+		res = lua_rawequal(L, -1, -2);
+		lua_pop(L, 2);
+		if (!res)
+			p = NULL;
+	}
+	return p;
+}
+
+static int compat53_countlevels(lua_State* L) {
+	lua_Debug ar;
+	int li = 1, le = 1;
+	/* find an upper bound */
+	while (lua_getstack(L, le, &ar)) {
+		li = le;
+		le *= 2;
+	}
+	/* do a binary search */
+	while (li < le) {
+		int m = (li + le) / 2;
+		if (lua_getstack(L, m, &ar))
+			li = m + 1;
+		else
+			le = m;
+	}
+	return le - 1;
+}
+
+static int compat53_findfield(lua_State* L, int objidx, int level) {
+	if (level == 0 || !lua_istable(L, -1))
+		return 0;                               /* not found */
+	lua_pushnil(L);                              /* start 'next' loop */
+	while (lua_next(L, -2)) {                    /* for each pair in table */
+		if (lua_type(L, -2) == LUA_TSTRING) {   /* ignore non-string keys */
+			if (lua_rawequal(L, objidx, -1)) { /* found object? */
+				lua_pop(L, 1);                /* remove value (but keep name) */
+				return 1;
+			}
+			else if (compat53_findfield(L, objidx, level - 1)) { /* try recursively */
+				lua_remove(L, -2);                              /* remove table (but keep name) */
+				lua_pushliteral(L, ".");
+				lua_insert(L, -2); /* place '.' between the two names */
+				lua_concat(L, 3);
+				return 1;
+			}
+		}
+		lua_pop(L, 1); /* remove value */
+	}
+	return 0; /* not found */
+}
+
+static int compat53_pushglobalfuncname(lua_State* L, lua_Debug* ar) {
+	int top = lua_gettop(L);
+	lua_getinfo(L, "f", ar); /* push function */
+	lua_pushvalue(L, LUA_GLOBALSINDEX);
+	if (compat53_findfield(L, top + 1, 2)) {
+		lua_copy(L, -1, top + 1); /* move name to proper place */
+		lua_pop(L, 2);            /* remove pushed values */
+		return 1;
+	}
+	else {
+		lua_settop(L, top); /* remove function and global table */
+		return 0;
+	}
+}
+
+static void compat53_pushfuncname(lua_State* L, lua_Debug* ar) {
+	if (*ar->namewhat != '\0') /* is there a name? */
+		lua_pushfstring(L, "function " LUA_QS, ar->name);
+	else if (*ar->what == 'm') /* main? */
+		lua_pushliteral(L, "main chunk");
+	else if (*ar->what == 'C') {
+		if (compat53_pushglobalfuncname(L, ar)) {
+			lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
+			lua_remove(L, -2); /* remove name */
+		}
+		else
+			lua_pushliteral(L, "?");
+	}
+	else
+		lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
+}
+
+#define COMPAT53_LEVELS1 12 /* size of the first part of the stack */
+#define COMPAT53_LEVELS2 10 /* size of the second part of the stack */
+
+COMPAT53_API void luaL_traceback(lua_State* L, lua_State* L1, const char* msg, int level) {
+	lua_Debug ar;
+	int top = lua_gettop(L);
+	int numlevels = compat53_countlevels(L1);
+	int mark = (numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2) ? COMPAT53_LEVELS1 : 0;
+	if (msg)
+		lua_pushfstring(L, "%s\n", msg);
+	lua_pushliteral(L, "stack traceback:");
+	while (lua_getstack(L1, level++, &ar)) {
+		if (level == mark) {                       /* too many levels? */
+			lua_pushliteral(L, "\n\t...");        /* add a '...' */
+			level = numlevels - COMPAT53_LEVELS2; /* and skip to last ones */
+		}
+		else {
+			lua_getinfo(L1, "Slnt", &ar);
+			lua_pushfstring(L, "\n\t%s:", ar.short_src);
+			if (ar.currentline > 0)
+				lua_pushfstring(L, "%d:", ar.currentline);
+			lua_pushliteral(L, " in ");
+			compat53_pushfuncname(L, &ar);
+			lua_concat(L, lua_gettop(L) - top);
+		}
+	}
+	lua_concat(L, lua_gettop(L) - top);
+}
+
+COMPAT53_API int luaL_fileresult(lua_State* L, int stat, const char* fname) {
+	const char* serr = NULL;
+	int en = errno; /* calls to Lua API may change this value */
+	char buf[512] = { 0 };
+	if (stat) {
+		lua_pushboolean(L, 1);
+		return 1;
+	}
+	else {
+		lua_pushnil(L);
+		serr = compat53_strerror(en, buf, sizeof(buf));
+		if (fname)
+			lua_pushfstring(L, "%s: %s", fname, serr);
+		else
+			lua_pushstring(L, serr);
+		lua_pushnumber(L, (lua_Number)en);
+		return 3;
+	}
+}
+
+static int compat53_checkmode(lua_State* L, const char* mode, const char* modename, int err) {
+	if (mode && strchr(mode, modename[0]) == NULL) {
+		lua_pushfstring(L, "attempt to load a %s chunk (mode is '%s')", modename, mode);
+		return err;
+	}
+	return LUA_OK;
+}
+
+typedef struct {
+	lua_Reader reader;
+	void* ud;
+	int has_peeked_data;
+	const char* peeked_data;
+	size_t peeked_data_size;
+} compat53_reader_data;
+
+static const char* compat53_reader(lua_State* L, void* ud, size_t* size) {
+	compat53_reader_data* data = (compat53_reader_data*)ud;
+	if (data->has_peeked_data) {
+		data->has_peeked_data = 0;
+		*size = data->peeked_data_size;
+		return data->peeked_data;
+	}
+	else
+		return data->reader(L, data->ud, size);
+}
+
+COMPAT53_API int lua_load(lua_State* L, lua_Reader reader, void* data, const char* source, const char* mode) {
+	int status = LUA_OK;
+	compat53_reader_data compat53_data = { reader, data, 1, 0, 0 };
+	compat53_data.peeked_data = reader(L, data, &(compat53_data.peeked_data_size));
+	if (compat53_data.peeked_data && compat53_data.peeked_data_size && compat53_data.peeked_data[0] == LUA_SIGNATURE[0]) /* binary file? */
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	else
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	if (status != LUA_OK)
+		return status;
+		/* we need to call the original 5.1 version of lua_load! */
+#undef lua_load
+	return lua_load(L, compat53_reader, &compat53_data, source);
+#define lua_load COMPAT53_CONCAT(COMPAT53_PREFIX, _load_53)
+}
+
+typedef struct {
+	int n;                                    /* number of pre-read characters */
+	FILE* f;                                  /* file being read */
+	char buff[COMPAT53_LUA_FILE_BUFFER_SIZE]; /* area for reading file */
+} compat53_LoadF;
+
+static const char* compat53_getF(lua_State* L, void* ud, size_t* size) {
+	compat53_LoadF* lf = (compat53_LoadF*)ud;
+	(void)L;            /* not used */
+	if (lf->n > 0) {    /* are there pre-read characters to be read? */
+		*size = lf->n; /* return them (chars already in buffer) */
+		lf->n = 0;     /* no more pre-read characters */
+	}
+	else { /* read a block from file */
+		  /* 'fread' can return > 0 *and* set the EOF flag. If next call to
+		  'compat53_getF' called 'fread', it might still wait for user input.
+		  The next check avoids this problem. */
+		if (feof(lf->f))
+			return NULL;
+		*size = fread(lf->buff, 1, sizeof(lf->buff), lf->f); /* read block */
+	}
+	return lf->buff;
+}
+
+static int compat53_errfile(lua_State* L, const char* what, int fnameindex) {
+	char buf[512] = { 0 };
+	const char* serr = compat53_strerror(errno, buf, sizeof(buf));
+	const char* filename = lua_tostring(L, fnameindex) + 1;
+	lua_pushfstring(L, "cannot %s %s: %s", what, filename, serr);
+	lua_remove(L, fnameindex);
+	return LUA_ERRFILE;
+}
+
+static int compat53_skipBOM(compat53_LoadF* lf) {
+	const char* p = "\xEF\xBB\xBF"; /* UTF-8 BOM mark */
+	int c;
+	lf->n = 0;
+	do {
+		c = getc(lf->f);
+		if (c == EOF || c != *(const unsigned char*)p++)
+			return c;
+		lf->buff[lf->n++] = (char)c; /* to be read by the parser */
+	} while (*p != '\0');
+	lf->n = 0;          /* prefix matched; discard it */
+	return getc(lf->f); /* return next character */
+}
+
+/*
+** reads the first character of file 'f' and skips an optional BOM mark
+** in its beginning plus its first line if it starts with '#'. Returns
+** true if it skipped the first line.  In any case, '*cp' has the
+** first "valid" character of the file (after the optional BOM and
+** a first-line comment).
+*/
+static int compat53_skipcomment(compat53_LoadF* lf, int* cp) {
+	int c = *cp = compat53_skipBOM(lf);
+	if (c == '#') { /* first line is a comment (Unix exec. file)? */
+		do {       /* skip first line */
+			c = getc(lf->f);
+		} while (c != EOF && c != '\n');
+		*cp = getc(lf->f); /* skip end-of-line, if present */
+		return 1;          /* there was a comment */
+	}
+	else
+		return 0; /* no comment */
+}
+
+COMPAT53_API int luaL_loadfilex(lua_State* L, const char* filename, const char* mode) {
+	compat53_LoadF lf;
+	int status, readstatus;
+	int c;
+	int fnameindex = lua_gettop(L) + 1; /* index of filename on the stack */
+	if (filename == NULL) {
+		lua_pushliteral(L, "=stdin");
+		lf.f = stdin;
+	}
+	else {
+		lua_pushfstring(L, "@%s", filename);
+#if defined(_MSC_VER)
+		/* This code is here to stop a deprecation error that stops builds
+		 * if a certain macro is defined. While normally not caring would
+		 * be best, some header-only libraries and builds can't afford to
+		 * dictate this to the user. A quick check shows that fopen_s this
+		 * goes back to VS 2005, and _fsopen goes back to VS 2003 .NET,
+		 * possibly even before that so we don't need to do any version
+		 * number checks, since this has been there since forever.  */
+
+		/* TO USER: if you want the behavior of typical fopen_s/fopen,
+		 * which does lock the file on VC++, define the macro used below to 0 */
+#if COMPAT53_FOPEN_NO_LOCK
+		lf.f = _fsopen(filename, "r", _SH_DENYNO); /* do not lock the file in any way */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#else  /* use default locking version */
+		if (fopen_s(&lf.f, filename, "r") != 0)
+			return compat53_errfile(L, "open", fnameindex);
+#endif /* Locking vs. No-locking fopen variants */
+#else
+		lf.f = fopen(filename, "r"); /* default stdlib doesn't forcefully lock files here */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "open", fnameindex);
+#endif
+	}
+	if (compat53_skipcomment(&lf, &c))       /* read initial portion */
+		lf.buff[lf.n++] = '\n';             /* add line to correct line numbers */
+	if (c == LUA_SIGNATURE[0] && filename) { /* binary file? */
+#if defined(_MSC_VER)
+		if (freopen_s(&lf.f, filename, "rb", lf.f) != 0)
+			return compat53_errfile(L, "reopen", fnameindex);
+#else
+		lf.f = freopen(filename, "rb", lf.f); /* reopen in binary mode */
+		if (lf.f == NULL)
+			return compat53_errfile(L, "reopen", fnameindex);
+#endif
+		compat53_skipcomment(&lf, &c); /* re-read initial portion */
+	}
+	if (c != EOF)
+		lf.buff[lf.n++] = (char)c; /* 'c' is the first character of the stream */
+	status = lua_load(L, &compat53_getF, &lf, lua_tostring(L, -1), mode);
+	readstatus = ferror(lf.f);
+	if (filename)
+		fclose(lf.f); /* close file (even in case of errors) */
+	if (readstatus) {
+		lua_settop(L, fnameindex); /* ignore results from 'lua_load' */
+		return compat53_errfile(L, "read", fnameindex);
+	}
+	lua_remove(L, fnameindex);
+	return status;
+}
+
+COMPAT53_API int luaL_loadbufferx(lua_State* L, const char* buff, size_t sz, const char* name, const char* mode) {
+	int status = LUA_OK;
+	if (sz > 0 && buff[0] == LUA_SIGNATURE[0]) {
+		status = compat53_checkmode(L, mode, "binary", LUA_ERRSYNTAX);
+	}
+	else {
+		status = compat53_checkmode(L, mode, "text", LUA_ERRSYNTAX);
+	}
+	if (status != LUA_OK)
+		return status;
+	return luaL_loadbuffer(L, buff, sz, name);
+}
+
+#if !defined(l_inspectstat) \
+     && (defined(unix) || defined(__unix) || defined(__unix__) || defined(__TOS_AIX__) || defined(_SYSTYPE_BSD) || (defined(__APPLE__) && defined(__MACH__)))
+/* some form of unix; check feature macros in unistd.h for details */
+#include <unistd.h>
+/* check posix version; the relevant include files and macros probably
+ * were available before 2001, but I'm not sure */
+#if defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112L
+#include <sys/wait.h>
+#define l_inspectstat(stat, what)   \
+	if (WIFEXITED(stat)) {         \
+		stat = WEXITSTATUS(stat); \
+	}                              \
+	else if (WIFSIGNALED(stat)) {  \
+		stat = WTERMSIG(stat);    \
+		what = "signal";          \
+	}
+#endif
+#endif
+
+/* provide default (no-op) version */
+#if !defined(l_inspectstat)
+#define l_inspectstat(stat, what) ((void)0)
+#endif
+
+COMPAT53_API int luaL_execresult(lua_State* L, int stat) {
+	const char* what = "exit";
+	if (stat == -1)
+		return luaL_fileresult(L, 0, NULL);
+	else {
+		l_inspectstat(stat, what);
+		if (*what == 'e' && stat == 0)
+			lua_pushboolean(L, 1);
+		else
+			lua_pushnil(L);
+		lua_pushstring(L, what);
+		lua_pushinteger(L, stat);
+		return 3;
+	}
+}
+
+COMPAT53_API void luaL_buffinit(lua_State* L, luaL_Buffer_53* B) {
+	/* make it crash if used via pointer to a 5.1-style luaL_Buffer */
+	B->b.p = NULL;
+	B->b.L = NULL;
+	B->b.lvl = 0;
+	/* reuse the buffer from the 5.1-style luaL_Buffer though! */
+	B->ptr = B->b.buffer;
+	B->capacity = LUAL_BUFFERSIZE;
+	B->nelems = 0;
+	B->L2 = L;
+}
+
+COMPAT53_API char* luaL_prepbuffsize(luaL_Buffer_53* B, size_t s) {
+	if (B->capacity - B->nelems < s) { /* needs to grow */
+		char* newptr = NULL;
+		size_t newcap = B->capacity * 2;
+		if (newcap - B->nelems < s)
+			newcap = B->nelems + s;
+		if (newcap < B->capacity) /* overflow */
+			luaL_error(B->L2, "buffer too large");
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 504
+		newptr = (char*)lua_newuserdatauv(B->L2, newcap, 0);
+#else
+		newptr = (char*)lua_newuserdata(B->L2, newcap);
+#endif
+		memcpy(newptr, B->ptr, B->nelems);
+		if (B->ptr != B->b.buffer)
+			lua_replace(B->L2, -2); /* remove old buffer */
+		B->ptr = newptr;
+		B->capacity = newcap;
+	}
+	return B->ptr + B->nelems;
+}
+
+COMPAT53_API void luaL_addlstring(luaL_Buffer_53* B, const char* s, size_t l) {
+	memcpy(luaL_prepbuffsize(B, l), s, l);
+	luaL_addsize(B, l);
+}
+
+COMPAT53_API void luaL_addvalue(luaL_Buffer_53* B) {
+	size_t len = 0;
+	const char* s = lua_tolstring(B->L2, -1, &len);
+	if (!s)
+		luaL_error(B->L2, "cannot convert value to string");
+	if (B->ptr != B->b.buffer)
+		lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
+	luaL_addlstring(B, s, len);
+	lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
+}
+
+void luaL_pushresult(luaL_Buffer_53* B) {
+	lua_pushlstring(B->L2, B->ptr, B->nelems);
+	if (B->ptr != B->b.buffer)
+		lua_replace(B->L2, -2); /* remove userdata buffer */
+}
+
+#endif /* Lua 5.1 */
+
+/* definitions for Lua 5.1 and Lua 5.2 */
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM <= 502
+
+COMPAT53_API int lua_geti(lua_State* L, int index, lua_Integer i) {
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_gettable(L, index);
+	return lua_type(L, -1);
+}
+
+COMPAT53_API int lua_isinteger(lua_State* L, int index) {
+	if (lua_type(L, index) == LUA_TNUMBER) {
+		lua_Number n = lua_tonumber(L, index);
+		lua_Integer i = lua_tointeger(L, index);
+		if (i == n)
+			return 1;
+	}
+	return 0;
+}
+
+COMPAT53_API lua_Integer lua_tointegerx(lua_State* L, int i, int* isnum) {
+	int ok = 0;
+	lua_Number n = lua_tonumberx(L, i, &ok);
+	if (ok) {
+		if (n == (lua_Integer)n) {
+			if (isnum)
+				*isnum = 1;
+			return (lua_Integer)n;
+		}
+	}
+	if (isnum)
+		*isnum = 0;
+	return 0;
+}
+
+static void compat53_reverse(lua_State* L, int a, int b) {
+	for (; a < b; ++a, --b) {
+		lua_pushvalue(L, a);
+		lua_pushvalue(L, b);
+		lua_replace(L, a);
+		lua_replace(L, b);
+	}
+}
+
+COMPAT53_API void lua_rotate(lua_State* L, int idx, int n) {
+	int n_elems = 0;
+	idx = lua_absindex(L, idx);
+	n_elems = lua_gettop(L) - idx + 1;
+	if (n < 0)
+		n += n_elems;
+	if (n > 0 && n < n_elems) {
+		luaL_checkstack(L, 2, "not enough stack slots available");
+		n = n_elems - n;
+		compat53_reverse(L, idx, idx + n - 1);
+		compat53_reverse(L, idx + n, idx + n_elems - 1);
+		compat53_reverse(L, idx, idx + n_elems - 1);
+	}
+}
+
+COMPAT53_API void lua_seti(lua_State* L, int index, lua_Integer i) {
+	luaL_checkstack(L, 1, "not enough stack slots available");
+	index = lua_absindex(L, index);
+	lua_pushinteger(L, i);
+	lua_insert(L, -2);
+	lua_settable(L, index);
+}
+
+#if !defined(lua_str2number)
+#define lua_str2number(s, p) strtod((s), (p))
+#endif
+
+COMPAT53_API size_t lua_stringtonumber(lua_State* L, const char* s) {
+	char* endptr;
+	lua_Number n = lua_str2number(s, &endptr);
+	if (endptr != s) {
+		while (*endptr != '\0' && isspace((unsigned char)*endptr))
+			++endptr;
+		if (*endptr == '\0') {
+			lua_pushnumber(L, n);
+			return endptr - s + 1;
+		}
+	}
+	return 0;
+}
+
+COMPAT53_API const char* luaL_tolstring(lua_State* L, int idx, size_t* len) {
+	if (!luaL_callmeta(L, idx, "__tostring")) {
+		int t = lua_type(L, idx), tt = 0;
+		char const* name = NULL;
+		switch (t) {
+		case LUA_TNIL:
+			lua_pushliteral(L, "nil");
+			break;
+		case LUA_TSTRING:
+		case LUA_TNUMBER:
+			lua_pushvalue(L, idx);
+			break;
+		case LUA_TBOOLEAN:
+			if (lua_toboolean(L, idx))
+				lua_pushliteral(L, "true");
+			else
+				lua_pushliteral(L, "false");
+			break;
+		default:
+			tt = luaL_getmetafield(L, idx, "__name");
+			name = (tt == LUA_TSTRING) ? lua_tostring(L, -1) : lua_typename(L, t);
+			lua_pushfstring(L, "%s: %p", name, lua_topointer(L, idx));
+			if (tt != LUA_TNIL)
+				lua_replace(L, -2);
+			break;
+		}
+	}
+	else {
+		if (!lua_isstring(L, -1))
+			luaL_error(L, "'__tostring' must return a string");
+	}
+	return lua_tolstring(L, -1, len);
+}
+
+COMPAT53_API void luaL_requiref(lua_State* L, const char* modname, lua_CFunction openf, int glb) {
+	luaL_checkstack(L, 3, "not enough stack slots available");
+	luaL_getsubtable(L, LUA_REGISTRYINDEX, "_LOADED");
+	if (lua_getfield(L, -1, modname) == LUA_TNIL) {
+		lua_pop(L, 1);
+		lua_pushcfunction(L, openf);
+		lua_pushstring(L, modname);
+		lua_call(L, 1, 1);
+		lua_pushvalue(L, -1);
+		lua_setfield(L, -3, modname);
+	}
+	if (glb) {
+		lua_pushvalue(L, -1);
+		lua_setglobal(L, modname);
+	}
+	lua_replace(L, -2);
+}
+
+#endif /* Lua 5.1 and 5.2 */
+
+#endif /* KEPLER_PROJECT_COMPAT53_C_ */
+
+/*********************************************************************
+ * This file contains parts of Lua 5.2's and Lua 5.3's source code:
+ *
+ * Copyright (C) 1994-2014 Lua.org, PUC-Rio.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *********************************************************************/
+// end of sol/compatibility/compat-5.3.c.h
+
+#endif
+
+#endif /* KEPLER_PROJECT_COMPAT53_H_ */
+
+// end of sol/compatibility/compat-5.3.h
+
+// beginning of sol/compatibility/compat-5.4.h
+
+#ifndef NOT_KEPLER_PROJECT_COMPAT54_H_
+#define NOT_KEPLER_PROJECT_COMPAT54_H_
+
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+extern "C" {
+#endif
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+#if defined(__cplusplus) && !defined(COMPAT53_LUA_CPP)
+}
+#endif
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 504
+
+#if !defined(LUA_ERRGCMM)
+/* So Lua 5.4 actually removes this, which breaks sol2...
+ man, this API is quite unstable...!
+*/
+#  define LUA_ERRGCMM (LUA_ERRERR + 2)
+#endif /* LUA_ERRGCMM define */
+
+#endif // Lua 5.4 only
+
+#endif // NOT_KEPLER_PROJECT_COMPAT54_H_// end of sol/compatibility/compat-5.4.h
+
+#endif
+
+// end of sol/compatibility.hpp
+
+#include <vector>
+#include <cstdint>
+#include <cstddef>
+
+namespace sol {
+
+	template <typename Allocator = std::allocator<std::byte>>
+	class basic_bytecode : private std::vector<std::byte, Allocator> {
+	private:
+		using base_t = std::vector<std::byte, Allocator>;
+
+	public:
+		using typename base_t::allocator_type;
+		using typename base_t::const_iterator;
+		using typename base_t::const_pointer;
+		using typename base_t::const_reference;
+		using typename base_t::const_reverse_iterator;
+		using typename base_t::difference_type;
+		using typename base_t::iterator;
+		using typename base_t::pointer;
+		using typename base_t::reference;
+		using typename base_t::reverse_iterator;
+		using typename base_t::size_type;
+		using typename base_t::value_type;
+
+		using base_t::base_t;
+		using base_t::operator=;
+
+		using base_t::data;
+		using base_t::empty;
+		using base_t::max_size;
+		using base_t::size;
+
+		using base_t::at;
+		using base_t::operator[];
+		using base_t::back;
+		using base_t::front;
+
+		using base_t::begin;
+		using base_t::cbegin;
+		using base_t::cend;
+		using base_t::end;
+
+		using base_t::crbegin;
+		using base_t::crend;
+		using base_t::rbegin;
+		using base_t::rend;
+
+		using base_t::get_allocator;
+		using base_t::swap;
+
+		using base_t::clear;
+		using base_t::emplace;
+		using base_t::emplace_back;
+		using base_t::erase;
+		using base_t::insert;
+		using base_t::pop_back;
+		using base_t::push_back;
+		using base_t::reserve;
+		using base_t::resize;
+		using base_t::shrink_to_fit;
+
+		string_view as_string_view() const {
+			return string_view(reinterpret_cast<const char*>(this->data()), this->size());
+		}
+	};
+
+	template <typename Container>
+	inline int basic_insert_dump_writer(lua_State*, const void* memory, size_t memory_size, void* userdata_pointer) {
+		using storage_t = Container;
+		const std::byte* p_code = static_cast<const std::byte*>(memory);
+		storage_t& bc = *static_cast<storage_t*>(userdata_pointer);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		bc.insert(bc.cend(), p_code, p_code + memory_size);
+#else
+		try {
+			bc.insert(bc.cend(), p_code, p_code + memory_size);
+		}
+		catch (...) {
+			return -1;
+		}
+#endif
+		return 0;
+	}
+
+	using bytecode = basic_bytecode<>;
+
+	constexpr inline auto bytecode_dump_writer = &basic_insert_dump_writer<bytecode>;
+
+} // namespace sol
+
+// end of sol/bytecode.hpp
+
+// beginning of sol/stack.hpp
+
+// beginning of sol/trampoline.hpp
+
+// beginning of sol/types.hpp
+
+// beginning of sol/error.hpp
+
+#include <stdexcept>
+#include <string>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct direct_error_tag { };
+		const auto direct_error = direct_error_tag {};
+
+		struct error_result {
+			int results;
+			const char* format_string;
+			std::array<const char*, 4> argument_strings;
+
+			error_result() : results(0), format_string(nullptr) {
+			}
+
+			error_result(int results_) : results(results_), format_string(nullptr) {
+			}
+
+			error_result(const char* format_string_, const char* first_message_) : results(0), format_string(format_string_), argument_strings() {
+				argument_strings[0] = first_message_;
+			}
+		};
+
+		inline int handle_errors(lua_State* L, const error_result& er) {
+			if (er.format_string == nullptr) {
+				return er.results;
+			}
+			return luaL_error(L, er.format_string, er.argument_strings[0], er.argument_strings[1], er.argument_strings[2], er.argument_strings[3]);
+		}
+	} // namespace detail
+
+	class error : public std::runtime_error {
+	private:
+		// Because VC++ is upsetting, most of the time!
+		std::string what_reason;
+
+	public:
+		error(const std::string& str) : error(detail::direct_error, "lua: error: " + str) {
+		}
+		error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {
+		}
+		error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), what_reason(str) {
+		}
+		error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), what_reason(std::move(str)) {
+		}
+
+		error(const error& e) = default;
+		error(error&& e) = default;
+		error& operator=(const error& e) = default;
+		error& operator=(error&& e) = default;
+
+		virtual const char* what() const noexcept override {
+			return what_reason.c_str();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/error.hpp
+
+// beginning of sol/optional.hpp
+
+// beginning of sol/in_place.hpp
+
+#include <cstddef>
+#include <utility>
+
+namespace sol {
+
+	using in_place_t = std::in_place_t;
+	constexpr std::in_place_t in_place {};
+	constexpr std::in_place_t in_place_of {};
+
+	template <typename T>
+	using in_place_type_t = std::in_place_type_t<T>;
+	template <typename T>
+	constexpr std::in_place_type_t<T> in_place_type {};
+
+	template <size_t I>
+	using in_place_index_t = std::in_place_index_t<I>;
+	template <size_t I>
+	constexpr in_place_index_t<I> in_place_index {};
+
+} // namespace sol
+
+// end of sol/in_place.hpp
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#include <boost/optional.hpp>
+#else
+// beginning of sol/optional_implementation.hpp
+
+#define SOL_TL_OPTIONAL_VERSION_MAJOR 0
+#define SOL_TL_OPTIONAL_VERSION_MINOR 5
+
+#include <exception>
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+#include <cstdlib>
+#include <optional>
+
+#if (defined(_MSC_VER) && _MSC_VER == 1900)
+#define SOL_TL_OPTIONAL_MSVC2015
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC49
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 4 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC54
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 5 && __GNUC_MINOR__ <= 5 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_GCC55
+#endif
+
+#if (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 9 && !defined(__clang__))
+#define SOL_TL_OPTIONAL_NO_CONSTRR
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::has_trivial_copy_constructor<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::has_trivial_copy_assign<T>::value
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+
+#elif (defined(__GNUC__) && __GNUC__ < 8 && !defined(__clang__))
+#ifndef SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+#define SOL_TL_GCC_LESS_8_TRIVIALLY_COPY_CONSTRUCTIBLE_MUTEX
+namespace sol { namespace detail {
+	template <class T>
+	struct is_trivially_copy_constructible : std::is_trivially_copy_constructible<T> { };
+#ifdef _GLIBCXX_VECTOR
+	template <class T, class A>
+	struct is_trivially_copy_constructible<std::vector<T, A>> : std::is_trivially_copy_constructible<T> { };
+#endif
+}} // namespace sol::detail
+#endif
+
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) sol::detail::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#else
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T) std::is_trivially_copy_constructible<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) std::is_trivially_copy_assignable<T>::value
+#define SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T) std::is_trivially_destructible<T>::value
+#endif
+
+#if __cplusplus > 201103L
+#define SOL_TL_OPTIONAL_CXX14
+#endif
+
+#if (__cplusplus == 201103L || defined(SOL_TL_OPTIONAL_MSVC2015) || defined(SOL_TL_OPTIONAL_GCC49))
+#define SOL_TL_OPTIONAL_11_CONSTEXPR
+#else
+   /// \exclude
+#define SOL_TL_OPTIONAL_11_CONSTEXPR constexpr
+#endif
+
+namespace sol {
+#ifndef SOL_TL_MONOSTATE_INPLACE_MUTEX
+#define SOL_TL_MONOSTATE_INPLACE_MUTEX
+	/// \brief Used to represent an optional with no data; essentially a bool
+	class monostate { };
+#endif
+
+	template <class T>
+	class optional;
+
+	/// \exclude
+	namespace detail {
+#ifndef SOL_TL_TRAITS_MUTEX
+#define SOL_TL_TRAITS_MUTEX
+		// C++14-style aliases for brevity
+		template <class T>
+		using remove_const_t = typename std::remove_const<T>::type;
+		template <class T>
+		using remove_reference_t = typename std::remove_reference<T>::type;
+		template <class T>
+		using decay_t = typename std::decay<T>::type;
+		template <bool E, class T = void>
+		using enable_if_t = typename std::enable_if<E, T>::type;
+		template <bool B, class T, class F>
+		using conditional_t = typename std::conditional<B, T, F>::type;
+
+		// std::conjunction from C++17
+		template <class...>
+		struct conjunction : std::true_type { };
+		template <class B>
+		struct conjunction<B> : B { };
+		template <class B, class... Bs>
+		struct conjunction<B, Bs...> : std::conditional<bool(B::value), conjunction<Bs...>, B>::type { };
+
+#if defined(_LIBCPP_VERSION) && __cplusplus == 201103L
+#define SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+#endif
+
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		template <class T>
+		struct is_pointer_to_non_const_member_func : std::false_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...)&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) &&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&> : std::true_type { };
+		template <class T, class Ret, class... Args>
+		struct is_pointer_to_non_const_member_func<Ret (T::*)(Args...) volatile&&> : std::true_type { };
+
+		template <class T>
+		struct is_const_or_const_ref : std::false_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const&> : std::true_type { };
+		template <class T>
+		struct is_const_or_const_ref<T const> : std::true_type { };
+#endif
+
+		// std::invoke from C++17
+		// https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
+		template <typename Fn, typename... Args,
+#ifdef SOL_TL_OPTIONAL_LIBCXX_MEM_FN_WORKAROUND
+		     typename = enable_if_t<!(is_pointer_to_non_const_member_func<Fn>::value && is_const_or_const_ref<Args...>::value)>,
+#endif
+		     typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>::value>, int = 0>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::mem_fn(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::mem_fn(f)(std::forward<Args>(args)...)) {
+			return std::mem_fn(f)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fn, typename... Args, typename = enable_if_t<!std::is_member_pointer<decay_t<Fn>>::value>>
+		constexpr auto invoke(Fn&& f, Args&&... args) noexcept(noexcept(std::forward<Fn>(f)(std::forward<Args>(args)...)))
+		     -> decltype(std::forward<Fn>(f)(std::forward<Args>(args)...)) {
+			return std::forward<Fn>(f)(std::forward<Args>(args)...);
+		}
+
+		// std::invoke_result from C++17
+		template <class F, class, class... Us>
+		struct invoke_result_impl;
+
+		template <class F, class... Us>
+		struct invoke_result_impl<F, decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...), void()), Us...> {
+			using type = decltype(detail::invoke(std::declval<F>(), std::declval<Us>()...));
+		};
+
+		template <class F, class... Us>
+		using invoke_result = invoke_result_impl<F, void, Us...>;
+
+		template <class F, class... Us>
+		using invoke_result_t = typename invoke_result<F, Us...>::type;
+#endif
+
+		// std::void_t from C++17
+		template <class...>
+		struct voider {
+			using type = void;
+		};
+		template <class... Ts>
+		using void_t = typename voider<Ts...>::type;
+
+		// Trait for checking if a type is a sol::optional
+		template <class T>
+		struct is_optional_impl : std::false_type { };
+		template <class T>
+		struct is_optional_impl<optional<T>> : std::true_type { };
+		template <class T>
+		using is_optional = is_optional_impl<decay_t<T>>;
+
+		// Change void to sol::monostate
+		template <class U>
+		using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
+
+		template <class F, class U, class = invoke_result_t<F, U>>
+		using get_map_return = optional<fixup_void<invoke_result_t<F, U>>>;
+
+		// Check if invoking F for some Us returns void
+		template <class F, class = void, class... U>
+		struct returns_void_impl;
+		template <class F, class... U>
+		struct returns_void_impl<F, void_t<invoke_result_t<F, U...>>, U...> : std::is_void<invoke_result_t<F, U...>> { };
+		template <class F, class... U>
+		using returns_void = returns_void_impl<F, void, U...>;
+
+		template <class T, class... U>
+		using enable_if_ret_void = enable_if_t<returns_void<T&&, U...>::value>;
+
+		template <class T, class... U>
+		using disable_if_ret_void = enable_if_t<!returns_void<T&&, U...>::value>;
+
+		template <class T, class U>
+		using enable_forward_value = detail::enable_if_t<std::is_constructible<T, U&&>::value && !std::is_same<detail::decay_t<U>, in_place_t>::value
+		     && !std::is_same<optional<T>, detail::decay_t<U>>::value>;
+
+		template <class T, class U, class Other>
+		using enable_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && !std::is_constructible<T, optional<U>&>::value
+		     && !std::is_constructible<T, optional<U>&&>::value && !std::is_constructible<T, const optional<U>&>::value
+		     && !std::is_constructible<T, const optional<U>&&>::value && !std::is_convertible<optional<U>&, T>::value
+		     && !std::is_convertible<optional<U>&&, T>::value && !std::is_convertible<const optional<U>&, T>::value
+		     && !std::is_convertible<const optional<U>&&, T>::value>;
+
+		template <class T, class U>
+		using enable_assign_forward = detail::enable_if_t<!std::is_same<optional<T>, detail::decay_t<U>>::value
+		     && !detail::conjunction<std::is_scalar<T>, std::is_same<T, detail::decay_t<U>>>::value && std::is_constructible<T, U>::value
+		     && std::is_assignable<T&, U>::value>;
+
+		template <class T, class U, class Other>
+		using enable_assign_from_other = detail::enable_if_t<std::is_constructible<T, Other>::value && std::is_assignable<T&, Other>::value
+		     && !std::is_constructible<T, optional<U>&>::value && !std::is_constructible<T, optional<U>&&>::value
+		     && !std::is_constructible<T, const optional<U>&>::value && !std::is_constructible<T, const optional<U>&&>::value
+		     && !std::is_convertible<optional<U>&, T>::value && !std::is_convertible<optional<U>&&, T>::value
+		     && !std::is_convertible<const optional<U>&, T>::value && !std::is_convertible<const optional<U>&&, T>::value
+		     && !std::is_assignable<T&, optional<U>&>::value && !std::is_assignable<T&, optional<U>&&>::value
+		     && !std::is_assignable<T&, const optional<U>&>::value && !std::is_assignable<T&, const optional<U>&&>::value>;
+
+#ifdef _MSC_VER
+		// TODO make a version which works with MSVC
+		template <class T, class U = T>
+		struct is_swappable : std::true_type { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable : std::true_type { };
+#else
+		// https://stackoverflow.com/questions/26744589/what-is-a-proper-way-to-implement-is-swappable-to-test-for-the-swappable-concept
+		namespace swap_adl_tests {
+			// if swap ADL finds this then it would call std::swap otherwise (same
+			// signature)
+			struct tag { };
+
+			template <class T>
+			tag swap(T&, T&);
+			template <class T, std::size_t N>
+			tag swap(T (&a)[N], T (&b)[N]);
+
+			// helper functions to test if an unqualified swap is possible, and if it
+			// becomes std::swap
+			template <class, class>
+			std::false_type can_swap(...) noexcept(false);
+			template <class T, class U, class = decltype(swap(std::declval<T&>(), std::declval<U&>()))>
+			std::true_type can_swap(int) noexcept(noexcept(swap(std::declval<T&>(), std::declval<U&>())));
+
+			template <class, class>
+			std::false_type uses_std(...);
+			template <class T, class U>
+			std::is_same<decltype(swap(std::declval<T&>(), std::declval<U&>())), tag> uses_std(int);
+
+			template <class T>
+			struct is_std_swap_noexcept
+			: std::integral_constant<bool, std::is_nothrow_move_constructible<T>::value && std::is_nothrow_move_assignable<T>::value> { };
+
+			template <class T, std::size_t N>
+			struct is_std_swap_noexcept<T[N]> : is_std_swap_noexcept<T> { };
+
+			template <class T, class U>
+			struct is_adl_swap_noexcept : std::integral_constant<bool, noexcept(can_swap<T, U>(0))> { };
+		} // namespace swap_adl_tests
+
+		template <class T, class U = T>
+		struct is_swappable : std::integral_constant<bool,
+		                           decltype(detail::swap_adl_tests::can_swap<T, U>(0))::value
+		                                && (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value
+		                                     || (std::is_move_assignable<T>::value && std::is_move_constructible<T>::value))> { };
+
+		template <class T, std::size_t N>
+		struct is_swappable<T[N], T[N]> : std::integral_constant<bool,
+		                                       decltype(detail::swap_adl_tests::can_swap<T[N], T[N]>(0))::value
+		                                            && (!decltype(detail::swap_adl_tests::uses_std<T[N], T[N]>(0))::value || is_swappable<T, T>::value)> { };
+
+		template <class T, class U = T>
+		struct is_nothrow_swappable
+		: std::integral_constant<bool,
+		       is_swappable<T, U>::value
+		            && ((decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_std_swap_noexcept<T>::value)
+		                 || (!decltype(detail::swap_adl_tests::uses_std<T, U>(0))::value&& detail::swap_adl_tests::is_adl_swap_noexcept<T, U>::value))> { };
+#endif
+
+		// The storage base manages the actual storage, and correctly propagates
+		// trivial destroyion from T. This case is for when T is not trivially
+		// destructible.
+		template <class T, bool = ::std::is_trivially_destructible<T>::value>
+		struct optional_storage_base {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			~optional_storage_base() {
+				if (m_has_value) {
+					m_value.~T();
+					m_has_value = false;
+				}
+			}
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value;
+		};
+
+		// This case is for when T is trivially destructible.
+		template <class T>
+		struct optional_storage_base<T, true> {
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base() noexcept : m_dummy(), m_has_value(false) {
+			}
+
+			template <class... U>
+			SOL_TL_OPTIONAL_11_CONSTEXPR optional_storage_base(in_place_t, U&&... u) : m_value(std::forward<U>(u)...), m_has_value(true) {
+			}
+
+			// No destructor, so this class is trivially destructible
+
+			struct dummy { };
+			union {
+				dummy m_dummy;
+				T m_value;
+			};
+
+			bool m_has_value = false;
+		};
+
+		// This base class provides some handy member functions which can be used in
+		// further derived classes
+		template <class T>
+		struct optional_operations_base : optional_storage_base<T> {
+			using optional_storage_base<T>::optional_storage_base;
+
+			void hard_reset() noexcept {
+				get().~T();
+				this->m_has_value = false;
+			}
+
+			template <class... Args>
+			void construct(Args&&... args) noexcept {
+				new (std::addressof(this->m_value)) T(std::forward<Args>(args)...);
+				this->m_has_value = true;
+			}
+
+			template <class Opt>
+			void assign(Opt&& rhs) {
+				if (this->has_value()) {
+					if (rhs.has_value()) {
+						this->m_value = std::forward<Opt>(rhs).get();
+					}
+					else {
+						this->m_value.~T();
+						this->m_has_value = false;
+					}
+				}
+
+				else if (rhs.has_value()) {
+					construct(std::forward<Opt>(rhs).get());
+				}
+			}
+
+			bool has_value() const {
+				return this->m_has_value;
+			}
+
+			SOL_TL_OPTIONAL_11_CONSTEXPR T& get() & {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR const T& get() const& {
+				return this->m_value;
+			}
+			SOL_TL_OPTIONAL_11_CONSTEXPR T&& get() && {
+				return std::move(this->m_value);
+			}
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+			constexpr const T&& get() const&& {
+				return std::move(this->m_value);
+			}
+#endif
+		};
+
+		// This class manages conditionally having a trivial copy constructor
+		// This specialization is for when T is trivially copy constructible
+		template <class T, bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)>
+		struct optional_copy_base : optional_operations_base<T> {
+			using optional_operations_base<T>::optional_operations_base;
+		};
+
+		// This specialization is for when T is not trivially copy constructible
+		template <class T>
+		struct optional_copy_base<T, false> : optional_operations_base<T> {
+			using base_t = optional_operations_base<T>;
+
+			using base_t::base_t;
+
+			optional_copy_base() = default;
+			optional_copy_base(const optional_copy_base& rhs) : base_t() {
+				if (rhs.has_value()) {
+					this->construct(rhs.get());
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+
+			optional_copy_base(optional_copy_base&& rhs) = default;
+			optional_copy_base& operator=(const optional_copy_base& rhs) = default;
+			optional_copy_base& operator=(optional_copy_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T, bool = std::is_trivially_move_constructible<T>::value>
+		struct optional_move_base : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_base;
+#endif
+		template <class T>
+		struct optional_move_base<T, false> : optional_copy_base<T> {
+			using optional_copy_base<T>::optional_copy_base;
+
+			optional_move_base() = default;
+			optional_move_base(const optional_move_base& rhs) = default;
+
+			optional_move_base(optional_move_base&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
+				if (rhs.has_value()) {
+					this->construct(std::move(rhs.get()));
+				}
+				else {
+					this->m_has_value = false;
+				}
+			}
+			optional_move_base& operator=(const optional_move_base& rhs) = default;
+			optional_move_base& operator=(optional_move_base&& rhs) = default;
+		};
+
+		// This class manages conditionally having a trivial copy assignment operator
+		template <class T,
+		     bool = SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_ASSIGNABLE(T) && SOL_TL_OPTIONAL_IS_TRIVIALLY_COPY_CONSTRUCTIBLE(T)
+		          && SOL_TL_OPTIONAL_IS_TRIVIALLY_DESTRUCTIBLE(T)>
+		struct optional_copy_assign_base : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+		};
+
+		template <class T>
+		struct optional_copy_assign_base<T, false> : optional_move_base<T> {
+			using optional_move_base<T>::optional_move_base;
+
+			optional_copy_assign_base() = default;
+			optional_copy_assign_base(const optional_copy_assign_base& rhs) = default;
+
+			optional_copy_assign_base(optional_copy_assign_base&& rhs) = default;
+			optional_copy_assign_base& operator=(const optional_copy_assign_base& rhs) {
+				this->assign(rhs);
+				return *this;
+			}
+			optional_copy_assign_base& operator=(optional_copy_assign_base&& rhs) = default;
+		};
+
+#ifndef SOL_TL_OPTIONAL_GCC49
+		template <class T,
+		     bool = std::is_trivially_destructible<T>::value&& std::is_trivially_move_constructible<T>::value&& std::is_trivially_move_assignable<T>::value>
+		struct optional_move_assign_base : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+		};
+#else
+		template <class T, bool = false>
+		struct optional_move_assign_base;
+#endif
+
+		template <class T>
+		struct optional_move_assign_base<T, false> : optional_copy_assign_base<T> {
+			using optional_copy_assign_base<T>::optional_copy_assign_base;
+
+			optional_move_assign_base() = default;
+			optional_move_assign_base(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base(optional_move_assign_base&& rhs) = default;
+
+			optional_move_assign_base& operator=(const optional_move_assign_base& rhs) = default;
+
+			optional_move_assign_base& operator=(optional_move_assign_base&& rhs) noexcept(
+			     std::is_nothrow_move_constructible<T>::value&& std::is_nothrow_move_assignable<T>::value) {
+				this->assign(std::move(rhs));
+				return *this;
+			}
+		};
+
+		// optional_delete_ctor_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible
+		template <class T, bool EnableCopy = std::is_copy_constructible<T>::value, bool EnableMove = std::is_move_constructible<T>::value>
+		struct optional_delete_ctor_base {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, true, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, true> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = default;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_ctor_base<T, false, false> {
+			optional_delete_ctor_base() = default;
+			optional_delete_ctor_base(const optional_delete_ctor_base&) = delete;
+			optional_delete_ctor_base(optional_delete_ctor_base&&) noexcept = delete;
+			optional_delete_ctor_base& operator=(const optional_delete_ctor_base&) = default;
+			optional_delete_ctor_base& operator=(optional_delete_ctor_base&&) noexcept = default;
+		};
+
+		// optional_delete_assign_base will conditionally delete copy and move
+		// constructors depending on whether T is copy/move constructible + assignable
+		template <class T, bool EnableCopy = (std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value),
+		     bool EnableMove = (std::is_move_constructible<T>::value && std::is_move_assignable<T>::value)>
+		struct optional_delete_assign_base {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, true, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, true> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = default;
+		};
+
+		template <class T>
+		struct optional_delete_assign_base<T, false, false> {
+			optional_delete_assign_base() = default;
+			optional_delete_assign_base(const optional_delete_assign_base&) = default;
+			optional_delete_assign_base(optional_delete_assign_base&&) noexcept = default;
+			optional_delete_assign_base& operator=(const optional_delete_assign_base&) = delete;
+			optional_delete_assign_base& operator=(optional_delete_assign_base&&) noexcept = delete;
+		};
+
+	} // namespace detail
+
+	/// \brief A tag type to represent an empty optional
+	using nullopt_t = std::nullopt_t;
+
+	/// \brief Represents an empty optional
+	/// \synopsis static constexpr nullopt_t nullopt;
+	///
+	/// *Examples*:
+	/// ```
+	/// sol::optional<int> a = sol::nullopt;
+	/// void foo (sol::optional<int>);
+	/// foo(sol::nullopt); //pass an empty optional
+	/// ```
+	using std::nullopt;
+
+	/// @brief An exception for when an optional is accessed through specific methods while it is not engaged.
+	class bad_optional_access : public std::exception {
+	public:
+		/// @brief Default-constructs an optional exception.
+		bad_optional_access() = default;
+		/// @brief Returns a pointer to a null-terminated string containing the reason for the exception.
+		const char* what() const noexcept override {
+			return "Optional has no value";
+		}
+	};
+
+	/// An optional object is an object that contains the storage for another
+	/// object and manages the lifetime of this contained object, if any. The
+	/// contained object may be initialized after the optional object has been
+	/// initialized, and may be destroyed before the optional object has been
+	/// destroyed. The initialization state of the contained object is tracked by
+	/// the optional object.
+	template <class T>
+	class optional : private detail::optional_move_assign_base<T>,
+	                 private detail::optional_delete_ctor_base<T>,
+	                 private detail::optional_delete_assign_base<T> {
+		using base = detail::optional_move_assign_base<T>;
+
+		static_assert(!std::is_same<T, in_place_t>::value, "instantiation of optional with in_place_t is ill-formed");
+		static_assert(!std::is_same<detail::decay_t<T>, nullopt_t>::value, "instantiation of optional with nullopt_t is ill-formed");
+
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise the return value of
+		/// `std::invoke(std::forward<F>(f), value())` is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`.
+		/// \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept = default;
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value in-place using the given arguments.
+		/// \group in_place
+		/// \synopsis template <class... Args> constexpr explicit optional(in_place_t, Args&&... args);
+		template <class... Args>
+		constexpr explicit optional(detail::enable_if_t<std::is_constructible<T, Args...>::value, in_place_t>, Args&&... args)
+		: base(in_place, std::forward<Args>(args)...) {
+		}
+
+		/// \group in_place
+		/// \synopsis template <class U, class... Args> \n constexpr explicit optional(in_place_t, std::initializer_list<U>&, Args&&... args);
+		template <class U, class... Args>
+		SOL_TL_OPTIONAL_11_CONSTEXPR explicit optional(detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, in_place_t>,
+		     std::initializer_list<U> il, Args&&... args) {
+			this->construct(il, std::forward<Args>(args)...);
+		}
+
+#if 0 // SOL_MODIFICATION
+      /// Constructs the stored value with `u`.
+      /// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+
+		/// \exclude
+		template <class U = T, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr, detail::enable_forward_value<T, U>* = nullptr>
+		constexpr explicit optional(U&& u) : base(in_place, std::forward<U>(u)) {
+		}
+#else
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		constexpr optional(T&& u) : base(in_place, std::move(u)) {
+		}
+
+		/// \exclude
+		constexpr optional(const T& u) : base(in_place, u) {
+		}
+#endif // sol2 modification
+
+		/// Converting copy constructor.
+		/// \synopsis template <class U> optional(const optional<U> &rhs);
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<std::is_convertible<const U&, T>::value>* = nullptr>
+		optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, const U&>* = nullptr, detail::enable_if_t<!std::is_convertible<const U&, T>::value>* = nullptr>
+		explicit optional(const optional<U>& rhs) {
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+		}
+
+		/// Converting move constructor.
+		/// \synopsis template <class U> optional(optional<U> &&rhs);
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<std::is_convertible<U&&, T>::value>* = nullptr>
+		optional(optional<U>&& rhs) {
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+		}
+
+		/// \exclude
+		template <class U, detail::enable_from_other<T, U, U&&>* = nullptr, detail::enable_if_t<!std::is_convertible<U&&, T>::value>* = nullptr>
+		explicit optional(optional<U>&& rhs) {
+			this->construct(std::move(*rhs));
+		}
+
+		/// Destroys the stored value if there is one.
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Move assignment.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		optional& operator=(optional&& rhs) = default;
+
+		/// Assigns the stored value from `u`, destroying the old value if there was
+		/// one.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_assign_forward<T, U>* = nullptr>
+		optional& operator=(U&& u) {
+			if (has_value()) {
+				this->m_value = std::forward<U>(u);
+			}
+			else {
+				this->construct(std::forward<U>(u));
+			}
+
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Copies the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(const optional<U> & rhs);
+		template <class U, detail::enable_assign_from_other<T, U, const U&>* = nullptr>
+		optional& operator=(const optional<U>& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = *rhs;
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(*rhs);
+			}
+
+			return *this;
+		}
+
+		// TODO check exception guarantee
+		/// Converting move assignment operator.
+		///
+		/// Moves the value from `rhs` if there is one. Otherwise resets the stored
+		/// value in `*this`.
+		/// \synopsis optional &operator=(optional<U> && rhs);
+		template <class U, detail::enable_assign_from_other<T, U, U>* = nullptr>
+		optional& operator=(optional<U>&& rhs) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					this->m_value = std::move(*rhs);
+				}
+				else {
+					this->hard_reset();
+				}
+			}
+
+			if (rhs.has_value()) {
+				this->construct(std::move(*rhs));
+			}
+
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// \group emplace
+		/// \synopsis template <class U, class... Args> \n T& emplace(std::initializer_list<U> il, Args &&... args);
+		template <class U, class... Args>
+		detail::enable_if_t<std::is_constructible<T, std::initializer_list<U>&, Args&&...>::value, T&> emplace(std::initializer_list<U> il, Args&&... args) {
+			*this = nullopt;
+			this->construct(il, std::forward<Args>(args)...);
+			return value();
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept(std::is_nothrow_move_constructible<T>::value&& detail::is_nothrow_swappable<T>::value) {
+			if (has_value()) {
+				if (rhs.has_value()) {
+					using std::swap;
+					swap(**this, *rhs);
+				}
+				else {
+					new (std::addressof(rhs.m_value)) T(std::move(this->m_value));
+					this->m_value.T::~T();
+				}
+			}
+			else if (rhs.has_value()) {
+				new (std::addressof(this->m_value)) T(std::move(rhs.m_value));
+				rhs.m_value.T::~T();
+			}
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return std::addressof(this->m_value);
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return std::addressof(this->m_value);
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() & {
+			return this->m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const& {
+			return this->m_value;
+		}
+
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& operator*() && {
+			return std::move(this->m_value);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		constexpr const T&& operator*() const&& {
+			return std::move(this->m_value);
+		}
+#endif
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return this->m_has_value;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// \synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() & {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const& {
+			if (has_value())
+				return this->m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR T&& value() && {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T&& value() const&& {
+			if (has_value())
+				return std::move(this->m_value);
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+#endif
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T value_or(U&& u) const& {
+			static_assert(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be copy constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// \group value_or
+		template <class U>
+		SOL_TL_OPTIONAL_11_CONSTEXPR T value_or(U&& u) && {
+			static_assert(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value, "T must be move constructible and convertible from U");
+			return has_value() ? **this : static_cast<T>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			if (has_value()) {
+				this->m_value.~T();
+				this->m_has_value = false;
+			}
+		}
+	}; // namespace sol
+
+	/// \group relop
+	/// \brief Compares two optional objects
+	/// \details If both optionals contain a value, they are compared with `T`s
+	/// relational operators. Otherwise `lhs` and `rhs` are equal only if they are
+	/// both empty, and `lhs` is less than `rhs` only if `rhs` is empty and `lhs`
+	/// is not.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() == rhs.has_value() && (!lhs.has_value() || *lhs == *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() != rhs.has_value() || (lhs.has_value() && *lhs != *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const optional<U>& rhs) {
+		return rhs.has_value() && (!lhs.has_value() || *lhs < *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const optional<U>& rhs) {
+		return lhs.has_value() && (!rhs.has_value() || *lhs > *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !lhs.has_value() || (rhs.has_value() && *lhs <= *rhs);
+	}
+	/// \group relop
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const optional<U>& rhs) {
+		return !rhs.has_value() || (lhs.has_value() && *lhs >= *rhs);
+	}
+
+	/// \group relop_nullopt
+	/// \brief Compares an optional to a `nullopt`
+	/// \details Equivalent to comparing the optional to an empty optional
+	template <class T>
+	inline constexpr bool operator==(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator==(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator!=(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<(nullopt_t, const optional<T>& rhs) noexcept {
+		return rhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(const optional<T>& lhs, nullopt_t) noexcept {
+		return !lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(const optional<T>& lhs, nullopt_t) noexcept {
+		return lhs.has_value();
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+		return false;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+		return true;
+	}
+	/// \group relop_nullopt
+	template <class T>
+	inline constexpr bool operator>=(nullopt_t, const optional<T>& rhs) noexcept {
+		return !rhs.has_value();
+	}
+
+	/// \group relop_t
+	/// \brief Compares the optional with a value.
+	/// \details If the optional has a value, it is compared with the other value
+	/// using `T`s relational operators. Otherwise, the optional is considered
+	/// less than the value.
+	template <class T, class U>
+	inline constexpr bool operator==(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs == rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator==(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs == *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs != rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator!=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs != *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs < rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs < *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs <= rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator<=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs <= *rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs > rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs > *rhs : true;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const optional<T>& lhs, const U& rhs) {
+		return lhs.has_value() ? *lhs >= rhs : false;
+	}
+	/// \group relop_t
+	template <class T, class U>
+	inline constexpr bool operator>=(const U& lhs, const optional<T>& rhs) {
+		return rhs.has_value() ? lhs >= *rhs : true;
+	}
+
+	/// \synopsis template <class T>  \n  void swap(optional<T> &lhs, optional<T> &rhs);
+	template <class T, detail::enable_if_t<std::is_move_constructible<T>::value>* = nullptr, detail::enable_if_t<detail::is_swappable<T>::value>* = nullptr>
+	void swap(optional<T>& lhs, optional<T>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
+		return lhs.swap(rhs);
+	}
+
+	namespace detail {
+		struct i_am_secret { };
+	} // namespace detail
+
+	template <class T = detail::i_am_secret, class U, class Ret = detail::conditional_t<std::is_same<T, detail::i_am_secret>::value, detail::decay_t<U>, T>>
+	inline constexpr optional<Ret> make_optional(U&& v) {
+		return optional<Ret>(std::forward<U>(v));
+	}
+
+	template <class T, class... Args>
+	inline constexpr optional<T> make_optional(Args&&... args) {
+		return optional<T>(in_place, std::forward<Args>(args)...);
+	}
+	template <class T, class U, class... Args>
+	inline constexpr optional<T> make_optional(std::initializer_list<U> il, Args&&... args) {
+		return optional<T>(in_place, il, std::forward<Args>(args)...);
+	}
+
+#if __cplusplus >= 201703L
+	template <class T>
+	optional(T) -> optional<T>;
+#endif
+
+	/// \exclude
+	namespace detail {
+#ifdef SOL_TL_OPTIONAL_CXX14
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+		auto optional_map_impl(Opt&& opt, F&& f) {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return make_optional(monostate {});
+			}
+
+			return optional<monostate>(nullopt);
+		}
+#else
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<!std::is_void<Ret>::value>* = nullptr>
+
+		constexpr auto optional_map_impl(Opt&& opt, F&& f) -> optional<Ret> {
+			return opt.has_value() ? detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt)) : optional<Ret>(nullopt);
+		}
+
+		template <class Opt, class F, class Ret = decltype(detail::invoke(std::declval<F>(), *std::declval<Opt>())),
+		     detail::enable_if_t<std::is_void<Ret>::value>* = nullptr>
+
+		auto optional_map_impl(Opt&& opt, F&& f) -> optional<monostate> {
+			if (opt.has_value()) {
+				detail::invoke(std::forward<F>(f), *std::forward<Opt>(opt));
+				return monostate {};
+			}
+
+			return nullopt;
+		}
+#endif
+	} // namespace detail
+
+	/// Specialization for when `T` is a reference. `optional<T&>` acts similarly
+	/// to a `T*`, but provides more operations and shows intent more clearly.
+	///
+	/// *Examples*:
+	///
+	/// ```
+	/// int i = 42;
+	/// sol::optional<int&> o = i;
+	/// *o == 42; //true
+	/// i = 12;
+	/// *o = 12; //true
+	/// &*o == &i; //true
+	/// ```
+	///
+	/// Assignment has rebind semantics rather than assign-through semantics:
+	///
+	/// ```
+	/// int j = 8;
+	/// o = j;
+	///
+	/// &*o == &j; //true
+	/// ```
+	template <class T>
+	class optional<T&> {
+	public:
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr auto and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr auto and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#else
+		/// \group and_then
+		/// Carries out some operation which returns an optional on the stored
+		/// object if there is one. \requires `std::invoke(std::forward<F>(f),
+		/// value())` returns a `std::optional<U>` for some `U`. \returns Let `U` be
+		/// the result of `std::invoke(std::forward<F>(f), value())`. Returns a
+		/// `std::optional<U>`. The return value is empty if `*this` is empty,
+		/// otherwise the return value of `std::invoke(std::forward<F>(f), value())`
+		/// is returned.
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) & {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR detail::invoke_result_t<F, T&> and_then(F&& f) && {
+			using result = detail::invoke_result_t<F, T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group and_then
+		/// \synopsis template <class F> \n constexpr auto and_then(F &&f) const &&;
+		template <class F>
+		constexpr detail::invoke_result_t<F, const T&> and_then(F&& f) const&& {
+			using result = detail::invoke_result_t<F, const T&>;
+			static_assert(detail::is_optional<result>::value, "F must return an optional");
+
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : result(nullopt);
+		}
+#endif
+#endif
+
+#if defined(SOL_TL_OPTIONAL_CXX14) && !defined(SOL_TL_OPTIONAL_GCC49) && !defined(SOL_TL_OPTIONAL_GCC54) && !defined(SOL_TL_OPTIONAL_GCC55)
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR auto map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&;
+		template <class F>
+		constexpr auto map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> constexpr auto map(F &&f) const&&;
+		template <class F>
+		constexpr auto map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#else
+		/// \brief Carries out some operation on the stored object if there is one.
+		/// \returns Let `U` be the result of `std::invoke(std::forward<F>(f),
+		/// value())`. Returns a `std::optional<U>`. The return value is empty if
+		/// `*this` is empty, otherwise an `optional<U>` is constructed from the
+		/// return value of `std::invoke(std::forward<F>(f), value())` and is
+		/// returned.
+		///
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&>(), std::declval<F&&>())) map(F&& f) & {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) &&;
+		template <class F>
+		SOL_TL_OPTIONAL_11_CONSTEXPR decltype(detail::optional_map_impl(std::declval<optional&&>(), std::declval<F&&>())) map(F&& f) && {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&>(), std::declval<F&&>())) map(F&& f) const& {
+			return detail::optional_map_impl(*this, std::forward<F>(f));
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map
+		/// \synopsis template <class F> auto map(F &&f) const&&;
+		template <class F>
+		constexpr decltype(detail::optional_map_impl(std::declval<const optional&&>(), std::declval<F&&>())) map(F&& f) const&& {
+			return detail::optional_map_impl(std::move(*this), std::forward<F>(f));
+		}
+#endif
+#endif
+
+		/// \brief Calls `f` if the optional is empty
+		/// \requires `std::invoke_result_t<F>` must be void or convertible to
+		/// `optional<T>`. \effects If `*this` has a value, returns `*this`.
+		/// Otherwise, if `f` returns `void`, calls `std::forward<F>(f)` and returns
+		/// `std::nullopt`. Otherwise, returns `std::forward<F>(f)()`.
+		///
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) & {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) &&;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) && {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) && {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+
+		/// \group or_else
+		/// \synopsis template <class F> optional<T> or_else (F &&f) const &;
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const& {
+			if (has_value())
+				return *this;
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> SOL_TL_OPTIONAL_11_CONSTEXPR or_else(F&& f) const& {
+			return has_value() ? *this : std::forward<F>(f)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \exclude
+		template <class F, detail::enable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			if (has_value())
+				return std::move(*this);
+
+			std::forward<F>(f)();
+			return nullopt;
+		}
+
+		/// \exclude
+		template <class F, detail::disable_if_ret_void<F>* = nullptr>
+		optional<T> or_else(F&& f) const&& {
+			return has_value() ? std::move(*this) : std::forward<F>(f)();
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise returns
+		/// `u`.
+		///
+		/// \details If there is a value stored, then `f` is called with `**this`
+		/// and the value is returned. Otherwise `u` is returned.
+		///
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or
+		template <class F, class U>
+		U map_or(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u);
+		}
+#endif
+
+		/// \brief Maps the stored value with `f` if there is one, otherwise calls
+		/// `u` and returns the result.
+		///
+		/// \details If there is a value stored, then `f` is
+		/// called with `**this` and the value is returned. Otherwise
+		/// `std::forward<U>(u)()` is returned.
+		///
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u) &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) & {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) && {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const& {
+			return has_value() ? detail::invoke(std::forward<F>(f), **this) : std::forward<U>(u)();
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group map_or_else
+		/// \synopsis template <class F, class U> \n auto map_or_else(F &&f, U &&u)
+		/// const &&;
+		template <class F, class U>
+		detail::invoke_result_t<U> map_or_else(F&& f, U&& u) const&& {
+			return has_value() ? detail::invoke(std::forward<F>(f), std::move(**this)) : std::forward<U>(u)();
+		}
+#endif
+
+		/// \returns `u` if `*this` has a value, otherwise an empty optional.
+		template <class U>
+		constexpr optional<typename std::decay<U>::type> conjunction(U&& u) const {
+			using result = optional<detail::decay_t<U>>;
+			return has_value() ? result { u } : result { nullopt };
+		}
+
+		/// \returns `rhs` if `*this` is empty, otherwise the current value.
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) & {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const& {
+			return has_value() ? *this : rhs;
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(const optional& rhs) && {
+			return has_value() ? std::move(*this) : rhs;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(const optional& rhs) const&& {
+			return has_value() ? std::move(*this) : rhs;
+		}
+#endif
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) & {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const& {
+			return has_value() ? *this : std::move(rhs);
+		}
+
+		/// \group disjunction
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional disjunction(optional&& rhs) && {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group disjunction
+		constexpr optional disjunction(optional&& rhs) const&& {
+			return has_value() ? std::move(*this) : std::move(rhs);
+		}
+#endif
+
+		/// Takes the value out of the optional, leaving it empty
+		/// \group take
+		optional take() & {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() const& {
+			optional ret = *this;
+			reset();
+			return ret;
+		}
+
+		/// \group take
+		optional take() && {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+
+#ifndef SOL_TL_OPTIONAL_NO_CONSTRR
+		/// \group take
+		optional take() const&& {
+			optional ret = std::move(*this);
+			reset();
+			return ret;
+		}
+#endif
+
+		using value_type = T&;
+
+		/// Constructs an optional that does not contain a value.
+		/// \group ctor_empty
+		constexpr optional() noexcept : m_value(nullptr) {
+		}
+
+		/// \group ctor_empty
+		constexpr optional(nullopt_t) noexcept : m_value(nullptr) {
+		}
+
+		/// Copy constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(const optional& rhs) noexcept = default;
+
+		/// Move constructor
+		///
+		/// If `rhs` contains a value, the stored value is direct-initialized with
+		/// it. Otherwise, the constructed optional is empty.
+		SOL_TL_OPTIONAL_11_CONSTEXPR optional(optional&& rhs) = default;
+
+		/// Constructs the stored value with `u`.
+		/// \synopsis template <class U=T> constexpr optional(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		constexpr optional(U&& u) : m_value(std::addressof(u)) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+		}
+
+		/// \exclude
+		template <class U>
+		constexpr explicit optional(const optional<U>& rhs) : optional(*rhs) {
+		}
+
+		/// No-op
+		~optional() = default;
+
+		/// Assignment to empty.
+		///
+		/// Destroys the current value if there is one.
+		optional& operator=(nullopt_t) noexcept {
+			m_value = nullptr;
+			return *this;
+		}
+
+		/// Copy assignment.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		optional& operator=(const optional& rhs) = default;
+
+		/// Rebinds this optional to `u`.
+		///
+		/// \requires `U` must be an lvalue reference.
+		/// \synopsis optional &operator=(U &&u);
+		template <class U = T, detail::enable_if_t<!detail::is_optional<detail::decay_t<U>>::value>* = nullptr>
+		optional& operator=(U&& u) {
+			static_assert(std::is_lvalue_reference<U>::value, "U must be an lvalue");
+			m_value = std::addressof(u);
+			return *this;
+		}
+
+		/// Converting copy assignment operator.
+		///
+		/// Rebinds this optional to the referee of `rhs` if there is one. Otherwise
+		/// resets the stored value in `*this`.
+		template <class U>
+		optional& operator=(const optional<U>& rhs) {
+			m_value = std::addressof(rhs.value());
+			return *this;
+		}
+
+		/// Constructs the value in-place, destroying the current one if there is
+		/// one.
+		///
+		/// \group emplace
+		template <class... Args>
+		T& emplace(Args&&... args) noexcept {
+			static_assert(std::is_constructible<T, Args&&...>::value, "T must be constructible with Args");
+
+			*this = nullopt;
+			this->construct(std::forward<Args>(args)...);
+		}
+
+		/// Swaps this optional with the other.
+		///
+		/// If neither optionals have a value, nothing happens.
+		/// If both have a value, the values are swapped.
+		/// If one has a value, it is moved to the other and the movee is left
+		/// valueless.
+		void swap(optional& rhs) noexcept {
+			std::swap(m_value, rhs.m_value);
+		}
+
+		/// \returns a pointer to the stored value
+		/// \requires a value is stored
+		/// \group pointer
+		/// \synopsis constexpr const T *operator->() const;
+		constexpr const T* operator->() const {
+			return m_value;
+		}
+
+		/// \group pointer
+		/// \synopsis constexpr T *operator->();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T* operator->() {
+			return m_value;
+		}
+
+		/// \returns the stored value
+		/// \requires a value is stored
+		/// \group deref
+		/// \synopsis constexpr T &operator*();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& operator*() {
+			return *m_value;
+		}
+
+		/// \group deref
+		/// \synopsis constexpr const T &operator*() const;
+		constexpr const T& operator*() const {
+			return *m_value;
+		}
+
+		/// \returns whether or not the optional has a value
+		/// \group has_value
+		constexpr bool has_value() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \group has_value
+		constexpr explicit operator bool() const noexcept {
+			return m_value != nullptr;
+		}
+
+		/// \returns the contained value if there is one, otherwise throws
+		/// [bad_optional_access]
+		/// \group value
+		/// synopsis constexpr T &value();
+		SOL_TL_OPTIONAL_11_CONSTEXPR T& value() {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+		/// \group value
+		/// \synopsis constexpr const T &value() const;
+		SOL_TL_OPTIONAL_11_CONSTEXPR const T& value() const {
+			if (has_value())
+				return *m_value;
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+			std::abort();
+#else
+			throw bad_optional_access();
+#endif // No exceptions allowed
+		}
+
+		/// \returns the stored value if there is one, otherwise returns `u`
+		/// \group value_or
+		template <class U>
+		constexpr T& value_or(U&& u) const {
+			static_assert(std::is_convertible<U&&, T&>::value, "T must be convertible from U");
+			return has_value() ? const_cast<T&>(**this) : static_cast<T&>(std::forward<U>(u));
+		}
+
+		/// Destroys the stored value if one exists, making the optional empty
+		void reset() noexcept {
+			m_value = nullptr;
+		}
+
+	private:
+		T* m_value;
+	};
+
+} // namespace sol
+
+namespace std {
+	// TODO SFINAE
+	template <class T>
+	struct hash<::sol::optional<T>> {
+		::std::size_t operator()(const ::sol::optional<T>& o) const {
+			if (!o.has_value())
+				return 0;
+
+			return ::std::hash<::sol::detail::remove_const_t<T>>()(*o);
+		}
+	};
+} // namespace std
+
+// end of sol/optional_implementation.hpp
+
+#endif // Boost vs. Better optional
+
+#include <optional>
+
+namespace sol {
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+	template <typename T>
+	using optional = boost::optional<T>;
+	using nullopt_t = boost::none_t;
+	SOL_BOOST_NONE_CONSTEXPR_I_ nullopt_t nullopt = boost::none;
+#endif // Boost vs. Better optional
+
+	namespace meta {
+		template <typename T>
+		using is_optional = any<is_specialization_of<T, optional>, is_specialization_of<T, std::optional>>;
+
+		template <typename T>
+		constexpr inline bool is_optional_v = is_optional<T>::value;
+	} // namespace meta
+
+	namespace detail {
+		template <typename T>
+		struct associated_nullopt {
+			inline static constexpr std::nullopt_t value = std::nullopt;
+		};
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		struct associated_nullopt<boost::optional<T>> {
+			inline static SOL_BOOST_NONE_CONSTEXPR_I_ boost::none_t value = boost::none;
+		};
+#endif // Boost nullopt
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+		template <typename T>
+		inline SOL_BOOST_NONE_CONSTEXPR_I_ auto associated_nullopt_v = associated_nullopt<T>::value;
+#else
+		template <typename T>
+		inline constexpr auto associated_nullopt_v = associated_nullopt<T>::value;
+#endif // Boost continues to lag behind, to not many people's surprise...
+	} // namespace detail
+} // namespace sol
+
+#if SOL_IS_ON(SOL_USE_BOOST)
+#undef SOL_BOOST_NONE_CONSTEXPR_I_
+#endif
+
+// end of sol/optional.hpp
+
+// beginning of sol/raii.hpp
+
+#include <memory>
+
+namespace sol {
+	namespace detail {
+		struct default_construct {
+			template <typename T, typename... Args>
+			static void construct(T&& obj, Args&&... args) {
+				typedef meta::unqualified_t<T> Tu;
+				std::allocator<Tu> alloc {};
+				std::allocator_traits<std::allocator<Tu>>::construct(alloc, std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+
+			template <typename T, typename... Args>
+			void operator()(T&& obj, Args&&... args) const {
+				construct(std::forward<T>(obj), std::forward<Args>(args)...);
+			}
+		};
+
+		struct default_destroy {
+			template <typename T>
+			static void destroy(T&& obj) {
+				std::allocator<meta::unqualified_t<T>> alloc {};
+				alloc.destroy(obj);
+			}
+
+			template <typename T>
+			void operator()(T&& obj) const {
+				destroy(std::forward<T>(obj));
+			}
+		};
+
+		struct deleter {
+			template <typename T>
+			void operator()(T* p) const {
+				delete p;
+			}
+		};
+
+		struct state_deleter {
+			void operator()(lua_State* L) const {
+				lua_close(L);
+			}
+		};
+
+		template <typename T, typename Dx, typename... Args>
+		inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
+			return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
+		}
+
+		template <typename Tag, typename T>
+		struct tagged {
+		private:
+			T value_;
+
+		public:
+			template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
+			tagged(Arg&& arg, Args&&... args) : value_(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+			}
+
+			T& value() & {
+				return value_;
+			}
+
+			T const& value() const& {
+				return value_;
+			}
+
+			T&& value() && {
+				return std::move(value_);
+			}
+		};
+	} // namespace detail
+
+	template <typename... Args>
+	struct constructor_list { };
+
+	template <typename... Args>
+	using constructors = constructor_list<Args...>;
+
+	const auto default_constructor = constructors<types<>> {};
+
+	struct no_construction { };
+	const auto no_constructor = no_construction {};
+
+	struct call_construction { };
+	const auto call_constructor = call_construction {};
+
+	template <typename... Functions>
+	struct constructor_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
+		constructor_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto initializers(Functions&&... functions) {
+		return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename... Functions>
+	struct factory_wrapper {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
+		factory_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename... Functions>
+	inline auto factories(Functions&&... functions) {
+		return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
+	}
+
+	template <typename Function>
+	struct destructor_wrapper {
+		Function fx;
+		destructor_wrapper(Function f) : fx(std::move(f)) {
+		}
+	};
+
+	template <>
+	struct destructor_wrapper<void> { };
+
+	const destructor_wrapper<void> default_destructor {};
+
+	template <typename Fx>
+	inline auto destructor(Fx&& fx) {
+		return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
+	}
+
+} // namespace sol
+
+// end of sol/raii.hpp
+
+// beginning of sol/policies.hpp
+
+#include <array>
+
+namespace sol {
+	namespace detail {
+		struct policy_base_tag { };
+	} // namespace detail
+
+	template <int Target, int... In>
+	struct static_stack_dependencies : detail::policy_base_tag { };
+	typedef static_stack_dependencies<-1, 1> self_dependency;
+	template <int... In>
+	struct returns_self_with : detail::policy_base_tag { };
+	typedef returns_self_with<> returns_self;
+
+	struct stack_dependencies : detail::policy_base_tag {
+		int target;
+		std::array<int, 64> stack_indices;
+		std::size_t len;
+
+		template <typename... Args>
+		stack_dependencies(int stack_target, Args&&... args) : target(stack_target), stack_indices(), len(sizeof...(Args)) {
+			std::size_t i = 0;
+			(void)detail::swallow { int(), (stack_indices[i++] = static_cast<int>(std::forward<Args>(args)), int())... };
+		}
+
+		int& operator[](std::size_t i) {
+			return stack_indices[i];
+		}
+
+		const int& operator[](std::size_t i) const {
+			return stack_indices[i];
+		}
+
+		std::size_t size() const {
+			return len;
+		}
+	};
+
+	template <typename F, typename... Policies>
+	struct policy_wrapper {
+		typedef std::index_sequence_for<Policies...> indices;
+
+		F value;
+		std::tuple<Policies...> policies;
+
+		template <typename Fx, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<Fx>, policy_wrapper>>> = meta::enabler>
+		policy_wrapper(Fx&& fx, Args&&... args) : value(std::forward<Fx>(fx)), policies(std::forward<Args>(args)...) {
+		}
+
+		policy_wrapper(const policy_wrapper&) = default;
+		policy_wrapper& operator=(const policy_wrapper&) = default;
+		policy_wrapper(policy_wrapper&&) = default;
+		policy_wrapper& operator=(policy_wrapper&&) = default;
+	};
+
+	template <typename F, typename... Args>
+	auto policies(F&& f, Args&&... args) {
+		return policy_wrapper<std::decay_t<F>, std::decay_t<Args>...>(std::forward<F>(f), std::forward<Args>(args)...);
+	}
+
+	namespace detail {
+		template <typename T>
+		using is_policy = meta::is_specialization_of<T, policy_wrapper>;
+
+		template <typename T>
+		inline constexpr bool is_policy_v = is_policy<T>::value;
+	} // namespace detail
+} // namespace sol
+
+// end of sol/policies.hpp
+
+// beginning of sol/ebco.hpp
+
+#include <type_traits>
+#include <utility>
+#include <memory>
+
+namespace sol { namespace detail {
+
+	template <typename T, std::size_t tag = 0, typename = void>
+	struct ebco {
+		T m_value;
+
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : m_value(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : m_value(std::move(v)) {};
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			m_value = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			m_value = std::move(v);
+			return *this;
+		};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>)
+		: m_value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		T& value() & noexcept {
+			return m_value;
+		}
+
+		T const& value() const& noexcept {
+			return m_value;
+		}
+
+		T&& value() && noexcept {
+			return std::move(m_value);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T, tag, std::enable_if_t<!std::is_reference_v<T> && std::is_class_v<T> && !std::is_final_v<T>>> : T {
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(const T& v) noexcept(std::is_nothrow_copy_constructible_v<T>) : T(v) {};
+		ebco(T&& v) noexcept(std::is_nothrow_move_constructible_v<T>) : T(std::move(v)) {};
+		template <typename Arg, typename... Args,
+			typename = std::enable_if_t<
+			     !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>,
+			          ebco> && !std::is_same_v<std::remove_reference_t<std::remove_cv_t<Arg>>, T> && (sizeof...(Args) > 0 || !std::is_convertible_v<Arg, T>)>>
+		ebco(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Arg, Args...>) : T(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(const T& v) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			static_cast<T&>(*this) = v;
+			return *this;
+		}
+		ebco& operator=(T&& v) noexcept(std::is_nothrow_move_assignable_v<T>) {
+			static_cast<T&>(*this) = std::move(v);
+			return *this;
+		};
+
+		T& value() & noexcept {
+			return static_cast<T&>(*this);
+		}
+
+		T const& value() const& noexcept {
+			return static_cast<T const&>(*this);
+		}
+
+		T&& value() && noexcept {
+			return std::move(static_cast<T&>(*this));
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&, tag> {
+	private:
+		T* m_ref;
+
+	public:
+		ebco() = default;
+		ebco(const ebco&) = default;
+		ebco(ebco&&) = default;
+		ebco(T& v) noexcept : m_ref(std::addressof(v)) {};
+
+		ebco& operator=(const ebco&) = default;
+		ebco& operator=(ebco&&) = default;
+		ebco& operator=(T& v) noexcept {
+			m_ref = std::addressof(v);
+			return *this;
+		}
+
+		T& value() const noexcept {
+			return *(const_cast<ebco<T&, tag>&>(*this).m_ref);
+		}
+	};
+
+	template <typename T, std::size_t tag>
+	struct ebco<T&&, tag> {
+		T&& ref;
+
+		ebco() = default;
+		ebco(const ebco&) = delete;
+		ebco(ebco&&) = default;
+		ebco(T&& v) noexcept : ref(v) {};
+
+		ebco& operator=(const ebco&) = delete;
+		ebco& operator=(ebco&&) = delete;
+
+		T& value() & noexcept {
+			return ref;
+		}
+
+		const T& value() const& noexcept {
+			return ref;
+		}
+
+		T&& value() && noexcept {
+			return std::move(ref);
+		}
+	};
+
+}} // namespace sol::detail
+
+// end of sol/ebco.hpp
+
+#include <array>
+#include <initializer_list>
+#include <string>
+#include <string_view>
+#include <optional>
+#include <memory>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol {
+	namespace d {
+		// shortest possible hidden detail namespace
+		// when types are transcribed, this saves
+		// quite a bit of space, actually.
+		// it's a little unfortunate, but here we are?
+		template <typename T>
+		struct u { };
+	} // namespace d
+
+	namespace detail {
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		typedef int (*lua_CFunction_noexcept)(lua_State* L) noexcept;
+#else
+		typedef int (*lua_CFunction_noexcept)(lua_State* L);
+#endif // noexcept function type for lua_CFunction
+
+		template <typename T>
+		struct implicit_wrapper {
+			T& value;
+
+			implicit_wrapper(T* value_) : value(*value_) {
+			}
+
+			implicit_wrapper(T& value_) : value(value_) {
+			}
+
+			operator T&() {
+				return value;
+			}
+
+			operator T*() {
+				return std::addressof(value);
+			}
+		};
+
+		struct yield_tag_t { };
+		inline constexpr yield_tag_t yield_tag {};
+	} // namespace detail
+
+	struct lua_nil_t { };
+	inline constexpr lua_nil_t lua_nil {};
+	inline bool operator==(lua_nil_t, lua_nil_t) {
+		return true;
+	}
+	inline bool operator!=(lua_nil_t, lua_nil_t) {
+		return false;
+	}
+#if SOL_IS_ON(SOL_NIL)
+	using nil_t = lua_nil_t;
+	inline constexpr const nil_t& nil = lua_nil;
+#endif
+
+	namespace detail {
+		struct non_lua_nil_t { };
+	} // namespace detail
+
+	struct metatable_key_t { };
+	inline constexpr metatable_key_t metatable_key {};
+
+	struct global_tag_t {
+	} inline constexpr global_tag {};
+
+	struct env_key_t { };
+	inline constexpr env_key_t env_key {};
+
+	struct no_metatable_t { };
+	inline constexpr no_metatable_t no_metatable {};
+
+	template <typename T>
+	struct yielding_t {
+		T func;
+
+		yielding_t() = default;
+		yielding_t(const yielding_t&) = default;
+		yielding_t(yielding_t&&) = default;
+		yielding_t& operator=(const yielding_t&) = default;
+		yielding_t& operator=(yielding_t&&) = default;
+		template <typename Arg,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<Arg>, yielding_t>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<Arg>>>> = meta::enabler>
+		yielding_t(Arg&& arg) : func(std::forward<Arg>(arg)) {
+		}
+		template <typename Arg0, typename Arg1, typename... Args>
+		yielding_t(Arg0&& arg0, Arg1&& arg1, Args&&... args) : func(std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename F>
+	inline yielding_t<std::decay_t<F>> yielding(F&& f) {
+		return yielding_t<std::decay_t<F>>(std::forward<F>(f));
+	}
+
+	typedef std::remove_pointer_t<lua_CFunction> lua_CFunction_ref;
+
+	template <typename T>
+	struct non_null { };
+
+	template <typename... Args>
+	struct function_sig { };
+
+	struct upvalue_index {
+		int index;
+		upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct raw_index {
+		int index;
+		raw_index(int i) : index(i) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct absolute_index {
+		int index;
+		absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct ref_index {
+		int index;
+		ref_index(int idx) : index(idx) {
+		}
+
+		operator int() const {
+			return index;
+		}
+	};
+
+	struct stack_count {
+		int count;
+
+		stack_count(int cnt) : count(cnt) {
+		}
+	};
+
+	struct lightuserdata_value {
+		void* value;
+		lightuserdata_value(void* data) : value(data) {
+		}
+		operator void*() const {
+			return value;
+		}
+	};
+
+	struct userdata_value {
+	private:
+		void* m_value;
+
+	public:
+		userdata_value(void* data) : m_value(data) {
+		}
+
+		void* value() const {
+			return m_value;
+		}
+
+		operator void*() const {
+			return value();
+		}
+	};
+
+	template <typename T>
+	struct light {
+	private:
+		static_assert(!std::is_void_v<T>, "the type for light will never be void");
+		T* m_value;
+
+	public:
+		light(T& x) : m_value(std::addressof(x)) {
+		}
+		light(T* x) : m_value(x) {
+		}
+		explicit light(void* x) : m_value(static_cast<T*>(x)) {
+		}
+
+		T* value() const {
+			return m_value;
+		}
+
+		operator T*() const {
+			return m_value;
+		}
+		operator T&() const {
+			return *m_value;
+		}
+
+		void* void_value() const {
+			return m_value;
+		}
+	};
+
+	template <typename T>
+	auto make_light(T& l) {
+		typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
+		return light<L>(l);
+	}
+
+	template <typename T>
+	struct user : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_pointer_t<std::remove_reference_t<T>>() {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_pointer_t<std::add_const_t<std::remove_reference_t<T>>>() const {
+			return std::addressof(this->base_t::value());
+		}
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>&() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	auto make_user(T&& u) {
+		typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
+		return user<U>(std::forward<T>(u));
+	}
+
+	template <typename T>
+	struct metatable_registry_key : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto meta_registry_key(T&& key) {
+		typedef meta::unqualified_t<T> K;
+		return metatable_registry_key<K>(std::forward<T>(key));
+	}
+
+	template <typename... Upvalues>
+	struct closure {
+		lua_CFunction c_function;
+		std::tuple<Upvalues...> upvalues;
+		closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {
+		}
+	};
+
+	template <>
+	struct closure<> {
+		lua_CFunction c_function;
+		int upvalues;
+		closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {
+		}
+	};
+
+	typedef closure<> c_closure;
+
+	template <typename... Args>
+	closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
+		return closure<Args...>(f, std::forward<Args>(args)...);
+	}
+
+	template <typename Sig, typename... Ps>
+	struct function_arguments {
+		std::tuple<Ps...> arguments;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
+		function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+	};
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function(Args&&... args) {
+		return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+
+	template <typename Sig = function_sig<>, typename... Args>
+	auto as_function_reference(Args&&... args) {
+		return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	struct as_table_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		as_table_t() = default;
+		as_table_t(const as_table_t&) = default;
+		as_table_t(as_table_t&&) = default;
+		as_table_t& operator=(const as_table_t&) = default;
+		as_table_t& operator=(as_table_t&&) = default;
+		as_table_t(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		as_table_t(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<as_table_t, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		as_table_t(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	template <typename T>
+	struct nested : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using nested_type = T;
+
+		nested() = default;
+		nested(const nested&) = default;
+		nested(nested&&) = default;
+		nested& operator=(const nested&) = default;
+		nested& operator=(nested&&) = default;
+		nested(const meta::unqualified_t<T>& obj) noexcept(std::is_nothrow_constructible_v<base_t, const meta::unqualified_t<T>&>) : base_t(obj) {
+		}
+		nested(meta::unqualified_t<T>&& obj) noexcept(std::is_nothrow_constructible_v<base_t, meta::unqualified_t<T>&&>) : base_t(std::move(obj)) {
+		}
+		template <typename Arg, typename... Args,
+		     std::enable_if_t<
+		          !std::is_same_v<nested, meta::unqualified_t<Arg>> && !std::is_same_v<meta::unqualified_t<T>, meta::unqualified_t<Arg>>>* = nullptr>
+		nested(Arg&& arg, Args&&... args) noexcept(std::is_nothrow_constructible_v<base_t, Arg, Args...>)
+		: base_t(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return this->base_t::value();
+		}
+
+		operator std::add_const_t<std::add_lvalue_reference_t<T>>() const {
+			return this->base_t::value();
+		}
+	};
+
+	struct nested_tag_t { };
+	constexpr inline nested_tag_t nested_tag {};
+
+	template <typename T>
+	as_table_t<T> as_table_ref(T&& container) {
+		return as_table_t<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	as_table_t<meta::unqualified_t<T>> as_table(T&& container) {
+		return as_table_t<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<T> as_nested_ref(T&& container) {
+		return nested<T>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	nested<meta::unqualified_t<T>> as_nested(T&& container) {
+		return nested<meta::unqualified_t<T>>(std::forward<T>(container));
+	}
+
+	template <typename T>
+	struct as_container_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using type = T;
+
+		as_container_t() = default;
+		as_container_t(const as_container_t&) = default;
+		as_container_t(as_container_t&&) = default;
+		as_container_t& operator=(const as_container_t&) = default;
+		as_container_t& operator=(as_container_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+
+		operator std::add_lvalue_reference_t<T>() {
+			return value();
+		}
+	};
+
+	template <typename T>
+	auto as_container(T&& value) {
+		return as_container_t<T>(std::forward<T>(value));
+	}
+
+	template <typename T>
+	struct push_invoke_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		push_invoke_t() = default;
+		push_invoke_t(const push_invoke_t&) = default;
+		push_invoke_t(push_invoke_t&&) = default;
+		push_invoke_t& operator=(const push_invoke_t&) = default;
+		push_invoke_t& operator=(push_invoke_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename Fx>
+	auto push_invoke(Fx&& fx) {
+		return push_invoke_t<Fx>(std::forward<Fx>(fx));
+	}
+
+	template <typename T>
+	struct forward_as_value_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		forward_as_value_t() = default;
+		forward_as_value_t(const forward_as_value_t&) = default;
+		forward_as_value_t(forward_as_value_t&&) = default;
+		forward_as_value_t& operator=(const forward_as_value_t&) = default;
+		forward_as_value_t& operator=(forward_as_value_t&&) = default;
+
+		using base_t::base_t;
+
+		using base_t::value;
+	};
+
+	template <typename T>
+	auto pass_as_value(T& value_ref_) {
+		return forward_as_value_t<T>(value_ref_);
+	}
+
+	struct override_value_t { };
+	constexpr inline override_value_t override_value = override_value_t();
+	struct update_if_empty_t { };
+	constexpr inline update_if_empty_t update_if_empty = update_if_empty_t();
+	struct create_if_nil_t { };
+	constexpr inline create_if_nil_t create_if_nil = create_if_nil_t();
+
+	namespace detail {
+		enum insert_mode { none = 0x0, update_if_empty = 0x01, override_value = 0x02, create_if_nil = 0x04 };
+
+		template <typename T, typename...>
+		using is_insert_mode = std::integral_constant<bool,
+		     std::is_same_v<T, override_value_t> || std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, create_if_nil_t>>;
+
+		template <typename T, typename...>
+		using is_not_insert_mode = meta::neg<is_insert_mode<T>>;
+	} // namespace detail
+
+	struct this_state {
+		lua_State* L;
+
+		this_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct this_main_state {
+		lua_State* L;
+
+		this_main_state(lua_State* Ls) : L(Ls) {
+		}
+
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+	};
+
+	struct new_table {
+		int sequence_hint = 0;
+		int map_hint = 0;
+
+		new_table() = default;
+		new_table(const new_table&) = default;
+		new_table(new_table&&) = default;
+		new_table& operator=(const new_table&) = default;
+		new_table& operator=(new_table&&) = default;
+
+		new_table(int sequence_hint_, int map_hint_ = 0) noexcept : sequence_hint(sequence_hint_), map_hint(map_hint_) {
+		}
+	};
+
+	const new_table create = {};
+
+	enum class lib : unsigned char {
+		// print, assert, and other base functions
+		base,
+		// require and other package functions
+		package,
+		// coroutine functions and utilities
+		coroutine,
+		// string library
+		string,
+		// functionality from the OS
+		os,
+		// all things math
+		math,
+		// the table manipulator and observer functions
+		table,
+		// the debug library
+		debug,
+		// the bit library: different based on which you're using
+		bit32,
+		// input/output library
+		io,
+		// LuaJIT only
+		ffi,
+		// LuaJIT only
+		jit,
+		// library for handling utf8: new to Lua
+		utf8,
+		// do not use
+		count
+	};
+
+	enum class call_syntax { dot = 0, colon = 1 };
+
+	enum class load_mode {
+		any = 0,
+		text = 1,
+		binary = 2,
+	};
+
+	enum class call_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		handler = LUA_ERRERR,
+		gc = LUA_ERRGCMM,
+		syntax = LUA_ERRSYNTAX,
+		file = LUA_ERRFILE,
+	};
+
+	enum class thread_status : int {
+		ok = LUA_OK,
+		yielded = LUA_YIELD,
+		runtime = LUA_ERRRUN,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		handler = LUA_ERRERR,
+		dead = -1,
+	};
+
+	enum class load_status : int {
+		ok = LUA_OK,
+		syntax = LUA_ERRSYNTAX,
+		memory = LUA_ERRMEM,
+		gc = LUA_ERRGCMM,
+		file = LUA_ERRFILE,
+	};
+
+	enum class gc_mode : int {
+		incremental = 0,
+		generational = 1,
+		default_value = incremental,
+	};
+
+	enum class type : int {
+		none = LUA_TNONE,
+		lua_nil = LUA_TNIL,
+#if SOL_IS_ON(SOL_NIL)
+		nil = lua_nil,
+#endif // Objective C/C++ Keyword that's found in OSX SDK and OBJC -- check for all forms to protect
+		string = LUA_TSTRING,
+		number = LUA_TNUMBER,
+		thread = LUA_TTHREAD,
+		boolean = LUA_TBOOLEAN,
+		function = LUA_TFUNCTION,
+		userdata = LUA_TUSERDATA,
+		lightuserdata = LUA_TLIGHTUSERDATA,
+		table = LUA_TTABLE,
+		poly = -0xFFFF
+	};
+
+	inline const std::string& to_string(call_status c) {
+		static const std::array<std::string, 10> names { { "ok",
+			"yielded",
+			"runtime",
+			"memory",
+			"handler",
+			"gc",
+			"syntax",
+			"file",
+			"CRITICAL_EXCEPTION_FAILURE",
+			"CRITICAL_INDETERMINATE_STATE_FAILURE" } };
+		switch (c) {
+		case call_status::ok:
+			return names[0];
+		case call_status::yielded:
+			return names[1];
+		case call_status::runtime:
+			return names[2];
+		case call_status::memory:
+			return names[3];
+		case call_status::handler:
+			return names[4];
+		case call_status::gc:
+			return names[5];
+		case call_status::syntax:
+			return names[6];
+		case call_status::file:
+			return names[7];
+		}
+		if (static_cast<std::ptrdiff_t>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[8];
+		}
+		return names[9];
+	}
+
+	inline bool is_indeterminate_call_failure(call_status c) {
+		switch (c) {
+		case call_status::ok:
+		case call_status::yielded:
+		case call_status::runtime:
+		case call_status::memory:
+		case call_status::handler:
+		case call_status::gc:
+		case call_status::syntax:
+		case call_status::file:
+			return false;
+		}
+		return true;
+	}
+
+	inline const std::string& to_string(load_status c) {
+		static const std::array<std::string, 7> names {
+			{ "ok", "memory", "gc", "syntax", "file", "CRITICAL_EXCEPTION_FAILURE", "CRITICAL_INDETERMINATE_STATE_FAILURE" }
+		};
+		switch (c) {
+		case load_status::ok:
+			return names[0];
+		case load_status::memory:
+			return names[1];
+		case load_status::gc:
+			return names[2];
+		case load_status::syntax:
+			return names[3];
+		case load_status::file:
+			return names[4];
+		}
+		if (static_cast<int>(c) == -1) {
+			// One of the many cases where a critical exception error has occurred
+			return names[5];
+		}
+		return names[6];
+	}
+
+	inline const std::string& to_string(load_mode c) {
+		static const std::array<std::string, 3> names { {
+			"bt",
+			"t",
+			"b",
+		} };
+		return names[static_cast<std::size_t>(c)];
+	}
+
+	enum class meta_function : unsigned {
+		construct,
+		index,
+		new_index,
+		mode,
+		call,
+		call_function = call,
+		metatable,
+		to_string,
+		length,
+		unary_minus,
+		addition,
+		subtraction,
+		multiplication,
+		division,
+		modulus,
+		power_of,
+		involution = power_of,
+		concatenation,
+		equal_to,
+		less_than,
+		less_than_or_equal_to,
+		garbage_collect,
+		floor_division,
+		bitwise_left_shift,
+		bitwise_right_shift,
+		bitwise_not,
+		bitwise_and,
+		bitwise_or,
+		bitwise_xor,
+		pairs,
+		ipairs,
+		next,
+		type,
+		type_info,
+		call_construct,
+		storage,
+		gc_names,
+		static_index,
+		static_new_index,
+	};
+
+	typedef meta_function meta_method;
+
+	inline const std::array<std::string, 37>& meta_function_names() {
+		static const std::array<std::string, 37> names = { { "new",
+			"__index",
+			"__newindex",
+			"__mode",
+			"__call",
+			"__metatable",
+			"__tostring",
+			"__len",
+			"__unm",
+			"__add",
+			"__sub",
+			"__mul",
+			"__div",
+			"__mod",
+			"__pow",
+			"__concat",
+			"__eq",
+			"__lt",
+			"__le",
+			"__gc",
+
+			"__idiv",
+			"__shl",
+			"__shr",
+			"__bnot",
+			"__band",
+			"__bor",
+			"__bxor",
+
+			"__pairs",
+			"__ipairs",
+			"next",
+
+			"__type",
+			"__typeinfo",
+			"__sol.call_new",
+			"__sol.storage",
+			"__sol.gc_names",
+			"__sol.static_index",
+			"__sol.static_new_index" } };
+		return names;
+	}
+
+	inline const std::string& to_string(meta_function mf) {
+		return meta_function_names()[static_cast<std::size_t>(mf)];
+	}
+
+	inline type type_of(lua_State* L, int index) {
+		return static_cast<type>(lua_type(L, index));
+	}
+
+	inline std::string type_name(lua_State* L, type t) {
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	template <typename T>
+	struct is_stateless_lua_reference
+	: std::integral_constant<bool,
+	       (std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>)&&(
+	            !std::is_base_of_v<stack_reference, T> && !std::is_base_of_v<reference, T> && !std::is_base_of_v<main_reference, T>)> { };
+
+	template <typename T>
+	inline constexpr bool is_stateless_lua_reference_v = is_stateless_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference
+	: std::integral_constant<bool,
+	       std::is_base_of_v<reference,
+	            T> || std::is_base_of_v<main_reference, T> || std::is_base_of_v<stack_reference, T> || std::is_base_of_v<stateless_stack_reference, T> || std::is_base_of_v<stateless_reference, T>> {
+	};
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_v = is_lua_reference<T>::value;
+
+	template <typename T>
+	struct is_lua_reference_or_proxy : std::integral_constant<bool, is_lua_reference_v<T> || meta::is_specialization_of_v<T, table_proxy>> { };
+
+	template <typename T>
+	inline constexpr bool is_lua_reference_or_proxy_v = is_lua_reference_or_proxy<T>::value;
+
+	template <typename T>
+	struct is_transparent_argument
+	: std::integral_constant<bool,
+	       std::is_same_v<meta::unqualified_t<T>,
+	            this_state> || std::is_same_v<meta::unqualified_t<T>, this_main_state> || std::is_same_v<meta::unqualified_t<T>, this_environment> || std::is_same_v<meta::unqualified_t<T>, variadic_args>> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_transparent_argument_v = is_transparent_argument<T>::value;
+
+	template <typename T>
+	struct is_variadic_arguments : meta::any<std::is_same<T, variadic_args>, meta::is_optional<T>> { };
+
+	template <typename T>
+	struct is_container
+	: std::integral_constant<bool,
+	       !std::is_same_v<state_view,
+	            T> && !std::is_same_v<state, T> && !meta::is_initializer_list_v<T> && !meta::is_string_like_v<T> && !meta::is_string_literal_array_v<T> && !is_transparent_argument_v<T> && !is_lua_reference_v<T> && (meta::has_begin_end_v<T> || std::is_array_v<T>)> {
+	};
+
+	template <typename T>
+	constexpr inline bool is_container_v = is_container<T>::value;
+
+	template <typename T>
+	struct is_to_stringable : meta::any<meta::supports_to_string_member<meta::unqualified_t<T>>, meta::supports_adl_to_string<meta::unqualified_t<T>>,
+	                               meta::supports_op_left_shift<std::ostream, meta::unqualified_t<T>>> { };
+
+	template <typename T>
+	inline constexpr bool is_to_stringable_v = is_to_stringable<T>::value;
+
+	template <typename T>
+	struct is_callable : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_callable_v = is_callable<T>::value;
+
+	namespace detail {
+		template <typename T, typename = void>
+		struct lua_type_of : std::integral_constant<type, type::userdata> { };
+
+		template <typename C, typename T, typename A>
+		struct lua_type_of<std::basic_string<C, T, A>> : std::integral_constant<type, type::string> { };
+
+		template <typename C, typename T>
+		struct lua_type_of<basic_string_view<C, T>> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <std::size_t N>
+		struct lua_type_of<char8_t[N]> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <std::size_t N>
+		struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <std::size_t N>
+		struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<char8_t> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<char16_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<char32_t> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const wchar_t*> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		template <>
+		struct lua_type_of<const char8_t*> : std::integral_constant<type, type::string> { };
+#endif
+
+		template <>
+		struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> { };
+
+		template <>
+		struct lua_type_of<bool> : std::integral_constant<type, type::boolean> { };
+
+		template <>
+		struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<lua_value> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<detail::non_lua_nil_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
+
+		template <>
+		struct lua_type_of<error> : std::integral_constant<type, type::string> { };
+
+		template <bool b, typename Base>
+		struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lua_table<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_metatable<Base>> : std::integral_constant<type, type::table> { };
+
+		template <typename T, typename Base>
+		struct lua_type_of<basic_usertype<T, Base>> : std::integral_constant<type, type::table> { };
+
+		template <>
+		struct lua_type_of<metatable_key_t> : std::integral_constant<type, type::table> { };
+
+		template <typename B>
+		struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<env_key_t> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> { };
+
+		template <typename T>
+		struct lua_type_of<std::initializer_list<T>> : std::integral_constant<type, type::table> { };
+
+		template <bool b>
+		struct lua_type_of<basic_reference<b>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> { };
+
+		template <typename... Args>
+		struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> { };
+
+		template <typename A, typename B>
+		struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<const void*> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <>
+		struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> { };
+
+		template <typename T>
+		struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename T>
+		struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> { };
+
+		template <>
+		struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> { };
+
+		template <>
+		struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned>
+		struct lua_type_of<basic_function<Base, aligned>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base, bool aligned, typename Handler>
+		struct lua_type_of<basic_protected_function<Base, aligned, Handler>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_coroutine<Base>> : std::integral_constant<type, type::function> { };
+
+		template <typename Base>
+		struct lua_type_of<basic_thread<Base>> : std::integral_constant<type, type::thread> { };
+
+		template <typename Signature>
+		struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <typename T>
+		struct lua_type_of<std::optional<T>> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<variadic_results> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<stack_count> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_main_state> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> { };
+
+		template <>
+		struct lua_type_of<type> : std::integral_constant<type, type::poly> { };
+
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, std::is_function_v<T> ? type::function : type::userdata> { };
+#else
+		template <typename T>
+		struct lua_type_of<T*> : std::integral_constant<type, type::userdata> { };
+#endif
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, lua_Number> || std::is_same_v<T, lua_Integer>>>
+		: std::integral_constant<type, type::number> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_function_v<T>>> : std::integral_constant<type, type::function> { };
+
+		template <typename T>
+		struct lua_type_of<T, std::enable_if_t<std::is_enum_v<T>>> : std::integral_constant<type, type::number> { };
+
+		template <>
+		struct lua_type_of<meta_function> : std::integral_constant<type, type::string> { };
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+		template <typename... Tn>
+		struct lua_type_of<std::variant<Tn...>> : std::integral_constant<type, type::poly> { };
+#endif // std::variant deployment sucks on Clang
+
+		template <typename T>
+		struct lua_type_of<nested<T>> : meta::conditional_t<::sol::is_container_v<T>, std::integral_constant<type, type::table>, lua_type_of<T>> { };
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate : std::integral_constant<C, v> { };
+
+		template <typename C, C v, template <typename...> class V, typename T, typename... Args>
+		struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> { };
+
+		template <typename C, C v, template <typename...> class V, typename List>
+		struct accumulate_list;
+
+		template <typename C, C v, template <typename...> class V, typename... Args>
+		struct accumulate_list<C, v, V, types<Args...>> : accumulate<C, v, V, Args...> { };
+	} // namespace detail
+
+	template <typename T>
+	struct lua_type_of : detail::lua_type_of<T> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename T>
+	inline constexpr type lua_type_of_v = lua_type_of<T>::value;
+
+	template <typename T>
+	struct lua_size : std::integral_constant<int, 1> {
+		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
+	};
+
+	template <typename A, typename B>
+	struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
+
+	template <typename... Args>
+	struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
+
+	template <typename T>
+	inline constexpr int lua_size_v = lua_size<T>::value;
+
+	namespace detail {
+		// MSVC's decltype detection is broken, which breaks other
+		// parts of the code. So we add more workarounds. The moment it's fixed,
+		// we take it away and break everyone that doesn't upgrade.
+		template <typename T>
+		using is_msvc_callable_rigged = meta::any<meta::is_specialization_of<T, push_invoke_t>, meta::is_specialization_of<T, as_table_t>,
+		     meta::is_specialization_of<T, forward_as_value_t>, meta::is_specialization_of<T, as_container_t>, meta::is_specialization_of<T, nested>,
+		     meta::is_specialization_of<T, yielding_t>>;
+
+		template <typename T>
+		inline constexpr bool is_msvc_callable_rigged_v = is_msvc_callable_rigged<T>::value;
+	} // namespace detail
+
+	template <typename T>
+	struct is_lua_primitive
+	: std::integral_constant<bool,
+	       type::userdata
+	                 != lua_type_of_v<
+	                      T> || ((type::userdata == lua_type_of_v<T>)&&meta::meta_detail::has_internal_marker_v<lua_type_of<T>> && !meta::meta_detail::has_internal_marker_v<lua_size<T>>)
+	            || is_lua_reference_or_proxy_v<T> || meta::is_specialization_of_v<T, std::tuple> || meta::is_specialization_of_v<T, std::pair>> { };
+
+	template <typename T>
+	constexpr inline bool is_lua_primitive_v = is_lua_primitive<T>::value;
+
+	template <typename T>
+	struct is_value_semantic_for_function
+#if SOL_IS_ON(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+	: std::true_type {
+	};
+#else
+	: std::false_type {
+	};
+#endif
+
+	template <typename T>
+	constexpr inline bool is_value_semantic_for_function_v = is_value_semantic_for_function<T>::value;
+
+	template <typename T>
+	struct is_main_threaded : std::is_base_of<main_reference, T> { };
+
+	template <typename T>
+	inline constexpr bool is_main_threaded_v = is_main_threaded<T>::value;
+
+	template <typename T>
+	struct is_stack_based : std::is_base_of<stack_reference, T> { };
+	template <>
+	struct is_stack_based<variadic_args> : std::true_type { };
+	template <>
+	struct is_stack_based<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<protected_function_result> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_proxy_base> : std::true_type { };
+	template <>
+	struct is_stack_based<stack_count> : std::true_type { };
+
+	template <typename T>
+	constexpr inline bool is_stack_based_v = is_stack_based<T>::value;
+
+	template <typename T>
+	struct is_lua_primitive<T*> : std::true_type { };
+	template <>
+	struct is_lua_primitive<unsafe_function_result> : std::true_type { };
+	template <>
+	struct is_lua_primitive<protected_function_result> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<user<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
+	template <typename T>
+	struct is_lua_primitive<optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<std::optional<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<as_table_t<T>> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<nested<T>> : std::true_type { };
+	template <>
+	struct is_lua_primitive<userdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<lightuserdata_value> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy> : std::true_type { };
+	template <>
+	struct is_lua_primitive<stack_proxy_base> : std::true_type { };
+	template <typename T>
+	struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> { };
+
+	template <typename T>
+	struct is_lua_index : std::is_integral<T> { };
+	template <>
+	struct is_lua_index<raw_index> : std::true_type { };
+	template <>
+	struct is_lua_index<absolute_index> : std::true_type { };
+	template <>
+	struct is_lua_index<ref_index> : std::true_type { };
+	template <>
+	struct is_lua_index<upvalue_index> : std::true_type { };
+
+	template <typename Signature>
+	struct lua_bind_traits : meta::bind_traits<Signature> {
+	private:
+		typedef meta::bind_traits<Signature> base_t;
+
+	public:
+		typedef std::integral_constant<bool, meta::count_for<is_variadic_arguments, typename base_t::args_list>::value != 0> runtime_variadics_t;
+		static const std::size_t true_arity = base_t::arity;
+		static const std::size_t arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+		static const std::size_t true_free_arity = base_t::free_arity;
+		static const std::size_t free_arity = detail::accumulate_list<std::size_t, 0, lua_size, typename base_t::free_args_list>::value
+		     - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
+	};
+
+	template <typename T>
+	struct is_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_table<basic_table_core<x, T>> : std::true_type { };
+	template <typename T>
+	struct is_table<basic_lua_table<T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_table_v = is_table<T>::value;
+
+	template <typename T>
+	struct is_global_table : std::false_type { };
+	template <typename T>
+	struct is_global_table<basic_table_core<true, T>> : std::true_type { };
+
+	template <typename T>
+	inline constexpr bool is_global_table_v = is_global_table<T>::value;
+
+	template <typename T>
+	struct is_stack_table : std::false_type { };
+	template <bool x, typename T>
+	struct is_stack_table<basic_table_core<x, T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+	template <typename T>
+	struct is_stack_table<basic_lua_table<T>> : std::integral_constant<bool, std::is_base_of_v<stack_reference, T>> { };
+
+	template <typename T>
+	inline constexpr bool is_stack_table_v = is_stack_table<T>::value;
+
+	template <typename T>
+	struct is_function : std::false_type { };
+	template <typename T, bool aligned>
+	struct is_function<basic_function<T, aligned>> : std::true_type { };
+	template <typename T, bool aligned, typename Handler>
+	struct is_function<basic_protected_function<T, aligned, Handler>> : std::true_type { };
+
+	template <typename T>
+	using is_lightuserdata = meta::is_specialization_of<T, basic_lightuserdata>;
+
+	template <typename T>
+	inline constexpr bool is_lightuserdata_v = is_lightuserdata<T>::value;
+
+	template <typename T>
+	using is_userdata = meta::is_specialization_of<T, basic_userdata>;
+
+	template <typename T>
+	inline constexpr bool is_userdata_v = is_userdata<T>::value;
+
+	template <typename T>
+	using is_environment = std::integral_constant<bool, is_userdata_v<T> || is_table_v<T> || meta::is_specialization_of_v<T, basic_environment>>;
+
+	template <typename T>
+	inline constexpr bool is_environment_v = is_environment<T>::value;
+
+	template <typename T>
+	using is_table_like = std::integral_constant<bool, is_table_v<T> || is_environment_v<T> || is_userdata_v<T>>;
+
+	template <typename T>
+	inline constexpr bool is_table_like_v = is_table_like<T>::value;
+
+	template <typename T>
+	struct is_automagical
+	: std::integral_constant<bool,
+	       (SOL_IS_ON(SOL_DEFAULT_AUTOMAGICAL_USERTYPES))
+	            || (std::is_array_v<
+	                     meta::unqualified_t<T>> || (!std::is_same_v<meta::unqualified_t<T>, state> && !std::is_same_v<meta::unqualified_t<T>, state_view>))> {
+	};
+
+	template <typename T>
+	inline type type_of() {
+		return lua_type_of<meta::unqualified_t<T>>::value;
+	}
+
+	namespace detail {
+		template <typename T>
+		struct is_non_factory_constructor : std::false_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructors<Args...>> : std::true_type { };
+
+		template <typename... Args>
+		struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type { };
+
+		template <>
+		struct is_non_factory_constructor<no_construction> : std::true_type { };
+
+		template <typename T>
+		inline constexpr bool is_non_factory_constructor_v = is_non_factory_constructor<T>::value;
+
+		template <typename T>
+		struct is_constructor : is_non_factory_constructor<T> { };
+
+		template <typename... Args>
+		struct is_constructor<factory_wrapper<Args...>> : std::true_type { };
+
+		template <typename T>
+		struct is_constructor<protect_t<T>> : is_constructor<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_constructor<policy_wrapper<F, Policies...>> : is_constructor<meta::unqualified_t<F>> { };
+
+		template <typename T>
+		inline constexpr bool is_constructor_v = is_constructor<T>::value;
+
+		template <typename... Args>
+		using any_is_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_constructor_v = any_is_constructor<Args...>::value;
+
+		template <typename T>
+		struct is_destructor : std::false_type { };
+
+		template <typename Fx>
+		struct is_destructor<destructor_wrapper<Fx>> : std::true_type { };
+
+		template <typename... Args>
+		using any_is_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
+
+		template <typename... Args>
+		inline constexpr bool any_is_destructor_v = any_is_destructor<Args...>::value;
+	} // namespace detail
+
+	template <typename T>
+	using is_lua_c_function = meta::any<std::is_same<lua_CFunction, T>, std::is_same<detail::lua_CFunction_noexcept, T>, std::is_same<lua_CFunction_ref, T>>;
+
+	template <typename T>
+	inline constexpr bool is_lua_c_function_v = is_lua_c_function<T>::value;
+
+	enum class automagic_flags : unsigned {
+		none = 0x000u,
+		default_constructor = 0x001,
+		destructor = 0x002u,
+		pairs_operator = 0x004u,
+		to_string_operator = 0x008u,
+		call_operator = 0x010u,
+		less_than_operator = 0x020u,
+		less_than_or_equal_to_operator = 0x040u,
+		length_operator = 0x080u,
+		equal_to_operator = 0x100u,
+		all = default_constructor | destructor | pairs_operator | to_string_operator | call_operator | less_than_operator | less_than_or_equal_to_operator
+		     | length_operator | equal_to_operator
+	};
+
+	inline constexpr automagic_flags operator|(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) | static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags operator&(automagic_flags left, automagic_flags right) noexcept {
+		return static_cast<automagic_flags>(
+		     static_cast<std::underlying_type_t<automagic_flags>>(left) & static_cast<std::underlying_type_t<automagic_flags>>(right));
+	}
+
+	inline constexpr automagic_flags& operator|=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left | right;
+		return left;
+	}
+
+	inline constexpr automagic_flags& operator&=(automagic_flags& left, automagic_flags right) noexcept {
+		left = left & right;
+		return left;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_flag(Left left, Right right) noexcept {
+		return (left & right) == right;
+	}
+
+	template <typename Left, typename Right>
+	constexpr bool has_any_flag(Left left, Right right) noexcept {
+		return (left & right) != static_cast<Left>(static_cast<std::underlying_type_t<Left>>(0));
+	}
+
+	template <typename Left, typename Right>
+	constexpr auto clear_flags(Left left, Right right) noexcept {
+		return static_cast<Left>(static_cast<std::underlying_type_t<Left>>(left) & ~static_cast<std::underlying_type_t<Right>>(right));
+	}
+
+	struct automagic_enrollments {
+		bool default_constructor = true;
+		bool destructor = true;
+		bool pairs_operator = true;
+		bool to_string_operator = true;
+		bool call_operator = true;
+		bool less_than_operator = true;
+		bool less_than_or_equal_to_operator = true;
+		bool length_operator = true;
+		bool equal_to_operator = true;
+	};
+
+	template <automagic_flags compile_time_defaults = automagic_flags::all>
+	struct constant_automagic_enrollments : public automagic_enrollments { };
+
+} // namespace sol
+
+// end of sol/types.hpp
+
+#include <exception>
+#include <cstring>
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	// must push a single object to be the error object
+	// NOTE: the VAST MAJORITY of all Lua libraries -- C or otherwise -- expect a string for the type of error
+	// break this convention at your own risk
+	using exception_handler_function = int (*)(lua_State*, optional<const std::exception&>, string_view);
+
+	namespace detail {
+		inline const char (&default_exception_handler_name())[11] {
+			static const char name[11] = "sol.\xE2\x98\xA2\xE2\x98\xA2";
+			return name;
+		}
+
+		// must push at least 1 object on the stack
+		inline int default_exception_handler(lua_State* L, optional<const std::exception&>, string_view what) {
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An exception occurred: ";
+			std::cerr.write(what.data(), static_cast<std::streamsize>(what.size()));
+			std::cerr << std::endl;
+#endif
+			lua_pushlstring(L, what.data(), what.size());
+			return 1;
+		}
+
+		inline int call_exception_handler(lua_State* L, optional<const std::exception&> maybe_ex, string_view what) {
+			lua_getglobal(L, default_exception_handler_name());
+			type t = static_cast<type>(lua_type(L, -1));
+			if (t != type::lightuserdata) {
+				lua_pop(L, 1);
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			void* vfunc = lua_touserdata(L, -1);
+			lua_pop(L, 1);
+			if (vfunc == nullptr) {
+				return default_exception_handler(L, std::move(maybe_ex), std::move(what));
+			}
+			exception_handler_function exfunc = reinterpret_cast<exception_handler_function>(vfunc);
+			return exfunc(L, std::move(maybe_ex), std::move(what));
+		}
+
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) noexcept {
+			return f(L);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) noexcept {
+			return f(L, std::forward<Args>(args)...);
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) noexcept {
+			return trampoline(L, f);
+		}
+#else
+
+		inline int lua_cfunction_trampoline(lua_State* L, lua_CFunction f) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+			return f(L);
+#else
+			try {
+				return f(L);
+			}
+			catch (const char* cs) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+			}
+			catch (const std::string& s) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+			}
+			catch (const std::exception& e) {
+				call_exception_handler(L, optional<const std::exception&>(e), e.what());
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+			}
+#endif // LuaJIT cannot have the catchall, but we must catch std::exceps for it
+			return lua_error(L);
+#endif // Safe exceptions
+		}
+
+		template <lua_CFunction f>
+		int static_trampoline(lua_State* L) {
+			return lua_cfunction_trampoline(L, f);
+		}
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <lua_CFunction_noexcept f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#else
+		template <lua_CFunction f>
+		int static_trampoline_noexcept(lua_State* L) noexcept {
+			return f(L);
+		}
+#endif
+
+		template <typename Fx, typename... Args>
+		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
+			if constexpr (meta::bind_traits<meta::unqualified_t<Fx>>::is_noexcept) {
+				return f(L, std::forward<Args>(args)...);
+			}
+			else {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				return f(L, std::forward<Args>(args)...);
+#else
+				try {
+					return f(L, std::forward<Args>(args)...);
+				}
+				catch (const char* cs) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(cs));
+				}
+				catch (const std::string& s) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), string_view(s.c_str(), s.size()));
+				}
+				catch (const std::exception& e) {
+					call_exception_handler(L, optional<const std::exception&>(e), e.what());
+				}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+				// LuaJIT cannot have the catchall when the safe propagation is on
+				// but LuaJIT will swallow all C++ errors
+				// if we don't at least catch std::exception ones
+				catch (...) {
+					call_exception_handler(L, optional<const std::exception&>(nullopt), "caught (...) exception");
+				}
+#endif
+				return lua_error(L);
+#endif
+			}
+		}
+
+		inline int c_trampoline(lua_State* L, lua_CFunction f) {
+			return trampoline(L, f);
+		}
+#endif // Exceptions vs. No Exceptions
+
+		template <typename F, F fx>
+		inline int typed_static_trampoline(lua_State* L) {
+#if 0
+			// TODO: you must evaluate the get/check_get of every
+			// argument, to ensure it doesn't throw
+			// (e.g., for the sol_lua_check_access extension point!)
+			// This incluudes properly noexcept-ing all the above
+			// trampolines / safety nets
+			if constexpr (meta::bind_traits<F>::is_noexcept) {
+				return static_trampoline_noexcept<fx>(L);
+			}
+			else
+#endif
+			{ return static_trampoline<fx>(L); }
+		}
+	} // namespace detail
+
+	inline void set_default_exception_handler(lua_State* L, exception_handler_function exf = &detail::default_exception_handler) {
+		static_assert(sizeof(void*) >= sizeof(exception_handler_function),
+		     "void* storage is too small to transport the exception handler: please file a bug on the sol2 issue tracker to get this looked at!");
+		void* storage;
+		std::memcpy(&storage, &exf, sizeof(exception_handler_function));
+		lua_pushlightuserdata(L, storage);
+		lua_setglobal(L, detail::default_exception_handler_name());
+	}
+} // namespace sol
+
+// end of sol/trampoline.hpp
+
+// beginning of sol/stack_core.hpp
+
+// beginning of sol/inheritance.hpp
+
+// beginning of sol/usertype_traits.hpp
+
+// beginning of sol/demangle.hpp
+
+#include <string>
+#include <array>
+#include <cctype>
+#if SOL_IS_ON(SOL_MINGW_CCTYPE_IS_POISONED)
+extern "C" {
+#include <ctype.h>
+}
+#endif // MinGW is on some stuff
+#include <locale>
+
+namespace sol { namespace detail {
+	inline constexpr std::array<string_view, 9> removals { { "{anonymous}",
+		"(anonymous namespace)",
+		"public:",
+		"private:",
+		"protected:",
+		"struct ",
+		"class ",
+		"`anonymous-namespace'",
+		"`anonymous namespace'" } };
+
+#if SOL_IS_ON(SOL_COMPILER_GCC) || SOL_IS_ON(SOL_COMPILER_CLANG)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		// cardinal sins from MINGW
+		using namespace std;
+		std::size_t start = name.find_first_of('[');
+		start = name.find_first_of('=', start);
+		std::size_t end = name.find_last_of(']');
+		if (end == std::string::npos)
+			end = name.size();
+		if (start == std::string::npos)
+			start = 0;
+		if (start < name.size() - 1)
+			start += 1;
+		name = name.substr(start, end - start);
+		start = name.rfind("seperator_mark");
+		if (start != std::string::npos) {
+			name.erase(start - 2, name.length());
+		}
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T, class seperator_mark = int>
+	inline std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__PRETTY_FUNCTION__);
+	}
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+	inline std::string ctti_get_type_name_from_sig(std::string name) {
+		std::size_t start = name.find("get_type_name");
+		if (start == std::string::npos)
+			start = 0;
+		else
+			start += 13;
+		if (start < name.size() - 1)
+			start += 1;
+		std::size_t end = name.find_last_of('>');
+		if (end == std::string::npos)
+			end = name.size();
+		name = name.substr(start, end - start);
+		if (name.find("struct", 0) == 0)
+			name.replace(0, 6, "", 0);
+		if (name.find("class", 0) == 0)
+			name.replace(0, 5, "", 0);
+		while (!name.empty() && isblank(name.front()))
+			name.erase(name.begin());
+		while (!name.empty() && isblank(name.back()))
+			name.pop_back();
+
+		for (std::size_t r = 0; r < removals.size(); ++r) {
+			auto found = name.find(removals[r]);
+			while (found != std::string::npos) {
+				name.erase(found, removals[r].size());
+				found = name.find(removals[r]);
+			}
+		}
+
+		return name;
+	}
+
+	template <typename T>
+	std::string ctti_get_type_name() {
+		return ctti_get_type_name_from_sig(__FUNCSIG__);
+	}
+#else
+#error Compiler not supported for demangling
+#endif // compilers
+
+	template <typename T>
+	std::string demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return realname;
+	}
+
+	inline std::string short_demangle_from_type_name(std::string realname) {
+		// This isn't the most complete but it'll do for now...?
+		static const std::array<std::string, 10> ops = {
+			{ "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" }
+		};
+		int level = 0;
+		std::size_t idx = 0;
+		for (idx = static_cast<std::size_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
+			if (level == 0 && realname[idx] == ':') {
+				break;
+			}
+			bool isleft = realname[idx] == '<';
+			bool isright = realname[idx] == '>';
+			if (!isleft && !isright)
+				continue;
+			bool earlybreak = false;
+			for (const auto& op : ops) {
+				std::size_t nisop = realname.rfind(op, idx);
+				if (nisop == std::string::npos)
+					continue;
+				std::size_t nisopidx = idx - op.size() + 1;
+				if (nisop == nisopidx) {
+					idx = static_cast<std::size_t>(nisopidx);
+					earlybreak = true;
+				}
+				break;
+			}
+			if (earlybreak) {
+				continue;
+			}
+			level += isleft ? -1 : 1;
+		}
+		if (idx > 0) {
+			realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
+		}
+		return realname;
+	}
+
+	template <typename T>
+	std::string short_demangle_once() {
+		std::string realname = ctti_get_type_name<T>();
+		return short_demangle_from_type_name(realname);
+	}
+
+	template <typename T>
+	const std::string& demangle() {
+		static const std::string d = demangle_once<T>();
+		return d;
+	}
+
+	template <typename T>
+	const std::string& short_demangle() {
+		static const std::string d = short_demangle_once<T>();
+		return d;
+	}
+}} // namespace sol::detail
+
+// end of sol/demangle.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_traits {
+		static const std::string& name() {
+			static const std::string& n = detail::short_demangle<T>();
+			return n;
+		}
+		static const std::string& qualified_name() {
+			static const std::string& q_n = detail::demangle<T>();
+			return q_n;
+		}
+		static const std::string& metatable() {
+			static const std::string m = std::string("sol.").append(detail::demangle<T>());
+			return m;
+		}
+		static const std::string& user_metatable() {
+			static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
+			return u_m;
+		}
+		static const std::string& user_gc_metatable() {
+			static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
+			return u_g_m;
+		}
+		static const std::string& gc_table() {
+			static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
+			return g_t;
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype_traits.hpp
+
+// beginning of sol/unique_usertype_traits.hpp
+
+#include <memory>
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct unique_fallback {
+			using SOL_INTERNAL_UNSPECIALIZED_MARKER_ = int;
+		};
+
+		template <typename T>
+		struct unique_fallback<std::shared_ptr<T>> {
+		private:
+			using pointer = typename std::pointer_traits<std::shared_ptr<T>>::element_type*;
+
+		public:
+			// rebind is non-void
+			// if and only if unique usertype
+			// is cast-capable
+			template <typename X>
+			using rebind_actual_type = std::shared_ptr<X>;
+
+			static bool is_null(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::shared_ptr<T>& p) noexcept {
+				return p.get();
+			}
+		};
+
+		template <typename T, typename D>
+		struct unique_fallback<std::unique_ptr<T, D>> {
+		private:
+			using pointer = typename std::unique_ptr<T, D>::pointer;
+
+		public:
+			static bool is_null(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p == nullptr;
+			}
+
+			static pointer get(lua_State*, const std::unique_ptr<T, D>& p) noexcept {
+				return p.get();
+			}
+		};
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename = void>
+		struct unique_actual_type;
+
+		template <typename T>
+		struct unique_actual_type<T, meta::void_t<typename T::actual_type>> {
+			using type = typename T::actual_type;
+		};
+
+		template <typename T, typename... Rest, template <typename...> class Templ>
+		struct unique_actual_type<Templ<T, Rest...>> {
+			using type = T;
+		};
+
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_actual_t = typename meta::meta_detail::unique_actual_type<unique_usertype_traits<T>>::type;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using value_test_t = decltype(T::value);
+
+		template <typename T>
+		using type_test_t = typename T::type;
+
+		template <typename T>
+		using type_element_type_t = typename T::element_type;
+
+		template <typename T, typename = void>
+		struct unique_element_type {
+			using type = typename std::pointer_traits<typename unique_actual_type<T>::type>::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_element_type_t, T>>> {
+			using type = typename T::element_type;
+		};
+
+		template <typename T>
+		struct unique_element_type<T, std::enable_if_t<meta::is_detected_v<type_test_t, T>>> {
+			using type = typename T::type;
+		};
+
+		template <typename T, typename = void>
+		struct unique_valid : std::integral_constant<bool, !has_internal_marker_v<T>> { };
+
+		template <typename T>
+		struct unique_valid<T, meta::void_t<decltype(T::value)>> : std::integral_constant<bool, T::value> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T>
+	using unique_usertype_element_t = typename meta::meta_detail::unique_element_type<unique_usertype_traits<T>>::type;
+
+	template <typename T, typename Element = void>
+	using unique_usertype_rebind_actual_t = typename unique_usertype_traits<T>::template rebind_actual_type<Element>;
+
+	template <typename T>
+	struct unique_usertype_traits : public detail::unique_fallback<T> { };
+
+	template <typename T>
+	struct is_unique_usertype : std::integral_constant<bool, meta::meta_detail::unique_valid<unique_usertype_traits<T>>::value> { };
+
+	template <typename T>
+	inline constexpr bool is_unique_usertype_v = is_unique_usertype<T>::value;
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_check_access_test_t
+			= decltype(sol_lua_check_access(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_access_v = meta::is_detected_v<adl_sol_lua_check_access_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_get_with_state_test_t
+			= decltype(unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_get_with_state_v = meta::is_detected_v<unique_usertype_get_with_state_test_t, T>;
+
+		template <typename T>
+		using unique_usertype_is_null_with_state_test_t
+			= decltype(unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<T>>()));
+
+		template <typename T>
+		inline constexpr bool unique_usertype_is_null_with_state_v = meta::is_detected_v<unique_usertype_is_null_with_state_test_t, T>;
+	}} // namespace meta::meta_detail
+
+	namespace detail {
+		template <typename T>
+		constexpr bool unique_is_null_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::is_null(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::is_null(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		bool unique_is_null(lua_State* L_, T& value_) noexcept(unique_is_null_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_is_null_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::is_null(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::is_null(value_);
+			}
+		}
+
+		template <typename T>
+		constexpr bool unique_get_noexcept() noexcept {
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<std::remove_cv_t<T>>) {
+				return noexcept(
+				     unique_usertype_traits<T>::get(static_cast<lua_State*>(nullptr), std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+			else {
+				return noexcept(unique_usertype_traits<T>::get(std::declval<unique_usertype_actual_t<std::remove_cv_t<T>>>()));
+			}
+		}
+
+		template <typename T>
+		auto unique_get(lua_State* L_, T& value_) noexcept(unique_get_noexcept<std::remove_cv_t<T>>()) {
+			using Tu = std::remove_cv_t<T>;
+			if constexpr (meta::meta_detail::unique_usertype_get_with_state_v<Tu>) {
+				return unique_usertype_traits<Tu>::get(L_, value_);
+			}
+			else {
+				return unique_usertype_traits<Tu>::get(value_);
+			}
+		}
+	} // namespace detail
+
+	namespace meta { namespace meta_detail {
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type_test_t = typename T::template rebind_actual_type<Element>;
+
+		template <typename T, typename Element = void>
+		using is_rebind_actual_type = meta::is_detected<is_rebind_actual_type_test_t, T, Element>;
+
+		template <typename T, typename Element = void>
+		inline constexpr bool is_rebind_actual_type_v = is_rebind_actual_type<T, Element>::value;
+
+		template <typename T, typename Element, bool = is_rebind_actual_type_v<T, Element>>
+		struct is_actual_type_rebindable_for_test : std::false_type { };
+
+		template <typename T, typename Element>
+		struct is_actual_type_rebindable_for_test<T, Element, true>
+		: std::integral_constant<bool, !std::is_void_v<typename T::template rebind_actual_type<Element>>> { };
+	}} // namespace meta::meta_detail
+
+	template <typename T, typename Element = void>
+	using is_actual_type_rebindable_for = typename meta::meta_detail::is_actual_type_rebindable_for_test<unique_usertype_traits<T>, Element>::type;
+
+	template <typename T, typename Element = void>
+	inline constexpr bool is_actual_type_rebindable_for_v = is_actual_type_rebindable_for<T, Element>::value;
+
+} // namespace sol
+
+// end of sol/unique_usertype_traits.hpp
+
+namespace sol {
+	template <typename... Args>
+	struct base_list { };
+	template <typename... Args>
+	using bases = base_list<Args...>;
+
+	typedef bases<> base_classes_tag;
+	const auto base_classes = base_classes_tag();
+
+	template <typename... Args>
+	struct is_to_stringable<base_list<Args...>> : std::false_type { };
+
+	namespace detail {
+
+		inline decltype(auto) base_class_check_key() {
+			static const auto& key = "class_check";
+			return key;
+		}
+
+		inline decltype(auto) base_class_cast_key() {
+			static const auto& key = "class_cast";
+			return key;
+		}
+
+		inline decltype(auto) base_class_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
+			return key;
+		}
+
+		inline decltype(auto) base_class_new_index_propogation_key() {
+			static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
+			return key;
+		}
+
+		template <typename T>
+		struct inheritance {
+			typedef typename base<T>::type bases_t;
+
+			static bool type_check_bases(types<>, const string_view&) {
+				return false;
+			}
+
+			template <typename Base, typename... Args>
+			static bool type_check_bases(types<Base, Args...>, const string_view& ti) {
+				return ti == usertype_traits<Base>::qualified_name() || type_check_bases(types<Args...>(), ti);
+			}
+
+			static bool type_check(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(bases_t(), ti);
+			}
+
+			template <typename... Bases>
+			static bool type_check_with(const string_view& ti) {
+				return ti == usertype_traits<T>::qualified_name() || type_check_bases(types<Bases...>(), ti);
+			}
+
+			static void* type_cast_bases(types<>, T*, const string_view&) {
+				return nullptr;
+			}
+
+			template <typename Base, typename... Args>
+			static void* type_cast_bases(types<Base, Args...>, T* data, const string_view& ti) {
+				// Make sure to convert to T first, and then dynamic cast to the proper type
+				return ti != usertype_traits<Base>::qualified_name() ? type_cast_bases(types<Args...>(), data, ti)
+				                                                     : static_cast<void*>(static_cast<Base*>(data));
+			}
+
+			static void* type_cast(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(bases_t(), data, ti) : data);
+			}
+
+			template <typename... Bases>
+			static void* type_cast_with(void* voiddata, const string_view& ti) {
+				T* data = static_cast<T*>(voiddata);
+				return static_cast<void*>(ti != usertype_traits<T>::qualified_name() ? type_cast_bases(types<Bases...>(), data, ti) : data);
+			}
+
+			template <typename U>
+			static bool type_unique_cast_bases(types<>, void*, void*, const string_view&) {
+				return 0;
+			}
+
+			template <typename U, typename Base, typename... Args>
+			static int type_unique_cast_bases(types<Base, Args...>, void* source_data, void* target_data, const string_view& ti) {
+				using uu_traits = unique_usertype_traits<U>;
+				using base_ptr = typename uu_traits::template rebind_actual_type<Base>;
+				string_view base_ti = usertype_traits<Base>::qualified_name();
+				if (base_ti == ti) {
+					if (target_data != nullptr) {
+						U* source = static_cast<U*>(source_data);
+						base_ptr* target = static_cast<base_ptr*>(target_data);
+						// perform proper derived -> base conversion
+						*target = *source;
+					}
+					return 2;
+				}
+				return type_unique_cast_bases<U>(types<Args...>(), source_data, target_data, ti);
+			}
+
+			template <typename U>
+			static int type_unique_cast(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using maybe_bases_or_empty = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(maybe_bases_or_empty(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+
+			template <typename U, typename... Bases>
+			static int type_unique_cast_with(void* source_data, void* target_data, const string_view& ti, const string_view& rebind_ti) {
+				using uc_bases_t = types<Bases...>;
+				if constexpr (is_actual_type_rebindable_for_v<U>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<U>;
+					using cond_bases_t = meta::conditional_t<std::is_void_v<rebound_actual_type>, types<>, uc_bases_t>;
+					string_view this_rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+					if (rebind_ti != this_rebind_ti) {
+						// this is not even of the same unique type
+						return 0;
+					}
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(cond_bases_t(), source_data, target_data, ti);
+				}
+				else {
+					(void)rebind_ti;
+					string_view this_ti = usertype_traits<T>::qualified_name();
+					if (ti == this_ti) {
+						// direct match, return 1
+						return 1;
+					}
+					return type_unique_cast_bases<U>(types<>(), source_data, target_data, ti);
+				}
+			}
+		};
+
+		using inheritance_check_function = decltype(&inheritance<void>::type_check);
+		using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
+		using inheritance_unique_cast_function = decltype(&inheritance<void>::type_unique_cast<void>);
+	} // namespace detail
+} // namespace sol
+
+// end of sol/inheritance.hpp
+
+// beginning of sol/error_handler.hpp
+
+#include <cstdio>
+
+namespace sol {
+
+	namespace detail {
+		constexpr const char* not_a_number = "not a numeric type";
+		constexpr const char* not_a_number_or_number_string = "not a numeric type or numeric string";
+		constexpr const char* not_a_number_integral = "not a numeric type that fits exactly an integer (number maybe has significant decimals)";
+		constexpr const char* not_a_number_or_number_string_integral
+		     = "not a numeric type or a numeric string that fits exactly an integer (e.g. number maybe has significant decimals)";
+
+		constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+		constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+		constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+		constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+		constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+		constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+		constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+		constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+		constexpr const char* protected_function_error = "caught (...) unknown error during protected_function call";
+
+		inline void accumulate_and_mark(const std::string& n, std::string& aux_message, int& marker) {
+			if (marker > 0) {
+				aux_message += ", ";
+			}
+			aux_message += n;
+			++marker;
+		}
+	} // namespace detail
+
+	inline std::string associated_type_name(lua_State* L, int index, type t) {
+		switch (t) {
+		case type::poly:
+			return "anything";
+		case type::userdata: {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 2, "not enough space to push get the type name");
+#endif // make sure stack doesn't overflow
+			if (lua_getmetatable(L, index) == 0) {
+				break;
+			}
+			lua_pushlstring(L, "__name", 6);
+			lua_rawget(L, -2);
+			size_t sz;
+			const char* name = lua_tolstring(L, -1, &sz);
+			std::string tn(name, static_cast<std::string::size_type>(sz));
+			lua_pop(L, 2);
+			return tn;
+		}
+		default:
+			break;
+		}
+		return lua_typename(L, static_cast<int>(t));
+	}
+
+	inline int push_type_panic_string(lua_State* L, int index, type expected, type actual, string_view message, string_view aux_message) noexcept {
+		const char* err = message.size() == 0
+		     ? (aux_message.size() == 0 ? "stack index %d, expected %s, received %s" : "stack index %d, expected %s, received %s: %s")
+		     : "stack index %d, expected %s, received %s: %s %s";
+		const char* type_name = expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected));
+		{
+			std::string actual_name = associated_type_name(L, index, actual);
+			lua_pushfstring(L, err, index, type_name, actual_name.c_str(), message.data(), aux_message.data());
+		}
+		return 1;
+	}
+
+	inline int type_panic_string(lua_State* L, int index, type expected, type actual, string_view message = "") noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message, "");
+		return lua_error(L);
+	}
+
+	inline int type_panic_c_str(lua_State* L, int index, type expected, type actual, const char* message = nullptr) noexcept(false) {
+		push_type_panic_string(L, index, expected, actual, message == nullptr ? "" : message, "");
+		return lua_error(L);
+	}
+
+	struct type_panic_t {
+		int operator()(lua_State* L, int index, type expected, type actual) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			return type_panic_c_str(L, index, expected, actual, message.data());
+		}
+	};
+
+	const type_panic_t type_panic = {};
+
+	struct constructor_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(type check failed in constructor)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename F = void>
+	struct argument_handler {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			push_type_panic_string(L, index, expected, actual, message, "(bad argument to variable or function call)");
+			return lua_error(L);
+		}
+	};
+
+	template <typename R, typename... Args>
+	struct argument_handler<types<R, Args...>> {
+		int operator()(lua_State* L, int index, type expected, type actual, string_view message) const noexcept(false) {
+			{
+				std::string aux_message = "(bad argument into '";
+				aux_message += detail::demangle<R>();
+				aux_message += "(";
+				int marker = 0;
+				(void)detail::swallow { int(), (detail::accumulate_and_mark(detail::demangle<Args>(), aux_message, marker), int())... };
+				aux_message += ")')";
+				push_type_panic_string(L, index, expected, actual, message, aux_message);
+			}
+			return lua_error(L);
+		}
+	};
+
+	// Specify this function as the handler for lua::check if you know there's nothing wrong
+	inline int no_panic(lua_State*, int, type, type, const char* = nullptr) noexcept {
+		return 0;
+	}
+
+	inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
+		luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
+	}
+
+	inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
+		type_error(L, static_cast<int>(expected), static_cast<int>(actual));
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
+		if (expected != type::poly && expected != actual) {
+			type_panic_c_str(L, index, expected, actual, nullptr);
+		}
+	}
+
+	inline void type_assert(lua_State* L, int index, type expected) {
+		type actual = type_of(L, index);
+		type_assert(L, index, expected, actual);
+	}
+
+} // namespace sol
+
+// end of sol/error_handler.hpp
+
+// beginning of sol/reference.hpp
+
+// beginning of sol/stack_reference.hpp
+
+namespace sol {
+	namespace detail {
+		inline bool xmovable(lua_State* leftL, lua_State* rightL) {
+			if (rightL == nullptr || leftL == nullptr || leftL == rightL) {
+				return false;
+			}
+			const void* leftregistry = lua_topointer(leftL, LUA_REGISTRYINDEX);
+			const void* rightregistry = lua_topointer(rightL, LUA_REGISTRYINDEX);
+			return leftregistry == rightregistry;
+		}
+	} // namespace detail
+
+	class stateless_stack_reference {
+	private:
+		friend class stack_reference;
+
+		int m_index = 0;
+
+		int registry_index() const noexcept {
+			return LUA_NOREF;
+		}
+
+	public:
+		stateless_stack_reference() noexcept = default;
+		stateless_stack_reference(lua_nil_t) noexcept : stateless_stack_reference() {};
+		stateless_stack_reference(lua_State* L_, int index_) noexcept : stateless_stack_reference(absolute_index(L_, index_)) {
+		}
+		stateless_stack_reference(lua_State*, absolute_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(lua_State*, raw_index index_) noexcept : stateless_stack_reference(index_) {
+		}
+		stateless_stack_reference(absolute_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(raw_index index_) noexcept : m_index(index_) {
+		}
+		stateless_stack_reference(lua_State*, ref_index) noexcept = delete;
+		stateless_stack_reference(ref_index) noexcept = delete;
+		stateless_stack_reference(const reference&) noexcept = delete;
+		stateless_stack_reference(const stateless_stack_reference&) noexcept = default;
+		stateless_stack_reference(stateless_stack_reference&& o) noexcept = default;
+		stateless_stack_reference& operator=(stateless_stack_reference&&) noexcept = default;
+		stateless_stack_reference& operator=(const stateless_stack_reference&) noexcept = default;
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int pop_count = 1) const noexcept {
+			lua_pop(L_, pop_count);
+		}
+
+		int stack_index() const noexcept {
+			return m_index;
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			const void* pointer_id = lua_topointer(L_, stack_index());
+			return pointer_id;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int untyped_value = lua_type(L_, stack_index());
+			return static_cast<type>(untyped_value);
+		}
+
+		bool valid(lua_State* L) const noexcept {
+			type t = get_type(L);
+			return t != type::lua_nil && t != type::none;
+		}
+
+		void reset(lua_State*) noexcept {
+			m_index = 0;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			m_index = absolute_index(L_, index_);
+		}
+
+		void abandon(lua_State* = nullptr) noexcept {
+			m_index = 0;
+		}
+
+		stateless_stack_reference copy(lua_State* L_) const noexcept {
+			return stateless_stack_reference(L_, raw_index(m_index));
+		}
+
+		void copy_assign(lua_State*, const stateless_stack_reference& right) noexcept {
+			m_index = right.m_index;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			return lua_compare(L_, this->stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	class stack_reference : public stateless_stack_reference {
+	private:
+		lua_State* luastate = nullptr;
+
+	public:
+		stack_reference() noexcept = default;
+		stack_reference(lua_nil_t) noexcept : stack_reference() {};
+		stack_reference(lua_State* L, lua_nil_t) noexcept : stateless_stack_reference(L, 0), luastate(L) {
+		}
+		stack_reference(lua_State* L, int i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, absolute_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, raw_index i) noexcept : stateless_stack_reference(L, i), luastate(L) {
+		}
+		stack_reference(lua_State* L, ref_index i) noexcept = delete;
+		stack_reference(lua_State* L, const reference& r) noexcept = delete;
+		stack_reference(lua_State* L, const stack_reference& r) noexcept : luastate(L) {
+			if (!r.valid()) {
+				m_index = 0;
+				return;
+			}
+			int i = r.stack_index();
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, "not enough Lua stack space to push a single reference value");
+#endif // make sure stack doesn't overflow
+				lua_pushvalue(r.lua_state(), r.stack_index());
+				lua_xmove(r.lua_state(), luastate, 1);
+				i = absolute_index(luastate, -1);
+			}
+			m_index = i;
+		}
+		stack_reference(stack_reference&& o) noexcept = default;
+		stack_reference& operator=(stack_reference&&) noexcept = default;
+		stack_reference(const stack_reference&) noexcept = default;
+		stack_reference& operator=(const stack_reference&) noexcept = default;
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		int push(lua_State* L_) const noexcept {
+			return stateless_stack_reference::push(L_);
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int pop_count_ = 1) const noexcept {
+			stateless_stack_reference::pop(L_, pop_count_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_stack_reference::pointer(lua_state());
+		}
+
+		type get_type() const noexcept {
+			return stateless_stack_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+
+		bool valid() const noexcept {
+			return stateless_stack_reference::valid(lua_state());
+		}
+
+		void abandon() {
+			stateless_stack_reference::abandon(lua_state());
+		}
+	};
+
+	inline bool operator==(const stack_reference& l, const stack_reference& r) {
+		return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	inline bool operator!=(const stack_reference& l, const stack_reference& r) {
+		return !operator==(l, r);
+	}
+
+	inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
+		return !lhs.valid();
+	}
+
+	inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
+		return !rhs.valid();
+	}
+
+	inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
+		return lhs.valid();
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() == r.stack_index();
+	}
+
+	inline bool operator!=(const stateless_stack_reference& l, const stateless_stack_reference& r) {
+		return l.stack_index() != r.stack_index();
+	}
+
+	struct stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_equals(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, const stateless_stack_reference& rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(lua_nil_t lhs, const stateless_stack_reference& rhs) const {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_stack_reference& lhs, lua_nil_t rhs) const {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		bool operator()(const lua_nil_t& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const lua_nil_t& rhs) const {
+			return lhs == rhs;
+		}
+
+		bool operator()(const stack_reference& lhs, const stack_reference& rhs) const {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_stack_reference_hash {
+		using argument_type = stateless_stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_stack_reference_hash(lua_State* L_) noexcept : m_L(L_) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return m_L;
+		}
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+
+	private:
+		lua_State* m_L;
+	};
+
+	struct stack_reference_hash {
+		using argument_type = stack_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		result_type operator()(const argument_type& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_reference.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline const char (&default_main_thread_name())[9] {
+			static const char name[9] = "sol.\xF0\x9F\x93\x8C";
+			return name;
+		}
+	} // namespace detail
+
+	namespace stack {
+		inline void remove(lua_State* L_, int rawindex, int count) {
+			if (count < 1)
+				return;
+			int top = lua_gettop(L_);
+			if (top < 1) {
+				return;
+			}
+			if (rawindex == -count || top == rawindex) {
+				// Slice them right off the top
+				lua_pop(L_, static_cast<int>(count));
+				return;
+			}
+
+			// Remove each item one at a time using stack operations
+			// Probably slower, maybe, haven't benchmarked,
+			// but necessary
+			int index = lua_absindex(L_, rawindex);
+			if (index < 0) {
+				index = lua_gettop(L_) + (index + 1);
+			}
+			int last = index + count;
+			for (int i = index; i < last; ++i) {
+				lua_remove(L_, index);
+			}
+		}
+
+		struct push_popper_at {
+			lua_State* L;
+			int index;
+			int count;
+			push_popper_at(lua_State* L_, int index_ = -1, int count_ = 1) : L(L_), index(index_), count(count_) {
+			}
+			~push_popper_at() {
+				remove(L, index, count);
+			}
+		};
+
+		template <bool top_level>
+		struct push_popper_n {
+			lua_State* L;
+			int pop_count;
+			push_popper_n(lua_State* L_, int pop_count_) : L(L_), pop_count(pop_count_) {
+			}
+			push_popper_n(const push_popper_n&) = delete;
+			push_popper_n(push_popper_n&&) = default;
+			push_popper_n& operator=(const push_popper_n&) = delete;
+			push_popper_n& operator=(push_popper_n&&) = default;
+			~push_popper_n() {
+				lua_pop(L, pop_count);
+			}
+		};
+
+		template <>
+		struct push_popper_n<true> {
+			push_popper_n(lua_State*, int) {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct push_popper {
+			using Tu = meta::unqualified_t<T>;
+			T m_object;
+			int m_index;
+
+			push_popper(T object_) noexcept : m_object(object_), m_index(lua_absindex(m_object.lua_state(), -m_object.push())) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~push_popper() {
+				m_object.pop();
+			}
+		};
+
+		template <typename T, typename C>
+		struct push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return -1;
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+
+			push_popper(T) noexcept {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~push_popper() {
+			}
+		};
+
+		template <bool, typename T, typename = void>
+		struct stateless_push_popper {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+			T m_object;
+			int m_index;
+
+			stateless_push_popper(lua_State* L_, T object_) noexcept : m_L(L_), m_object(object_), m_index(lua_absindex(m_L, -m_object.push(m_L))) {
+			}
+
+			int index_of(const Tu&) const noexcept {
+				return m_index;
+			}
+
+			~stateless_push_popper() {
+				m_object.pop(m_L);
+			}
+		};
+
+		template <typename T, typename C>
+		struct stateless_push_popper<true, T, C> {
+			using Tu = meta::unqualified_t<T>;
+
+			stateless_push_popper(lua_State*, T) noexcept {
+			}
+
+			int index_of(lua_State*, const Tu&) const noexcept {
+				return -1;
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <typename T>
+		struct stateless_push_popper<false, T, std::enable_if_t<is_stack_based_v<meta::unqualified_t<T>>>> {
+			using Tu = meta::unqualified_t<T>;
+			lua_State* m_L;
+
+			stateless_push_popper(lua_State* L_, T) noexcept : m_L(L_) {
+			}
+
+			int index_of(const Tu& object_) const noexcept {
+				return object_.stack_index();
+			}
+
+			~stateless_push_popper() {
+			}
+		};
+
+		template <bool top_level = false, typename T>
+		push_popper<top_level, T> push_pop(T&& x) {
+			return push_popper<top_level, T>(std::forward<T>(x));
+		}
+
+		template <bool top_level = false, typename T>
+		stateless_push_popper<top_level, T> push_pop(lua_State* L_, T&& object_) {
+			return stateless_push_popper<top_level, T>(L_, std::forward<T>(object_));
+		}
+
+		template <typename T>
+		push_popper_at push_pop_at(T&& object_) {
+			int push_count = object_.push();
+			lua_State* L = object_.lua_state();
+			return push_popper_at(L, lua_absindex(L, -push_count), push_count);
+		}
+
+		template <bool top_level = false>
+		push_popper_n<top_level> pop_n(lua_State* L_, int pop_count_) {
+			return push_popper_n<top_level>(L_, pop_count_);
+		}
+	} // namespace stack
+
+	inline lua_State* main_thread(lua_State* L_, lua_State* backup_if_unsupported_ = nullptr) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_getglobal(L_, detail::default_main_thread_name());
+		auto pp = stack::pop_n(L_, 1);
+		if (type_of(L_, -1) == type::thread) {
+			return lua_tothread(L_, -1);
+		}
+		return backup_if_unsupported_;
+#else
+		if (L_ == nullptr)
+			return backup_if_unsupported_;
+		lua_rawgeti(L_, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
+		lua_State* Lmain = lua_tothread(L_, -1);
+		lua_pop(L_, 1);
+		return Lmain;
+#endif // Lua 5.2+ has the main thread unqualified_getter
+	}
+
+	namespace detail {
+		struct no_safety_tag {
+		} inline constexpr no_safety {};
+
+		template <bool b>
+		inline lua_State* pick_main_thread(lua_State* L_, lua_State* backup_if_unsupported = nullptr) {
+			(void)L_;
+			(void)backup_if_unsupported;
+			if (b) {
+				return main_thread(L_, backup_if_unsupported);
+			}
+			return L_;
+		}
+	} // namespace detail
+
+	class stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+
+		int ref = LUA_NOREF;
+
+		int copy_ref(lua_State* L_) const noexcept {
+			if (ref == LUA_NOREF)
+				return LUA_NOREF;
+			push(L_);
+			return luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		lua_State* copy_assign_ref(lua_State* L_, lua_State* rL, const stateless_reference& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.copy_ref(L_);
+			return rL;
+		}
+
+		lua_State* move_assign(lua_State* L_, lua_State* rL, stateless_reference&& r) {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			return rL;
+		}
+
+	protected:
+		int stack_index() const noexcept {
+			return -1;
+		}
+
+		stateless_reference(lua_State* L_, global_tag_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushglobaltable(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(int raw_ref_index) noexcept : ref(raw_ref_index) {
+		}
+
+	public:
+		stateless_reference() noexcept = default;
+		stateless_reference(lua_nil_t) noexcept : stateless_reference() {
+		}
+		stateless_reference(const stack_reference& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(stack_reference&& r) noexcept : stateless_reference(r.lua_state(), r.stack_index()) {
+		}
+		stateless_reference(lua_State* L_, const stateless_reference& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.copy_ref(L_);
+		}
+
+		stateless_reference(lua_State* L_, stateless_reference&& r) noexcept {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || L_ == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+		}
+
+		stateless_reference(lua_State* L_, const stack_reference& r) noexcept {
+			if (L_ == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (L_ != r.lua_state() && !detail::xmovable(L_, r.lua_state())) {
+				return;
+			}
+			r.push(L_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		stateless_reference(lua_State* L_, const stateless_stack_reference& r) noexcept : stateless_reference(L_, r.stack_index()) {
+		}
+
+		stateless_reference(lua_State* L_, int index = -1) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State* L_, absolute_index index_) noexcept : stateless_reference(L_, index_.index) {
+		}
+		stateless_reference(lua_State* L_, ref_index index_) noexcept {
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, index_.index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		stateless_reference(lua_State*, lua_nil_t) noexcept {
+		}
+
+		~stateless_reference() noexcept = default;
+
+		stateless_reference(const stateless_reference& o) noexcept = delete;
+		stateless_reference& operator=(const stateless_reference& r) noexcept = delete;
+
+		stateless_reference(stateless_reference&& o) noexcept : ref(o.ref) {
+			o.ref = LUA_NOREF;
+		}
+
+		stateless_reference& operator=(stateless_reference&& o) noexcept {
+			ref = o.ref;
+			o.ref = LUA_NOREF;
+			return *this;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L_, LUA_REGISTRYINDEX, ref);
+			return 1;
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			lua_pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return ref;
+		}
+
+		void reset(lua_State* L_) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			ref = LUA_NOREF;
+		}
+
+		void reset(lua_State* L_, int index_) noexcept {
+			reset(L_);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index_);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+
+		bool valid(lua_State*) const noexcept {
+			return !(ref == LUA_NOREF || ref == LUA_REFNIL);
+		}
+
+		const void* pointer(lua_State* L_) const noexcept {
+			int si = push(L_);
+			const void* vp = lua_topointer(L_, -si);
+			lua_pop(L_, si);
+			return vp;
+		}
+
+		type get_type(lua_State* L_) const noexcept {
+			int p = push(L_);
+			int result = lua_type(L_, -1);
+			pop(L_, p);
+			return static_cast<type>(result);
+		}
+
+		void abandon(lua_State* = nullptr) {
+			ref = LUA_NOREF;
+		}
+
+		void deref(lua_State* L_) const noexcept {
+			luaL_unref(L_, LUA_REGISTRYINDEX, ref);
+		}
+
+		stateless_reference copy(lua_State* L_) const noexcept {
+			if (!valid(L_)) {
+				return {};
+			}
+			return stateless_reference(copy_ref(L_));
+		}
+
+		void copy_assign(lua_State* L_, const stateless_reference& right) noexcept {
+			if (valid(L_)) {
+				deref(L_);
+			}
+			if (!right.valid(L_)) {
+				return;
+			}
+			ref = right.copy_ref(L_);
+		}
+
+		bool equals(lua_State* L_, const stateless_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			auto ppr = stack::push_pop(L_, r);
+			return lua_compare(L_, -1, -2, LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, const stateless_stack_reference& r) const noexcept {
+			auto ppl = stack::push_pop(L_, *this);
+			return lua_compare(L_, -1, r.stack_index(), LUA_OPEQ) == 1;
+		}
+
+		bool equals(lua_State* L_, lua_nil_t) const noexcept {
+			return valid(L_);
+		}
+	};
+
+	template <bool main_only = false>
+	class basic_reference : public stateless_reference {
+	private:
+		template <bool o_main_only>
+		friend class basic_reference;
+		lua_State* luastate = nullptr; // non-owning
+
+		template <bool r_main_only>
+		void copy_assign_complex(const basic_reference<r_main_only>& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		void move_assign(basic_reference<r_main_only>&& r) {
+			if (valid()) {
+				deref();
+			}
+			if (r.ref == LUA_REFNIL) {
+				luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF) {
+				luastate = r.luastate;
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+
+			luastate = detail::pick_main_thread < main_only && !r_main_only > (r.lua_state(), r.lua_state());
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+	protected:
+		basic_reference(lua_State* L_, global_tag_t) noexcept : basic_reference(detail::pick_main_thread<main_only>(L_, L_), global_tag, global_tag) {
+		}
+
+		basic_reference(lua_State* L_, global_tag_t, global_tag_t) noexcept : stateless_reference(L_, global_tag), luastate(L_) {
+		}
+
+		basic_reference(lua_State* oL, const basic_reference<!main_only>& o) noexcept : stateless_reference(oL, o), luastate(oL) {
+		}
+
+		void deref() const noexcept {
+			return stateless_reference::deref(lua_state());
+		}
+
+		int copy_ref() const noexcept {
+			return copy_ref(lua_state());
+		}
+
+		int copy_ref(lua_State* L_) const noexcept {
+			return stateless_reference::copy_ref(L_);
+		}
+
+	public:
+		basic_reference() noexcept = default;
+		basic_reference(lua_nil_t) noexcept : basic_reference() {
+		}
+		basic_reference(const stack_reference& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		basic_reference(stack_reference&& r) noexcept : basic_reference(r.lua_state(), r.stack_index()) {
+		}
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, const basic_reference<r_main_only>& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.copy_ref();
+		}
+
+		template <bool r_main_only>
+		basic_reference(lua_State* L_, basic_reference<r_main_only>&& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (r.ref == LUA_REFNIL) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (r.ref == LUA_NOREF || lua_state() == nullptr) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (detail::xmovable(lua_state(), r.lua_state())) {
+				r.push(lua_state());
+				ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+				return;
+			}
+			ref = r.ref;
+			r.ref = LUA_NOREF;
+			r.luastate = nullptr;
+		}
+
+		basic_reference(lua_State* L_, const stack_reference& r) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			if (lua_state() == nullptr || r.lua_state() == nullptr || r.get_type() == type::none) {
+				ref = LUA_NOREF;
+				return;
+			}
+			if (r.get_type() == type::lua_nil) {
+				ref = LUA_REFNIL;
+				return;
+			}
+			if (lua_state() != r.lua_state() && !detail::xmovable(lua_state(), r.lua_state())) {
+				return;
+			}
+			r.push(lua_state());
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, int index = -1) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			// use L_ to stick with that state's execution stack
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L_, index);
+			ref = luaL_ref(L_, LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, ref_index index) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, index.index);
+			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
+		}
+		basic_reference(lua_State* L_, lua_nil_t) noexcept : luastate(detail::pick_main_thread<main_only>(L_, L_)) {
+		}
+
+		~basic_reference() noexcept {
+			if (lua_state() == nullptr || ref == LUA_NOREF)
+				return;
+			deref();
+		}
+
+		basic_reference(const basic_reference& o) noexcept : stateless_reference(o.copy_ref()), luastate(o.lua_state()) {
+		}
+
+		basic_reference(basic_reference&& o) noexcept : stateless_reference(std::move(o)), luastate(o.lua_state()) {
+			o.luastate = nullptr;
+		}
+
+		basic_reference(const basic_reference<!main_only>& o) noexcept
+		: basic_reference(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state()), o) {
+		}
+
+		basic_reference(basic_reference<!main_only>&& o) noexcept
+		: stateless_reference(std::move(o)), luastate(detail::pick_main_thread<main_only>(o.lua_state(), o.lua_state())) {
+			o.luastate = nullptr;
+			o.ref = LUA_NOREF;
+		}
+
+		basic_reference& operator=(basic_reference&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(basic_reference<!main_only>&& r) noexcept {
+			move_assign(std::move(r));
+			return *this;
+		}
+
+		basic_reference& operator=(const basic_reference<!main_only>& r) noexcept {
+			copy_assign_complex(r);
+			return *this;
+		}
+
+		basic_reference& operator=(const lua_nil_t&) noexcept {
+			reset();
+			return *this;
+		}
+
+		template <typename Super>
+		basic_reference& operator=(proxy_base<Super>&& r);
+
+		template <typename Super>
+		basic_reference& operator=(const proxy_base<Super>& r);
+
+		int push() const noexcept {
+			return push(lua_state());
+		}
+
+		void reset() noexcept {
+			stateless_reference::reset(luastate);
+			luastate = nullptr;
+		}
+
+		int push(lua_State* L_) const noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L_, 1, "not enough Lua stack space to push this reference value");
+#endif // make sure stack doesn't overflow
+			if (lua_state() == nullptr) {
+				lua_pushnil(L_);
+				return 1;
+			}
+			lua_rawgeti(lua_state(), LUA_REGISTRYINDEX, ref);
+			if (L_ != lua_state()) {
+				lua_xmove(lua_state(), L_, 1);
+			}
+			return 1;
+		}
+
+		void pop() const noexcept {
+			pop(lua_state());
+		}
+
+		void pop(lua_State* L_, int n = 1) const noexcept {
+			stateless_reference::pop(L_, n);
+		}
+
+		int registry_index() const noexcept {
+			return stateless_reference::registry_index();
+		}
+
+		bool valid() const noexcept {
+			return stateless_reference::valid(lua_state());
+		}
+
+		bool valid(lua_State* L_) const noexcept {
+			return stateless_reference::valid(L_);
+		}
+
+		const void* pointer() const noexcept {
+			return stateless_reference::pointer(lua_state());
+		}
+
+		explicit operator bool() const noexcept {
+			return valid();
+		}
+
+		type get_type() const noexcept {
+			return stateless_reference::get_type(lua_state());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return luastate;
+		}
+	};
+
+	template <bool lb, bool rb>
+	inline bool operator==(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
+	}
+
+	template <bool lb, bool rb>
+	inline bool operator!=(const basic_reference<lb>& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		auto ppl = stack::push_pop(l);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& l, const stack_reference& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool rb>
+	inline bool operator==(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		auto ppr = stack::push_pop(r);
+		return lua_compare(l.lua_state(), -1, r.stack_index(), LUA_OPEQ) == 1;
+	}
+
+	template <bool rb>
+	inline bool operator!=(const stack_reference& l, const basic_reference<rb>& r) noexcept {
+		return !operator==(l, r);
+	}
+
+	template <bool lb>
+	inline bool operator==(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return !lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator==(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return !rhs.valid();
+	}
+
+	template <bool lb>
+	inline bool operator!=(const basic_reference<lb>& lhs, const lua_nil_t&) noexcept {
+		return lhs.valid();
+	}
+
+	template <bool rb>
+	inline bool operator!=(const lua_nil_t&, const basic_reference<rb>& rhs) noexcept {
+		return rhs.valid();
+	}
+
+	inline bool operator==(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() == r.registry_index();
+	}
+
+	inline bool operator!=(const stateless_reference& l, const stateless_reference& r) noexcept {
+		return l.registry_index() != r.registry_index();
+	}
+
+	inline bool operator==(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator==(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() == LUA_REFNIL;
+	}
+
+	inline bool operator!=(const stateless_reference& lhs, const lua_nil_t&) noexcept {
+		return lhs.registry_index() != LUA_REFNIL;
+	}
+
+	inline bool operator!=(const lua_nil_t&, const stateless_reference& rhs) noexcept {
+		return rhs.registry_index() != LUA_REFNIL;
+	}
+
+	struct stateless_reference_equals : public stateless_stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		stateless_reference_equals(lua_State* L_) noexcept : stateless_stack_reference_equals(L_) {
+		}
+
+		bool operator()(const lua_nil_t& lhs, const stateless_reference& rhs) const noexcept {
+			return rhs.equals(lua_state(), lhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+
+		bool operator()(const stateless_reference& lhs, const stateless_reference& rhs) const noexcept {
+			return lhs.equals(lua_state(), rhs);
+		}
+	};
+
+	struct reference_equals : public stack_reference_equals {
+		using is_transparent = std::true_type;
+
+		template <bool rb>
+		bool operator()(const lua_nil_t& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const lua_nil_t& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb, bool rb>
+		bool operator()(const basic_reference<lb>& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool lb>
+		bool operator()(const basic_reference<lb>& lhs, const stack_reference& rhs) const noexcept {
+			return lhs == rhs;
+		}
+
+		template <bool rb>
+		bool operator()(const stack_reference& lhs, const basic_reference<rb>& rhs) const noexcept {
+			return lhs == rhs;
+		}
+	};
+
+	struct stateless_reference_hash : public stateless_stack_reference_hash {
+		using argument_type = stateless_reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		stateless_reference_hash(lua_State* L_) noexcept : stateless_stack_reference_hash(L_) {
+		}
+
+		result_type operator()(const stateless_reference& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer(lua_state()));
+		}
+	};
+
+	struct reference_hash : public stack_reference_hash {
+		using argument_type = reference;
+		using result_type = std::size_t;
+		using is_transparent = std::true_type;
+
+		template <bool lb>
+		result_type operator()(const basic_reference<lb>& lhs) const noexcept {
+			std::hash<const void*> h;
+			return h(lhs.pointer());
+		}
+	};
+} // namespace sol
+
+// end of sol/reference.hpp
+
+// beginning of sol/tie.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		struct is_speshul : std::false_type { };
+	} // namespace detail
+
+	template <typename T>
+	struct tie_size : std::tuple_size<T> { };
+
+	template <typename T>
+	struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> { };
+
+	template <typename... Tn>
+	struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
+	private:
+		typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
+
+		template <typename T>
+		void set(std::false_type, T&& target) {
+			std::get<0>(*this) = std::forward<T>(target);
+		}
+
+		template <typename T>
+		void set(std::true_type, T&& target) {
+			typedef tie_size<meta::unqualified_t<T>> value_size;
+			typedef tie_size<std::tuple<Tn...>> tie_size;
+			typedef meta::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
+			typedef std::make_index_sequence<indices_size::value> indices;
+			set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)..., 0 };
+		}
+
+		template <std::size_t... I, typename T>
+		void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
+			using std::get;
+			(void)detail::swallow { 0, (get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)..., 0 };
+		}
+
+	public:
+		using base_t::base_t;
+
+		template <typename T>
+		tie_t& operator=(T&& value) {
+			typedef is_tieable<meta::unqualified_t<T>> tieable;
+			set(tieable(), std::forward<T>(value));
+			return *this;
+		}
+	};
+
+	template <typename... Tn>
+	struct tie_size<tie_t<Tn...>> : std::tuple_size<std::tuple<Tn...>> { };
+
+	namespace adl_barrier_detail {
+		template <typename... Tn>
+		inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
+			return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
+		}
+	} // namespace adl_barrier_detail
+
+	using namespace adl_barrier_detail;
+
+} // namespace sol
+
+// end of sol/tie.hpp
+
+// beginning of sol/stack_guard.hpp
+
+#include <functional>
+
+namespace sol {
+	namespace detail {
+		inline void stack_fail(int, int) {
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+			throw error(detail::direct_error, "imbalanced stack after operation finish");
+#else
+			// Lol, what do you want, an error printout? :3c
+			// There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
+			// hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
+#endif // No Exceptions
+		}
+	} // namespace detail
+
+	struct stack_guard {
+		lua_State* L;
+		int top;
+		std::function<void(int, int)> on_mismatch;
+
+		stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {
+		}
+		stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {
+		}
+		bool check_stack(int modification = 0) const {
+			int bottom = lua_gettop(L) + modification;
+			if (top == bottom) {
+				return true;
+			}
+			on_mismatch(top, bottom);
+			return false;
+		}
+		~stack_guard() {
+			check_stack();
+		}
+	};
+} // namespace sol
+
+// end of sol/stack_guard.hpp
+
+#include <vector>
+#include <bitset>
+#include <forward_list>
+#include <string>
+#include <limits>
+#include <algorithm>
+#include <sstream>
+#include <optional>
+#include <type_traits>
+
+namespace sol {
+	namespace detail {
+		struct with_function_tag { };
+		struct as_reference_tag { };
+		template <typename T>
+		struct as_pointer_tag { };
+		template <typename T>
+		struct as_value_tag { };
+		template <typename T>
+		struct as_unique_tag { };
+		template <typename T>
+		struct as_table_tag { };
+
+		template <typename Tag>
+		inline constexpr bool is_tagged_v
+		     = meta::is_specialization_of_v<Tag,
+		            detail::
+		                 as_pointer_tag> || meta::is_specialization_of_v<Tag, as_value_tag> || meta::is_specialization_of_v<Tag, as_unique_tag> || meta::is_specialization_of_v<Tag, as_table_tag> || std::is_same_v<Tag, as_reference_tag> || std::is_same_v<Tag, with_function_tag>;
+
+		using lua_reg_table = luaL_Reg[64];
+
+		using unique_destructor = void (*)(void*);
+		using unique_tag = detail::inheritance_unique_cast_function;
+
+		inline void* alloc_newuserdata(lua_State* L, std::size_t bytesize) {
+#if SOL_LUA_VERSION_I_ >= 504
+			return lua_newuserdatauv(L, bytesize, 1);
+#else
+			return lua_newuserdata(L, bytesize);
+#endif
+		}
+
+		constexpr std::uintptr_t align(std::size_t alignment, std::uintptr_t ptr, std::size_t& space) {
+			// this handles arbitrary alignments...
+			// make this into a power-of-2-only?
+			// actually can't: this is a C++14-compatible framework,
+			// power of 2 alignment is C++17
+			std::uintptr_t offby = static_cast<std::uintptr_t>(ptr % alignment);
+			std::uintptr_t padding = (alignment - offby) % alignment;
+			ptr += padding;
+			space -= padding;
+			return ptr;
+		}
+
+		inline void* align(std::size_t alignment, void* ptr, std::size_t& space) {
+			return reinterpret_cast<void*>(align(alignment, reinterpret_cast<std::uintptr_t>(ptr), space));
+		}
+
+		constexpr std::uintptr_t align_one(std::size_t alignment, std::size_t size, std::uintptr_t ptr) {
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(alignment, ptr, space) + size;
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for(std::uintptr_t ptr) {
+			std::uintptr_t end = ptr;
+			((end = align_one(alignof(Args), sizeof(Args), end)), ...);
+			return static_cast<std::size_t>(end - ptr);
+		}
+
+		template <typename... Args>
+		constexpr std::size_t aligned_space_for() {
+			static_assert(sizeof...(Args) > 0);
+
+			constexpr std::size_t max_arg_alignment = (std::max)({ alignof(Args)... });
+			if constexpr (max_arg_alignment <= alignof(std::max_align_t)) {
+				// If all types are `good enough`, simply calculate alignment in case of the worst allocator
+				std::size_t worst_required_size = 0;
+				for (std::size_t ptr = 0; ptr < max_arg_alignment; ptr++) {
+					worst_required_size = (std::max)(worst_required_size, aligned_space_for<Args...>(ptr));
+				}
+				return worst_required_size;
+			}
+			else {
+				// For over-aligned types let's assume that every Arg in Args starts at the worst aligned address
+				return (aligned_space_for<Args>(0x1) + ...);
+			}
+		}
+
+		inline void* align_usertype_pointer(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<void*>::value > 1)
+#endif
+			     >;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<void*>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_destructor(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_destructor>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_pointer(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(void*));
+			}
+			if (!use_align::value) {
+				return static_cast<void*>(static_cast<void**>(ptr) + 1);
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_destructor>::value, ptr, space);
+		}
+
+		template <bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique_tag(void* ptr) {
+			using use_align = std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<unique_tag>::value > 1)
+#endif
+			     >;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_destructor(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_destructor));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of<unique_tag>::value, ptr, space);
+		}
+
+		template <typename T, bool pre_aligned = false, bool pre_shifted = false>
+		void* align_usertype_unique(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!pre_aligned) {
+				ptr = align_usertype_unique_tag(ptr);
+			}
+			if (!pre_shifted) {
+				ptr = static_cast<void*>(static_cast<char*>(ptr) + sizeof(unique_tag));
+			}
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		void* align_user(void* ptr) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				return ptr;
+			}
+			std::size_t space = (std::numeric_limits<std::size_t>::max)();
+			return align(std::alignment_of_v<T>, ptr, space);
+		}
+
+		template <typename T>
+		T** usertype_allocate_pointer(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*)));
+				return pointerpointer;
+			}
+			constexpr std::size_t initial_size = aligned_space_for<T*>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, initial_size);
+			void* adjusted = align(std::alignment_of<T*>::value, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				// trash allocator can burn in hell
+				lua_pop(L, 1);
+				// luaL_error(L, "if you are the one that wrote this allocator you should feel bad for doing a
+				// worse job than malloc/realloc and should go read some books, yeah?");
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T*>().data());
+			}
+			return static_cast<T**>(adjusted);
+		}
+
+		inline bool attempt_alloc(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t value_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			// subtract size of what we're going to allocate there
+			allocated_size -= ptr_size;
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			data_adjusted = align(value_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		inline bool attempt_alloc_unique(lua_State* L, std::size_t ptr_align, std::size_t ptr_size, std::size_t real_align,
+		     std::size_t allocated_size, void*& pointer_adjusted, void*& dx_adjusted, void*& id_adjusted, void*& data_adjusted) {
+			void* adjusted = alloc_newuserdata(L, allocated_size);
+			pointer_adjusted = align(ptr_align, adjusted, allocated_size);
+			if (pointer_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= ptr_size;
+
+			adjusted = static_cast<void*>(static_cast<char*>(pointer_adjusted) + ptr_size);
+			dx_adjusted = align(std::alignment_of_v<unique_destructor>, adjusted, allocated_size);
+			if (dx_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_destructor);
+
+			adjusted = static_cast<void*>(static_cast<char*>(dx_adjusted) + sizeof(unique_destructor));
+
+			id_adjusted = align(std::alignment_of_v<unique_tag>, adjusted, allocated_size);
+			if (id_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			allocated_size -= sizeof(unique_tag);
+
+			adjusted = static_cast<void*>(static_cast<char*>(id_adjusted) + sizeof(unique_tag));
+			data_adjusted = align(real_align, adjusted, allocated_size);
+			if (data_adjusted == nullptr) {
+				lua_pop(L, 1);
+				return false;
+			}
+			return true;
+		}
+
+		template <typename T>
+		T* usertype_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T** pointerpointer = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(T)));
+				T*& pointerreference = *pointerpointer;
+				T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
+				pointerreference = allocationtarget;
+				return allocationtarget;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, T>();
+
+			void* pointer_adjusted;
+			void* data_adjusted;
+			bool result
+			     = attempt_alloc(L, std::alignment_of_v<T*>, sizeof(T*), std::alignment_of_v<T>, initial_size, pointer_adjusted, data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			T** pointerpointer = reinterpret_cast<T**>(pointer_adjusted);
+			T*& pointerreference = *pointerpointer;
+			T* allocationtarget = reinterpret_cast<T*>(data_adjusted);
+			pointerreference = allocationtarget;
+			return allocationtarget;
+		}
+
+		template <typename T, typename Real>
+		Real* usertype_unique_allocate(lua_State* L, T**& pref, unique_destructor*& dx, unique_tag*& id) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of<T*>::value > 1 || std::alignment_of<unique_tag>::value > 1 || std::alignment_of<unique_destructor>::value > 1
+			          || std::alignment_of<Real>::value > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				pref = static_cast<T**>(alloc_newuserdata(L, sizeof(T*) + sizeof(detail::unique_destructor) + sizeof(unique_tag) + sizeof(Real)));
+				dx = static_cast<detail::unique_destructor*>(static_cast<void*>(pref + 1));
+				id = static_cast<unique_tag*>(static_cast<void*>(dx + 1));
+				Real* mem = static_cast<Real*>(static_cast<void*>(id + 1));
+				return mem;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T*, unique_destructor, unique_tag, Real>();
+
+			void* pointer_adjusted;
+			void* dx_adjusted;
+			void* id_adjusted;
+			void* data_adjusted;
+			bool result = attempt_alloc_unique(L,
+			     std::alignment_of_v<T*>,
+			     sizeof(T*),
+			     std::alignment_of_v<Real>,
+			     initial_size,
+			     pointer_adjusted,
+			     dx_adjusted,
+			     id_adjusted,
+			     data_adjusted);
+			if (!result) {
+				if (pointer_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (pointer section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else if (dx_adjusted == nullptr) {
+					luaL_error(L, "aligned allocation of userdata block (deleter section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				else {
+					luaL_error(L, "aligned allocation of userdata block (data section) for '%s' failed", detail::demangle<T>().c_str());
+				}
+				return nullptr;
+			}
+
+			pref = static_cast<T**>(pointer_adjusted);
+			dx = static_cast<detail::unique_destructor*>(dx_adjusted);
+			id = static_cast<unique_tag*>(id_adjusted);
+			Real* mem = static_cast<Real*>(data_adjusted);
+			return mem;
+		}
+
+		template <typename T>
+		T* user_allocate(lua_State* L) {
+			typedef std::integral_constant<bool,
+#if SOL_IS_OFF(SOL_ALIGN_MEMORY)
+			     false
+#else
+			     (std::alignment_of_v<T> > 1)
+#endif
+			     >
+			     use_align;
+			if (!use_align::value) {
+				T* pointer = static_cast<T*>(alloc_newuserdata(L, sizeof(T)));
+				return pointer;
+			}
+
+			constexpr std::size_t initial_size = aligned_space_for<T>();
+
+			std::size_t allocated_size = initial_size;
+			void* unadjusted = alloc_newuserdata(L, allocated_size);
+			void* adjusted = align(std::alignment_of_v<T>, unadjusted, allocated_size);
+			if (adjusted == nullptr) {
+				lua_pop(L, 1);
+				luaL_error(L, "cannot properly align memory for '%s'", detail::demangle<T>().data());
+			}
+			return static_cast<T*>(adjusted);
+		}
+
+		template <typename T>
+		int usertype_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_pointer(memory);
+			T** pdata = static_cast<T**>(memory);
+			T* data = *pdata;
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, data);
+			return 0;
+		}
+
+		template <typename T>
+		int unique_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			memory = align_usertype_unique_destructor(memory);
+			unique_destructor& dx = *static_cast<unique_destructor*>(memory);
+			memory = align_usertype_unique_tag<true>(memory);
+			(dx)(memory);
+			return 0;
+		}
+
+		template <typename T>
+		int user_alloc_destroy(lua_State* L) noexcept {
+			void* memory = lua_touserdata(L, 1);
+			void* aligned_memory = align_user<T>(memory);
+			T* typed_memory = static_cast<T*>(aligned_memory);
+			std::allocator<T> alloc;
+			std::allocator_traits<std::allocator<T>>::destroy(alloc, typed_memory);
+			return 0;
+		}
+
+		template <typename T, typename Real>
+		void usertype_unique_alloc_destroy(void* memory) {
+			void* aligned_memory = align_usertype_unique<Real, true>(memory);
+			Real* typed_memory = static_cast<Real*>(aligned_memory);
+			std::allocator<Real> alloc;
+			std::allocator_traits<std::allocator<Real>>::destroy(alloc, typed_memory);
+		}
+
+		template <typename T>
+		int cannot_destroy(lua_State* L) {
+			return luaL_error(L,
+			     "cannot call the destructor for '%s': it is either hidden (protected/private) or removed with '= "
+			     "delete' and thusly this type is being destroyed without properly destroying, invoking undefined "
+			     "behavior: please bind a usertype and specify a custom destructor to define the behavior properly",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		void reserve(T&, std::size_t) {
+		}
+
+		template <typename T, typename Al>
+		void reserve(std::vector<T, Al>& vec, std::size_t hint) {
+			vec.reserve(hint);
+		}
+
+		template <typename T, typename Tr, typename Al>
+		void reserve(std::basic_string<T, Tr, Al>& str, std::size_t hint) {
+			str.reserve(hint);
+		}
+
+		inline bool property_always_true(meta_function) {
+			return true;
+		}
+
+		struct properties_enrollment_allowed {
+			int& times_through;
+			std::bitset<64>& properties;
+			automagic_enrollments& enrollments;
+
+			properties_enrollment_allowed(int& times_through_, std::bitset<64>& properties_, automagic_enrollments& enrollments_)
+			: times_through(times_through_), properties(properties_), enrollments(enrollments_) {
+			}
+
+			bool operator()(meta_function mf) const {
+				bool p = properties[static_cast<std::size_t>(mf)];
+				if (times_through > 0) {
+					return p;
+				}
+				switch (mf) {
+				case meta_function::length:
+					return enrollments.length_operator && !p;
+				case meta_function::pairs:
+					return enrollments.pairs_operator && !p;
+				case meta_function::call:
+					return enrollments.call_operator && !p;
+				case meta_function::less_than:
+					return enrollments.less_than_operator && !p;
+				case meta_function::less_than_or_equal_to:
+					return enrollments.less_than_or_equal_to_operator && !p;
+				case meta_function::equal_to:
+					return enrollments.equal_to_operator && !p;
+				default:
+					break;
+				}
+				return !p;
+			}
+		};
+
+		struct indexed_insert {
+			lua_reg_table& registration_table;
+			int& index;
+
+			indexed_insert(lua_reg_table& registration_table_, int& index_ref_) : registration_table(registration_table_), index(index_ref_) {
+			}
+			void operator()(meta_function meta_function_name_, lua_CFunction c_function_) {
+				registration_table[index] = luaL_Reg { to_string(meta_function_name_).c_str(), c_function_ };
+				++index;
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_getter;
+		template <typename T, typename P, bool global = false, bool raw = false, typename = void>
+		struct probe_field_getter;
+
+		template <typename T, bool global = false, bool raw = false, typename = void>
+		struct field_setter;
+
+		template <typename T, typename = void>
+		struct unqualified_getter;
+		template <typename T, typename = void>
+		struct qualified_getter;
+
+		template <typename T, typename = void>
+		struct qualified_interop_getter;
+		template <typename T, typename = void>
+		struct unqualified_interop_getter;
+
+		template <typename T, typename = void>
+		struct popper;
+
+		template <typename T, typename = void>
+		struct unqualified_pusher;
+
+		template <typename T, type t, typename = void>
+		struct unqualified_checker;
+		template <typename T, type t, typename = void>
+		struct qualified_checker;
+
+		template <typename T, typename = void>
+		struct unqualified_check_getter;
+		template <typename T, typename = void>
+		struct qualified_check_getter;
+
+		struct probe {
+			bool success;
+			int levels;
+
+			probe(bool s, int l) : success(s), levels(l) {
+			}
+
+			operator bool() const {
+				return success;
+			};
+		};
+
+		struct record {
+			int last;
+			int used;
+
+			record() noexcept : last(), used() {
+			}
+			void use(int count) noexcept {
+				last = count;
+				used += count;
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function>
+			Function* get_function_pointer(lua_State*, int, record&) noexcept;
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept;
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace meta { namespace meta_detail {
+		template <typename T>
+		using adl_sol_lua_get_test_t = decltype(sol_lua_get(types<T>(), static_cast<lua_State*>(nullptr), -1, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_get_test_t
+			= decltype(sol_lua_interop_get(types<T>(), static_cast<lua_State*>(nullptr), -1, static_cast<void*>(nullptr), std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_test_t = decltype(sol_lua_check(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_interop_check_test_t
+			= decltype(sol_lua_interop_check(types<T>(), static_cast<lua_State*>(nullptr), -1, type::none, &no_panic, std::declval<stack::record&>()));
+
+		template <typename T>
+		using adl_sol_lua_check_get_test_t
+			= decltype(sol_lua_check_get(types<T>(), static_cast<lua_State*>(nullptr), -1, &no_panic, std::declval<stack::record&>()));
+
+		template <typename... Args>
+		using adl_sol_lua_push_test_t = decltype(sol_lua_push(static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T, typename... Args>
+		using adl_sol_lua_push_exact_test_t = decltype(sol_lua_push(types<T>(), static_cast<lua_State*>(nullptr), std::declval<Args>()...));
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_get_v = meta::is_detected_v<adl_sol_lua_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_get_v = meta::is_detected_v<adl_sol_lua_interop_get_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_v = meta::is_detected_v<adl_sol_lua_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_interop_check_v = meta::is_detected_v<adl_sol_lua_interop_check_test_t, T>;
+
+		template <typename T>
+		inline constexpr bool is_adl_sol_lua_check_get_v = meta::is_detected_v<adl_sol_lua_check_get_test_t, T>;
+
+		template <typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_v = meta::is_detected_v<adl_sol_lua_push_test_t, Args...>;
+
+		template <typename T, typename... Args>
+		inline constexpr bool is_adl_sol_lua_push_exact_v = meta::is_detected_v<adl_sol_lua_push_exact_test_t, T, Args...>;
+	}} // namespace meta::meta_detail
+
+	namespace stack {
+		namespace stack_detail {
+			constexpr const char* not_enough_stack_space = "not enough space left on Lua stack";
+			constexpr const char* not_enough_stack_space_floating = "not enough space left on Lua stack for a floating point number";
+			constexpr const char* not_enough_stack_space_integral = "not enough space left on Lua stack for an integral number";
+			constexpr const char* not_enough_stack_space_string = "not enough space left on Lua stack for a string";
+			constexpr const char* not_enough_stack_space_meta_function_name = "not enough space left on Lua stack for the name of a meta_function";
+			constexpr const char* not_enough_stack_space_userdata = "not enough space left on Lua stack to create a sol2 userdata";
+			constexpr const char* not_enough_stack_space_generic = "not enough space left on Lua stack to push valuees";
+			constexpr const char* not_enough_stack_space_environment = "not enough space left on Lua stack to retrieve environment";
+
+			template <typename T>
+			struct strip {
+				typedef T type;
+			};
+			template <typename T>
+			struct strip<std::reference_wrapper<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<user<T>> {
+				typedef T& type;
+			};
+			template <typename T>
+			struct strip<non_null<T>> {
+				typedef T type;
+			};
+			template <typename T>
+			using strip_t = typename strip<T>::type;
+
+			template <typename C>
+			static int get_size_hint(C& c) {
+				return static_cast<int>(c.size());
+			}
+
+			template <typename V, typename Al>
+			static int get_size_hint(const std::forward_list<V, Al>&) {
+				// forward_list makes me sad
+				return static_cast<int>(32);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_unqualified_get(lua_State* L, int index, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<Tu>) {
+					return sol_lua_get(types<Tu>(), L, index, tracking);
+				}
+				else {
+					unqualified_getter<Tu> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+					return sol_lua_get(types<T>(), L, index, tracking);
+				}
+				else {
+					qualified_getter<T> g {};
+					return g.get(L, index, tracking);
+				}
+			}
+
+			template <typename T>
+			decltype(auto) unqualified_interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<Tu>) {
+					return sol_lua_interop_get(types<Tu>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)unadjusted_pointer;
+					(void)tracking;
+					using Ti = stack_detail::strip_t<Tu>;
+					return std::pair<bool, Ti*> { false, nullptr };
+				}
+			}
+
+			template <typename T>
+			decltype(auto) interop_get(lua_State* L, int index, void* unadjusted_pointer, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_get_v<T>) {
+					return sol_lua_interop_get(types<T>(), L, index, unadjusted_pointer, tracking);
+				}
+				else {
+					return unqualified_interop_get<T>(L, index, unadjusted_pointer, tracking);
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool unqualified_interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				using Tu = meta::unqualified_t<T>;
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<Tu>) {
+					return sol_lua_interop_check(types<Tu>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					(void)L;
+					(void)index;
+					(void)index_type;
+					(void)handler;
+					(void)tracking;
+					return false;
+				}
+			}
+
+			template <typename T, typename Handler>
+			bool interop_check(lua_State* L, int index, type index_type, Handler&& handler, record& tracking) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_interop_check_v<T>) {
+					return sol_lua_interop_check(types<T>(), L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return unqualified_interop_check<T>(L, index, index_type, std::forward<Handler>(handler), tracking);
+				}
+			}
+
+			using undefined_method_func = void (*)(stack_reference);
+
+			struct undefined_metatable {
+				lua_State* L;
+				const char* key;
+				undefined_method_func on_new_table;
+
+				undefined_metatable(lua_State* l, const char* k, undefined_method_func umf) : L(l), key(k), on_new_table(umf) {
+				}
+
+				void operator()() const {
+					if (luaL_newmetatable(L, key) == 1) {
+						on_new_table(stack_reference(L, -1));
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		inline bool maybe_indexable(lua_State* L, int index = -1) {
+			type t = type_of(L, index);
+			return t == type::userdata || t == type::table;
+		}
+
+		inline int top(lua_State* L) {
+			return lua_gettop(L);
+		}
+
+		inline bool is_main_thread(lua_State* L) {
+			int ismainthread = lua_pushthread(L);
+			lua_pop(L, 1);
+			return ismainthread == 1;
+		}
+
+		inline void coroutine_create_guard(lua_State* L) {
+			if (is_main_thread(L)) {
+				return;
+			}
+			int stacksize = lua_gettop(L);
+			if (stacksize < 1) {
+				return;
+			}
+			if (type_of(L, 1) != type::function) {
+				return;
+			}
+			// well now we're screwed...
+			// we can clean the stack and pray it doesn't destroy anything?
+			lua_pop(L, stacksize);
+		}
+
+		inline void clear(lua_State* L, int table_index) {
+			lua_pushnil(L);
+			while (lua_next(L, table_index) != 0) {
+				// remove value
+				lua_pop(L, 1);
+				// duplicate key to protect form rawset
+				lua_pushvalue(L, -1);
+				// push new value
+				lua_pushnil(L);
+				// table_index%[key] = nil
+				lua_rawset(L, table_index);
+			}
+		}
+
+		inline void clear(reference& r) {
+			auto pp = push_pop<false>(r);
+			int stack_index = pp.index_of(r);
+			clear(r.lua_state(), stack_index);
+		}
+
+		inline void clear(stack_reference& r) {
+			clear(r.lua_state(), r.stack_index());
+		}
+
+		inline void clear(lua_State* L_, stateless_reference& r) {
+			r.push(L_);
+			int stack_index = absolute_index(L_, -1);
+			clear(L_, stack_index);
+			r.pop(L_);
+		}
+
+		inline void clear(lua_State* L_, stateless_stack_reference& r) {
+			clear(L_, r.stack_index());
+		}
+
+		template <typename T, typename... Args>
+		int push(lua_State* L, T&& t, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, T, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, T, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<T, Args...>) {
+				return sol_lua_push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<T>(t), std::forward<Args>(args)...);
+			}
+		}
+
+		// overload allows to use a pusher of a specific type, but pass in any kind of args
+		template <typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
+		int push(lua_State* L, Arg&& arg, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<T, Arg, Args...>) {
+				return sol_lua_push(types<T>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_exact_v<Tu, Arg, Args...>) {
+				return sol_lua_push(types<Tu>(), L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_push_v<Arg, Args...> && !detail::is_tagged_v<Tu>) {
+				return sol_lua_push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+			else {
+				unqualified_pusher<Tu> p {};
+				return p.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, typename... Args>
+		int push_userdata(lua_State* L, T&& t, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_userdata(lua_State* L, Arg&& arg, Args&&... args) {
+			using U = meta::unqualified_t<T>;
+			using Tr = meta::conditional_t<std::is_pointer_v<U>,
+			     detail::as_pointer_tag<std::remove_pointer_t<U>>,
+			     meta::conditional_t<is_unique_usertype_v<U>, detail::as_unique_tag<U>, detail::as_value_tag<U>>>;
+			return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		namespace stack_detail {
+
+			template <typename T, typename Arg, typename... Args>
+			int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+				// clang-format off
+				using use_reference_tag =
+				meta::all<
+					meta::neg<is_value_semantic_for_function<T>>
+#if SOL_IS_OFF(SOL_FUNCTION_CALL_VALUE_SEMANTICS)
+					, std::is_lvalue_reference<T>,
+					meta::neg<std::is_const<std::remove_reference_t<T>>>,
+					meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
+					meta::neg<is_unique_usertype<meta::unqualified_t<T>>>
+#endif
+				>;
+				// clang-format on
+				using Tr = meta::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>;
+				return stack::push<Tr>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T, typename... Args>
+		int push_reference(lua_State* L, T&& t, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename Arg, typename... Args>
+		int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
+			return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+		}
+
+		inline int multi_push(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = push(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		inline int multi_push_reference(lua_State*) {
+			// do nothing
+			return 0;
+		}
+
+		template <typename T, typename... Args>
+		int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
+			int pushcount = stack::push_reference(L, std::forward<T>(t));
+			void(detail::swallow { (pushcount += stack::push_reference(L, std::forward<Args>(args)), 0)... });
+			return pushcount;
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<Tu>) {
+				return sol_lua_check(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_checker<Tu, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool unqualified_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool unqualified_check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_v<T>) {
+				return sol_lua_check(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				using Tu = meta::unqualified_t<T>;
+				qualified_checker<T, lua_type_of_v<Tu>> c{};
+				return c.check(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		bool check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, type, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			using detail_t = meta::conditional_t<std::is_pointer_v<T>, detail::as_pointer_tag<Tu>, detail::as_value_tag<Tu>>;
+			return check<detail_t>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T, typename Handler>
+		bool check_usertype(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_usertype<T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename T>
+		bool check_usertype(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_usertype<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<Tu>) {
+				return sol_lua_check_get(types<Tu>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				unqualified_check_getter<Tu> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) unqualified_check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return unqualified_check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return unqualified_check_get<T>(L, index, handler);
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (meta::meta_detail::is_adl_sol_lua_check_get_v<T>) {
+				return sol_lua_check_get(types<T>(), L, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				qualified_check_getter<T> cg {};
+				return cg.get(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+
+		template <typename T, typename Handler>
+		decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return check_get<T>(L, index, handler, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			auto handler = &no_panic;
+			return check_get<T>(L, index, handler);
+		}
+
+		namespace stack_detail {
+
+			template <typename Handler>
+			bool check_types(lua_State*, int, Handler&&, record&) {
+				return true;
+			}
+
+			template <typename T, typename... Args, typename Handler>
+			bool check_types(lua_State* L, int firstargument, Handler&& handler, record& tracking) {
+				if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
+					return false;
+				return check_types<Args...>(L, firstargument, std::forward<Handler>(handler), tracking);
+			}
+
+			template <typename... Args, typename Handler>
+			bool check_types(types<Args...>, lua_State* L, int index, Handler&& handler, record& tracking) {
+				return check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+			}
+
+		} // namespace stack_detail
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::check_types<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args, typename Handler>
+		bool multi_check(lua_State* L, int index, Handler&& handler) {
+			record tracking {};
+			return multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename... Args>
+		bool multi_check(lua_State* L, int index) {
+			return multi_check<Args...>(L, index);
+		}
+
+		template <typename T>
+		auto unqualified_get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_unqualified_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+				auto op = unqualified_check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) unqualified_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return unqualified_get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		auto get(lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
+#if SOL_IS_ON(SOL_SAFE_GETTER)
+			static constexpr bool is_op = meta::is_optional_v<T>;
+			if constexpr (is_op) {
+				return stack_detail::unchecked_get<T>(L, index, tracking);
+			}
+			else {
+				if (is_lua_reference<T>::value) {
+					return stack_detail::unchecked_get<T>(L, index, tracking);
+				}
+				auto op = check_get<T>(L, index, type_panic_c_str, tracking);
+				return *std::move(op);
+			}
+#else
+			return stack_detail::unchecked_get<T>(L, index, tracking);
+#endif
+		}
+
+		template <typename T>
+		decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
+			record tracking {};
+			return get<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index, record& tracking) {
+			using UT = meta::conditional_t<std::is_pointer<T>::value, detail::as_pointer_tag<std::remove_pointer_t<T>>, detail::as_value_tag<T>>;
+			return get<UT>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) get_usertype(lua_State* L, int index = -lua_size_v<meta::unqualified_t<T>>) {
+			record tracking {};
+			return get_usertype<T>(L, index, tracking);
+		}
+
+		template <typename T>
+		decltype(auto) pop(lua_State* L) {
+			return popper<T> {}.pop(L);
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename Key>
+		void get_field(lua_State* L, Key&& key, int tableindex) {
+			field_getter<meta::unqualified_t<Key>, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key) {
+			get_field<global, true>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename Key>
+		void raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			get_field<global, true>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_field_getter<meta::unqualified_t<Key>, C, global, raw> {}.get(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key));
+		}
+
+		template <bool global = false, typename C = detail::non_lua_nil_t, typename Key>
+		probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
+			return probe_get_field<global, true, C>(L, std::forward<Key>(key), tableindex);
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, bool raw = false, typename Key, typename Value>
+		void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			field_setter<meta::unqualified_t<Key>, global, raw> {}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
+		}
+
+		template <bool global = false, typename Key, typename Value>
+		void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
+			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
+		}
+
+		template <typename T, typename F>
+		void modify_unique_usertype_as(const stack_reference& obj, F&& f) {
+			void* raw = lua_touserdata(obj.lua_state(), obj.stack_index());
+			void* ptr_memory = detail::align_usertype_pointer(raw);
+			void* uu_memory = detail::align_usertype_unique<T>(raw);
+			T& uu = *static_cast<T*>(uu_memory);
+			f(uu);
+			*static_cast<void**>(ptr_memory) = static_cast<void*>(detail::unique_get(obj.lua_state(), uu));
+		}
+
+		template <typename F>
+		void modify_unique_usertype(const stack_reference& obj, F&& f) {
+			using bt = meta::bind_traits<meta::unqualified_t<F>>;
+			using T = typename bt::template arg_at<0>;
+			using Tu = meta::unqualified_t<T>;
+			modify_unique_usertype_as<Tu>(obj, std::forward<F>(f));
+		}
+
+		namespace stack_detail {
+			template <typename T, typename Handler>
+			decltype(auto) check_get_arg(lua_State* L_, int index_, Handler&& handler_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return check_get<T>(L_, index_, std::forward<Handler>(handler_), tracking_);
+			}
+
+			template <typename T>
+			decltype(auto) unchecked_get_arg(lua_State* L_, int index_, record& tracking_) {
+				if constexpr (meta::meta_detail::is_adl_sol_lua_check_access_v<T>) {
+					sol_lua_check_access(types<meta::unqualified_t<T>>(), L_, index_, tracking_);
+				}
+				return unchecked_get<T>(L_, index_, tracking_);
+			}
+		} // namespace stack_detail
+
+	} // namespace stack
+
+	namespace detail {
+
+		template <typename T>
+		lua_CFunction make_destructor(std::true_type) {
+			if constexpr (is_unique_usertype_v<T>) {
+				return &unique_destroy<T>;
+			}
+			else if constexpr (!std::is_pointer_v<T>) {
+				return &usertype_alloc_destroy<T>;
+			}
+			else {
+				return &cannot_destroy<T>;
+			}
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor(std::false_type) {
+			return &cannot_destroy<T>;
+		}
+
+		template <typename T>
+		lua_CFunction make_destructor() {
+			return make_destructor<T>(std::is_destructible<T>());
+		}
+
+		struct no_comp {
+			template <typename A, typename B>
+			bool operator()(A&&, B&&) const {
+				return false;
+			}
+		};
+
+		template <typename T>
+		int is_check(lua_State* L) {
+			return stack::push(L, stack::check<T>(L, 1, &no_panic));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::true_type, lua_State* L) {
+			decltype(auto) ts = stack::get<T>(L, 1).to_string();
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int member_default_to_string(std::false_type, lua_State* L) {
+			return luaL_error(L,
+			     "cannot perform to_string on '%s': no 'to_string' overload in namespace, 'to_string' member "
+			     "function, or operator<<(ostream&, ...) present",
+			     detail::demangle<T>().data());
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::true_type, lua_State* L) {
+			using namespace std;
+			decltype(auto) ts = to_string(stack::get<T>(L, 1));
+			return stack::push(L, std::forward<decltype(ts)>(ts));
+		}
+
+		template <typename T>
+		int adl_default_to_string(std::false_type, lua_State* L) {
+			return member_default_to_string<T>(meta::supports_to_string_member<T>(), L);
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::true_type, lua_State* L) {
+			std::ostringstream oss;
+			oss << stack::unqualified_get<T>(L, 1);
+			return stack::push(L, oss.str());
+		}
+
+		template <typename T>
+		int oss_default_to_string(std::false_type, lua_State* L) {
+			return adl_default_to_string<T>(meta::supports_adl_to_string<T>(), L);
+		}
+
+		template <typename T>
+		int default_to_string(lua_State* L) {
+			return oss_default_to_string<T>(meta::supports_op_left_shift<std::ostream, T>(), L);
+		}
+
+		template <typename T>
+		int default_size(lua_State* L) {
+			decltype(auto) self = stack::unqualified_get<T>(L, 1);
+			return stack::push(L, self.size());
+		}
+
+		template <typename T, typename Op>
+		int comparsion_operator_wrap(lua_State* L) {
+			if constexpr (std::is_void_v<T>) {
+				return stack::push(L, false);
+			}
+			else {
+				auto maybel = stack::unqualified_check_get<T>(L, 1);
+				if (!maybel) {
+					return stack::push(L, false);
+				}
+				auto mayber = stack::unqualified_check_get<T>(L, 2);
+				if (!mayber) {
+					return stack::push(L, false);
+				}
+				decltype(auto) l = *maybel;
+				decltype(auto) r = *mayber;
+				if constexpr (std::is_same_v<no_comp, Op>) {
+					std::equal_to<> op;
+					return stack::push(L, op(detail::ptr(l), detail::ptr(r)));
+				}
+				else {
+					if constexpr (std::is_same_v<std::equal_to<>, Op> // clang-format hack
+					     || std::is_same_v<std::less_equal<>, Op>     //
+					     || std::is_same_v<std::less_equal<>, Op>) {  //
+						if (detail::ptr(l) == detail::ptr(r)) {
+							return stack::push(L, true);
+						}
+					}
+					Op op;
+					return stack::push(L, op(detail::deref(l), detail::deref(r)));
+				}
+			}
+		}
+
+		template <typename T, typename IFx, typename Fx>
+		void insert_default_registrations(IFx&& ifx, Fx&& fx);
+
+		template <typename T, bool, bool>
+		struct get_is_primitive : is_lua_primitive<T> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, false>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<T>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, false, true>
+		: meta::neg<std::is_reference<decltype(sol_lua_get(types<meta::unqualified_t<T>>(), nullptr, -1, std::declval<stack::record&>()))>> { };
+
+		template <typename T>
+		struct get_is_primitive<T, true, true> : get_is_primitive<T, true, false> { };
+
+	} // namespace detail
+
+	template <typename T>
+	struct is_proxy_primitive
+	: detail::get_is_primitive<T, meta::meta_detail::is_adl_sol_lua_get_v<T>, meta::meta_detail::is_adl_sol_lua_get_v<meta::unqualified_t<T>>> { };
+
+} // namespace sol
+
+// end of sol/stack_core.hpp
+
+// beginning of sol/stack_check.hpp
+
+// beginning of sol/stack_check_unqualified.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans
+
+namespace sol { namespace stack {
+	template <typename Handler>
+	bool loose_table_check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+		tracking.use(1);
+		type t = type_of(L_, index);
+		if (t == type::table) {
+			return true;
+		}
+		if (t != type::userdata) {
+			handler(L_, index, type::table, t, "value is not a table or a userdata that can behave like one");
+			return false;
+		}
+		return true;
+	}
+
+	namespace stack_detail {
+		inline bool impl_check_metatable(lua_State* L_, int index, const std::string& metakey, bool poptable) {
+			luaL_getmetatable(L_, &metakey[0]);
+			const type expectedmetatabletype = static_cast<type>(lua_type(L_, -1));
+			if (expectedmetatabletype != type::lua_nil) {
+				if (lua_rawequal(L_, -1, index) == 1) {
+					lua_pop(L_, 1 + static_cast<int>(poptable));
+					return true;
+				}
+			}
+			lua_pop(L_, 1);
+			return false;
+		}
+
+		template <typename T, bool poptable = true>
+		inline bool check_metatable(lua_State* L_, int index = -2) {
+			return impl_check_metatable(L_, index, usertype_traits<T>::metatable(), poptable);
+		}
+
+		template <type expected, int (*check_func)(lua_State*, int)>
+		struct basic_check {
+			template <typename Handler>
+			static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+				tracking.use(1);
+				bool success = check_func(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State*, int, type, Handler&&, record&) {
+			return false;
+		}
+	};
+
+	template <typename T, typename>
+	struct qualified_interop_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type index_type, Handler&& handler, record& tracking) {
+			return stack_detail::unqualified_interop_check<T>(L_, index, index_type, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename T, type expected, typename>
+	struct unqualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				bool success = lua_isboolean(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (meta::any_same_v<T,
+				                   char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				                   ,
+				                   char8_t
+#endif
+				                   ,
+				                   char16_t,
+				                   char32_t>) {
+				return stack::check<std::basic_string<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				// Lua 5.3 and greater checks for numeric precision
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				// imprecise, sloppy conversions
+				int isnum = 0;
+				lua_tointegerx(L_, index, &isnum);
+				const bool success = isnum != 0;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string_integral);
+				}
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				// this check is precise, do not convert
+				if (lua_isinteger(L_, index) == 1) {
+					return true;
+				}
+				const bool success = false;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_integral);
+				}
+#else
+				// Numerics are neither safe nor string-convertible
+				type t = type_of(L_, index);
+				const bool success = t == type::number;
+#endif
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number);
+				}
+				return success;
+#else
+				// Lua 5.2 and below checks
+#if SOL_IS_OFF(SOL_STRINGS_ARE_NUMBERS)
+				// must pre-check, because it will convert
+				type t = type_of(L_, index);
+				if (t != type::number) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+					return false;
+				}
+#endif // Do not allow strings to be numbers
+
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				int isnum = 0;
+				const lua_Number v = lua_tonumberx(L_, index, &isnum);
+				const bool success = isnum != 0 && static_cast<lua_Number>(llround(v)) == v;
+#else
+				const bool success = true;
+#endif // Safe numerics and number precision checking
+				if (!success) {
+					// Use defines to provide a better error message!
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+#elif SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+					handler(L_, index, type::number, t, detail::not_a_number_or_number_string);
+#else
+					handler(L_, index, type::number, t, detail::not_a_number);
+#endif
+				}
+				return success;
+#endif
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+#if SOL_IS_ON(SOL_STRINGS_ARE_NUMBERS)
+				bool success = lua_isnumber(L_, index) == 1;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, type_of(L_, index), detail::not_a_number_or_number_string);
+				}
+				return success;
+#else
+				type t = type_of(L_, index);
+				bool success = t == type::number;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::number, t, detail::not_a_number);
+				}
+				return success;
+#endif // Strings are Numbers
+			}
+			else if constexpr (meta::any_same_v<T, type, this_state, this_main_state, this_environment, variadic_args>) {
+				(void)L_;
+				(void)index;
+				(void)handler;
+				tracking.use(0);
+				return true;
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using element = unique_usertype_element_t<T>;
+				using actual = unique_usertype_actual_t<T>;
+				const type indextype = type_of(L_, index);
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<d::u<element>>(L_, metatableindex)) {
+					void* memory = lua_touserdata(L_, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					bool success = &detail::usertype_unique_alloc_destroy<element, actual> == pdx;
+					if (!success) {
+						memory = detail::align_usertype_unique_tag<true>(memory);
+#if 0
+						// New version, one day
+#else
+						const char*& name_tag = *static_cast<const char**>(memory);
+						success = usertype_traits<T>::qualified_name() == name_tag;
+#endif
+						if (!success) {
+							handler(L_, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+						}
+					}
+					return success;
+				}
+				lua_pop(L_, 1);
+				handler(L_, index, type::userdata, indextype, "unrecognized userdata (not pushed by sol?)");
+				return false;
+			}
+			else if constexpr (meta::any_same_v<T, lua_nil_t, std::nullopt_t, nullopt_t>) {
+				bool success = lua_isnil(L_, index);
+				if (success) {
+					tracking.use(1);
+					return success;
+				}
+				tracking.use(0);
+				success = lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, expected, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t == type::table || t == type::none || t == type::lua_nil || t == type::userdata) {
+					return true;
+				}
+				handler(L_, index, type::table, t, "value cannot not have a valid environment");
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, detail::non_lua_nil_t>) {
+				return !stack::unqualified_check<lua_nil_t>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_lua_table>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::table) {
+					handler(L_, index, type::table, t, "value is not a table");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_bytecode>) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				if (t != type::function) {
+					handler(L_, index, type::function, t, "value is not a function that can be dumped");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_specialization_of_v<T, basic_environment>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, type::table, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				tracking.use(1);
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				type t = type_of(L_, -1);
+				if (t == type::table || t == type::none || t == type::lua_nil) {
+					lua_pop(L_, 1);
+					return true;
+				}
+				if (t != type::userdata) {
+					lua_pop(L_, 1);
+					handler(L_, index, expected, t, "value does not have a valid metatable");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*> || std::is_same_v<T, luaL_Stream>) {
+				if (lua_getmetatable(L_, index) == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (has no metatable/is not a valid value)");
+					return false;
+				}
+				luaL_getmetatable(L_, LUA_FILEHANDLE);
+				if (type_of(L_, index) != type::table) {
+					type t = type_of(L_, index);
+					lua_pop(L_, 1);
+					handler(L_,
+						index,
+						expected,
+						t,
+						"value is not a valid luaL_Stream (there is no metatable for luaL_Stream -- did you forget to "
+						"my_lua_state.open_libraries(sol::lib::state) or equivalent?)");
+					return false;
+				}
+				int is_stream_table = lua_compare(L_, -1, -2, LUA_OPEQ);
+				lua_pop(L_, 2);
+				if (is_stream_table == 0) {
+					type t = type_of(L_, index);
+					handler(L_, index, expected, t, "value is not a valid luaL_Stream (incorrect metatable)");
+					return false;
+				}
+				return true;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				(void)handler;
+				type t = type_of(L_, index);
+				if (t == type::none) {
+					tracking.use(0);
+					return true;
+				}
+				if (t == type::lua_nil) {
+					tracking.use(1);
+					return true;
+				}
+				return stack::unqualified_check<ValueType>(L_, index, &no_panic, tracking);
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::check_function_pointer<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+			}
+#endif
+			else if constexpr (expected == type::userdata) {
+				if constexpr (meta::any_same_v<T, userdata_value> || meta::is_specialization_of_v<T, basic_userdata>) {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					bool success = t == type::userdata;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, type::userdata, t, "");
+					}
+					return success;
+				}
+				else if constexpr (meta::is_specialization_of_v<T, user>) {
+					unqualified_checker<lightuserdata_value, type::userdata> c;
+					(void)c;
+					return c.check(L_, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					if constexpr (std::is_pointer_v<T>) {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else if constexpr (meta::is_specialization_of_v<T, std::reference_wrapper>) {
+						using T_internal = typename T::type;
+						return stack::check<T_internal>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+					else {
+						return check_usertype<T>(L_, index, std::forward<Handler>(handler), tracking);
+					}
+				}
+			}
+			else if constexpr (expected == type::poly) {
+				tracking.use(1);
+				bool success = is_lua_reference_v<T> || !lua_isnone(L_, index);
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::poly, type_of(L_, index), "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::lightuserdata) {
+				tracking.use(1);
+				type t = type_of(L_, index);
+				bool success = t == type::userdata || t == type::lightuserdata;
+				if (!success) {
+					// expected type, actual type
+					handler(L_, index, type::lightuserdata, t, "");
+				}
+				return success;
+			}
+			else if constexpr (expected == type::function) {
+				if constexpr (meta::any_same_v<T, lua_CFunction, std::remove_pointer_t<lua_CFunction>, c_closure>) {
+					tracking.use(1);
+					bool success = lua_iscfunction(L_, index) == 1;
+					if (!success) {
+						// expected type, actual type
+						handler(L_, index, expected, type_of(L_, index), "");
+					}
+					return success;
+				}
+				else {
+					tracking.use(1);
+					type t = type_of(L_, index);
+					if (t == type::lua_nil || t == type::none || t == type::function) {
+						// allow for lua_nil to be returned
+						return true;
+					}
+					if (t != type::userdata && t != type::table) {
+						handler(L_, index, type::function, t, "must be a function or table or a userdata");
+						return false;
+					}
+					// Do advanced check for call-style userdata?
+					static const auto& callkey = to_string(meta_function::call);
+					if (lua_getmetatable(L_, index) == 0) {
+						// No metatable, no __call key possible
+						handler(L_, index, type::function, t, "value is not a function and does not have overriden metatable");
+						return false;
+					}
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 1);
+						handler(L_, index, type::function, t, "value is not a function and does not have valid metatable");
+						return false;
+					}
+					lua_getfield(L_, -1, &callkey[0]);
+					if (lua_isnoneornil(L_, -1)) {
+						lua_pop(L_, 2);
+						handler(L_, index, type::function, t, "value's metatable does not have __call overridden in metatable, cannot call this type");
+						return false;
+					}
+					// has call, is definitely a function
+					lua_pop(L_, 2);
+					return true;
+				}
+			}
+			else if constexpr (expected == type::table) {
+				return stack::loose_table_check(L_, index, std::forward<Handler>(handler), tracking);
+			}
+			else {
+				tracking.use(1);
+				const type indextype = type_of(L_, index);
+				bool success = expected == indextype;
+				if (!success) {
+					// expected type, actual type, message
+					handler(L_, index, expected, indextype, "");
+				}
+				return success;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<non_null<T>, type::userdata> : unqualified_checker<T, lua_type_of_v<T>> { };
+
+	template <typename T>
+	struct unqualified_checker<detail::as_value_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(types<T>(), L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename U, typename Handler>
+		static bool check(types<U>, lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if constexpr (
+				std::is_same_v<T,
+				     lightuserdata_value> || std::is_same_v<T, userdata_value> || std::is_same_v<T, userdata> || std::is_same_v<T, lightuserdata>) {
+				tracking.use(1);
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				return true;
+			}
+			else {
+#if SOL_IS_ON(SOL_USE_INTEROP)
+				if (stack_detail::interop_check<U>(L_, index, indextype, handler, tracking)) {
+					return true;
+				}
+#endif // interop extensibility
+				tracking.use(1);
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				if (lua_iscfunction(L_, index) != 0) {
+					// a potential match...
+					return true;
+				}
+#endif
+				if (indextype != type::userdata) {
+					handler(L_, index, type::userdata, indextype, "value is not a valid userdata");
+					return false;
+				}
+				if (lua_getmetatable(L_, index) == 0) {
+					return true;
+				}
+				int metatableindex = lua_gettop(L_);
+				if (stack_detail::check_metatable<U>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<U*>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<d::u<U>>(L_, metatableindex))
+					return true;
+				if (stack_detail::check_metatable<as_container_t<U>>(L_, metatableindex))
+					return true;
+				bool success = false;
+				bool has_derived = derive<T>::value || weak_derive<T>::value;
+				if (has_derived) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L_, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+					auto pn = stack::pop_n(L_, 1);
+					lua_pushstring(L_, &detail::base_class_check_key()[0]);
+					lua_rawget(L_, metatableindex);
+					if (type_of(L_, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L_, -1);
+						detail::inheritance_check_function ic = reinterpret_cast<detail::inheritance_check_function>(basecastdata);
+						success = ic(usertype_traits<T>::qualified_name());
+					}
+				}
+				lua_pop(L_, 1);
+				if (!success) {
+					handler(L_, index, type::userdata, indextype, "value at this index does not properly reflect the desired type");
+					return false;
+				}
+				return true;
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_checker<detail::as_pointer_tag<T>, type::userdata> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, type indextype, Handler&& handler, record& tracking) {
+			if (indextype == type::lua_nil) {
+				tracking.use(1);
+				return true;
+			}
+			return check_usertype<std::remove_pointer_t<T>>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			const type indextype = type_of(L_, index);
+			return check(L_, index, indextype, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_checker<std::tuple<Args...>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<Args...>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_checker<std::pair<A, B>, type::poly> {
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return stack::multi_check<A, B>(L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_checker<std::variant<Tn...>, type::poly> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, 0>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			if constexpr (V_is_empty::value) {
+				if (lua_isnone(L_, index)) {
+					return true;
+				}
+			}
+			tracking.use(1);
+			handler(L_, index, type::poly, type_of(L_, index), "value does not fit any type present in the variant");
+			return false;
+		}
+
+		template <std::size_t I, typename Handler>
+		static bool is_one(std::integral_constant<std::size_t, I>, lua_State* L_, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L_, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return true;
+			}
+			return is_one(std::integral_constant<std::size_t, I - 1>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static bool check(lua_State* L_, int index, Handler&& handler, record& tracking) {
+			return is_one(std::integral_constant<std::size_t, V_size::value>(), L_, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#endif // variant shenanigans
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_unqualified.hpp
+
+// beginning of sol/stack_check_qualified.hpp
+
+namespace sol { namespace stack {
+
+	template <typename X, type expected, typename>
+	struct qualified_checker {
+		template <typename Handler>
+		static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using no_cv_X = meta::unqualified_t<X>;
+			if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<no_cv_X>) {
+				using element = unique_usertype_element_t<no_cv_X>;
+				if constexpr (is_actual_type_rebindable_for_v<no_cv_X>) {
+					using rebound_actual_type = unique_usertype_rebind_actual_t<no_cv_X>;
+					// we have a unique pointer type that can be
+					// rebound to a base/derived type
+					const type indextype = type_of(L, index);
+					tracking.use(1);
+					if (indextype != type::userdata) {
+						handler(L, index, type::userdata, indextype, "value is not a userdata");
+						return false;
+					}
+					void* memory = lua_touserdata(L, index);
+					memory = detail::align_usertype_unique_destructor(memory);
+					detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+					if (&detail::usertype_unique_alloc_destroy<element, no_cv_X> == pdx) {
+						return true;
+					}
+					if constexpr (derive<element>::value) {
+						memory = detail::align_usertype_unique_tag<true, false>(memory);
+						detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+						string_view ti = usertype_traits<element>::qualified_name();
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						if (ic(nullptr, nullptr, ti, rebind_ti) != 0) {
+							return true;
+						}
+					}
+					handler(L, index, type::userdata, indextype, "value is a userdata but is not the correct unique usertype");
+					return false;
+				}
+				else {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_container_v<no_cv_X>) {
+				if (type_of(L, index) == type::userdata) {
+					return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+				}
+				else {
+					return stack::unqualified_check<nested<X>>(L, index, std::forward<Handler>(handler), tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && meta::is_specialization_of_v<X, nested>) {
+				using NestedX = typename meta::unqualified_t<X>::nested_type;
+				return stack::check<NestedX>(L, index, ::std::forward<Handler>(handler), tracking);
+			}
+			else {
+				return stack::unqualified_check<X>(L, index, std::forward<Handler>(handler), tracking);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_check_qualified.hpp
+
+// end of sol/stack_check.hpp
+
+// beginning of sol/stack_get.hpp
+
+// beginning of sol/stack_get_unqualified.hpp
+
+// beginning of sol/overload.hpp
+
+#include <utility>
+
+namespace sol {
+	template <typename... Functions>
+	struct overload_set {
+		std::tuple<Functions...> functions;
+		template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
+		overload_set(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+		overload_set(const overload_set&) = default;
+		overload_set(overload_set&&) = default;
+		overload_set& operator=(const overload_set&) = default;
+		overload_set& operator=(overload_set&&) = default;
+	};
+
+	template <typename... Args>
+	decltype(auto) overload(Args&&... args) {
+		return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/overload.hpp
+
+// beginning of sol/unicode.hpp
+
+#include <array>
+#include <cstring>
+
+namespace sol {
+	// Everything here was lifted pretty much straight out of
+	// ogonek, because fuck figuring it out=
+	namespace unicode {
+		enum class error_code {
+			ok = 0,
+			invalid_code_point,
+			invalid_code_unit,
+			invalid_leading_surrogate,
+			invalid_trailing_surrogate,
+			sequence_too_short,
+			overlong_sequence,
+		};
+
+		inline const string_view& to_string(error_code ec) {
+			static const string_view storage[7] = { "ok",
+				"invalid code points",
+				"invalid code unit",
+				"invalid leading surrogate",
+				"invalid trailing surrogate",
+				"sequence too short",
+				"overlong sequence" };
+			return storage[static_cast<std::size_t>(ec)];
+		}
+
+		template <typename It>
+		struct decoded_result {
+			error_code error;
+			char32_t codepoint;
+			It next;
+		};
+
+		template <typename C>
+		struct encoded_result {
+			error_code error;
+			std::size_t code_units_size;
+			std::array<C, 4> code_units;
+		};
+
+		struct unicode_detail {
+			// codepoint related
+			static constexpr char32_t last_code_point = 0x10FFFF;
+
+			static constexpr char32_t first_lead_surrogate = 0xD800;
+			static constexpr char32_t last_lead_surrogate = 0xDBFF;
+
+			static constexpr char32_t first_trail_surrogate = 0xDC00;
+			static constexpr char32_t last_trail_surrogate = 0xDFFF;
+
+			static constexpr char32_t first_surrogate = first_lead_surrogate;
+			static constexpr char32_t last_surrogate = last_trail_surrogate;
+
+			static constexpr bool is_lead_surrogate(char32_t u) {
+				return u >= first_lead_surrogate && u <= last_lead_surrogate;
+			}
+			static constexpr bool is_trail_surrogate(char32_t u) {
+				return u >= first_trail_surrogate && u <= last_trail_surrogate;
+			}
+			static constexpr bool is_surrogate(char32_t u) {
+				return u >= first_surrogate && u <= last_surrogate;
+			}
+
+			// utf8 related
+			static constexpr auto last_1byte_value = 0x7Fu;
+			static constexpr auto last_2byte_value = 0x7FFu;
+			static constexpr auto last_3byte_value = 0xFFFFu;
+
+			static constexpr auto start_2byte_mask = 0x80u;
+			static constexpr auto start_3byte_mask = 0xE0u;
+			static constexpr auto start_4byte_mask = 0xF0u;
+
+			static constexpr auto continuation_mask = 0xC0u;
+			static constexpr auto continuation_signature = 0x80u;
+
+			static constexpr bool is_invalid(unsigned char b) {
+				return b == 0xC0 || b == 0xC1 || b > 0xF4;
+			}
+
+			static constexpr bool is_continuation(unsigned char b) {
+				return (b & unicode_detail::continuation_mask) == unicode_detail::continuation_signature;
+			}
+
+			static constexpr bool is_overlong(char32_t u, std::size_t bytes) {
+				return u <= unicode_detail::last_1byte_value || (u <= unicode_detail::last_2byte_value && bytes > 2)
+				     || (u <= unicode_detail::last_3byte_value && bytes > 3);
+			}
+
+			static constexpr int sequence_length(unsigned char b) {
+				return (b & start_2byte_mask) == 0                ? 1
+				     : (b & start_3byte_mask) != start_3byte_mask ? 2
+				     : (b & start_4byte_mask) != start_4byte_mask ? 3
+				                                                  : 4;
+			}
+
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1) {
+				return (static_cast<char32_t>((b0 & 0x1Fu) << 6u) | static_cast<char32_t>(b1 & 0x3Fu));
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2) {
+				return static_cast<char32_t>((b0 & 0x0Fu) << 12u) | static_cast<char32_t>((b1 & 0x3Fu) << 6u) | static_cast<char32_t>(b2 & 0x3Fu);
+			}
+			static constexpr char32_t decode(unsigned char b0, unsigned char b1, unsigned char b2, unsigned char b3) {
+				return static_cast<char32_t>(static_cast<char32_t>((b0 & 0x07u) << 18u) | static_cast<char32_t>((b1 & 0x3F) << 12)
+				     | static_cast<char32_t>((b2 & 0x3Fu) << 6u) | static_cast<char32_t>(b3 & 0x3Fu));
+			}
+
+			// utf16 related
+			static constexpr char32_t last_bmp_value = 0xFFFF;
+			static constexpr char32_t normalizing_value = 0x10000;
+			static constexpr int lead_surrogate_bitmask = 0xFFC00;
+			static constexpr int trail_surrogate_bitmask = 0x3FF;
+			static constexpr int lead_shifted_bits = 10;
+			static constexpr char32_t replacement = 0xFFFD;
+
+			static char32_t combine_surrogates(char16_t lead, char16_t trail) {
+				auto hi = lead - first_lead_surrogate;
+				auto lo = trail - first_trail_surrogate;
+				return normalizing_value + ((hi << lead_shifted_bits) | lo);
+			}
+		};
+
+		inline encoded_result<char> code_point_to_utf8(char32_t codepoint) {
+			encoded_result<char> er;
+			er.error = error_code::ok;
+			if (codepoint <= unicode_detail::last_1byte_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char, 4> { { static_cast<char>(codepoint) } };
+			}
+			else if (codepoint <= unicode_detail::last_2byte_value) {
+				er.code_units_size = 2;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xC0 | ((codepoint & 0x7C0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else if (codepoint <= unicode_detail::last_3byte_value) {
+				er.code_units_size = 3;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xE0 | ((codepoint & 0xF000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			else {
+				er.code_units_size = 4;
+				er.code_units = std::array<char, 4> { {
+					static_cast<char>(0xF0 | ((codepoint & 0x1C0000) >> 18)),
+					static_cast<char>(0x80 | ((codepoint & 0x3F000) >> 12)),
+					static_cast<char>(0x80 | ((codepoint & 0xFC0) >> 6)),
+					static_cast<char>(0x80 | (codepoint & 0x3F)),
+				} };
+			}
+			return er;
+		}
+
+		inline encoded_result<char16_t> code_point_to_utf16(char32_t codepoint) {
+			encoded_result<char16_t> er;
+
+			if (codepoint <= unicode_detail::last_bmp_value) {
+				er.code_units_size = 1;
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(codepoint) } };
+				er.error = error_code::ok;
+			}
+			else {
+				auto normal = codepoint - unicode_detail::normalizing_value;
+				auto lead = unicode_detail::first_lead_surrogate + ((normal & unicode_detail::lead_surrogate_bitmask) >> unicode_detail::lead_shifted_bits);
+				auto trail = unicode_detail::first_trail_surrogate + (normal & unicode_detail::trail_surrogate_bitmask);
+				er.code_units = std::array<char16_t, 4> { { static_cast<char16_t>(lead), static_cast<char16_t>(trail) } };
+				er.code_units_size = 2;
+				er.error = error_code::ok;
+			}
+			return er;
+		}
+
+		inline encoded_result<char32_t> code_point_to_utf32(char32_t codepoint) {
+			encoded_result<char32_t> er;
+			er.code_units_size = 1;
+			er.code_units[0] = codepoint;
+			er.error = error_code::ok;
+			return er;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf8_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			unsigned char b0 = static_cast<unsigned char>(*it);
+			std::size_t length = static_cast<std::size_t>(unicode_detail::sequence_length(b0));
+
+			if (length == 1) {
+				dr.codepoint = static_cast<char32_t>(b0);
+				dr.error = error_code::ok;
+				++it;
+				dr.next = it;
+				return dr;
+			}
+
+			if (unicode_detail::is_invalid(b0) || unicode_detail::is_continuation(b0)) {
+				dr.error = error_code::invalid_code_unit;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			std::array<unsigned char, 4> b;
+			b[0] = b0;
+			for (std::size_t i = 1; i < length; ++i) {
+				b[i] = static_cast<unsigned char>(*it);
+				if (!unicode_detail::is_continuation(b[i])) {
+					dr.error = error_code::invalid_code_unit;
+					dr.next = it;
+					return dr;
+				}
+				++it;
+			}
+
+			char32_t decoded;
+			switch (length) {
+			case 2:
+				decoded = unicode_detail::decode(b[0], b[1]);
+				break;
+			case 3:
+				decoded = unicode_detail::decode(b[0], b[1], b[2]);
+				break;
+			default:
+				decoded = unicode_detail::decode(b[0], b[1], b[2], b[3]);
+				break;
+			}
+
+			if (unicode_detail::is_overlong(decoded, length)) {
+				dr.error = error_code::overlong_sequence;
+				return dr;
+			}
+			if (unicode_detail::is_surrogate(decoded) || decoded > unicode_detail::last_code_point) {
+				dr.error = error_code::invalid_code_point;
+				return dr;
+			}
+
+			// then everything is fine
+			dr.codepoint = decoded;
+			dr.error = error_code::ok;
+			dr.next = it;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf16_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+
+			char16_t lead = static_cast<char16_t>(*it);
+
+			if (!unicode_detail::is_surrogate(lead)) {
+				++it;
+				dr.codepoint = static_cast<char32_t>(lead);
+				dr.next = it;
+				dr.error = error_code::ok;
+				return dr;
+			}
+			if (!unicode_detail::is_lead_surrogate(lead)) {
+				dr.error = error_code::invalid_leading_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			++it;
+			auto trail = *it;
+			if (!unicode_detail::is_trail_surrogate(trail)) {
+				dr.error = error_code::invalid_trailing_surrogate;
+				dr.next = it;
+				return dr;
+			}
+
+			dr.codepoint = unicode_detail::combine_surrogates(lead, trail);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+
+		template <typename It>
+		inline decoded_result<It> utf32_to_code_point(It it, It last) {
+			decoded_result<It> dr;
+			if (it == last) {
+				dr.next = it;
+				dr.error = error_code::sequence_too_short;
+				return dr;
+			}
+			dr.codepoint = static_cast<char32_t>(*it);
+			dr.next = ++it;
+			dr.error = error_code::ok;
+			return dr;
+		}
+	} // namespace unicode
+} // namespace sol
+// end of sol/unicode.hpp
+
+#include <memory>
+#include <functional>
+#include <utility>
+#include <cstdlib>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Apple clang screwed up
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename Ch>
+		struct count_code_units_utf {
+			std::size_t needed_size;
+
+			count_code_units_utf() : needed_size(0) {
+			}
+
+			void operator()(const unicode::encoded_result<Ch> er) {
+				needed_size += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename ErCh>
+		struct copy_code_units_utf {
+			Ch* target_;
+
+			copy_code_units_utf(Ch* target) : target_(target) {
+			}
+
+			void operator()(const unicode::encoded_result<ErCh> er) {
+				std::memcpy(target_, er.code_units.data(), er.code_units_size * sizeof(ErCh));
+				target_ += er.code_units_size;
+			}
+		};
+
+		template <typename Ch, typename F>
+		inline void convert(const char* strb, const char* stre, F&& f) {
+			char32_t cp = 0;
+			for (const char* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf8_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+					++strtarget;
+				}
+				else {
+					cp = dr.codepoint;
+					strtarget = dr.next;
+				}
+				if constexpr (std::is_same_v<Ch, char32_t>) {
+					auto er = unicode::code_point_to_utf32(cp);
+					f(er);
+				}
+				else {
+					auto er = unicode::code_point_to_utf16(cp);
+					f(er);
+				}
+			}
+		}
+
+		template <typename BaseCh, typename S>
+		inline S get_into(lua_State* L, int index, record& tracking) {
+			using Ch = typename S::value_type;
+			tracking.use(1);
+			size_t len;
+			auto utf8p = lua_tolstring(L, index, &len);
+			if (len < 1)
+				return S();
+			const char* strb = utf8p;
+			const char* stre = utf8p + len;
+			stack_detail::count_code_units_utf<BaseCh> count_units;
+			convert<BaseCh>(strb, stre, count_units);
+			S r(count_units.needed_size, static_cast<Ch>(0));
+			r.resize(count_units.needed_size);
+			Ch* target = &r[0];
+			stack_detail::copy_code_units_utf<Ch, BaseCh> copy_units(target);
+			convert<BaseCh>(strb, stre, copy_units);
+			return r;
+		}
+	} // namespace stack_detail
+
+	template <typename T, typename>
+	struct unqualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			if constexpr (std::is_same_v<T, bool>) {
+				tracking.use(1);
+				return lua_toboolean(L, index) != 0;
+			}
+			else if constexpr (std::is_enum_v<T>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tointegerx(L, index, nullptr));
+			}
+			else if constexpr (std::is_integral_v<T> || std::is_same_v<T, lua_Integer>) {
+				tracking.use(1);
+#if SOL_LUA_VERSION_I_ >= 503
+				if (lua_isinteger(L, index) != 0) {
+					return static_cast<T>(lua_tointeger(L, index));
+				}
+#endif
+				return static_cast<T>(llround(lua_tonumber(L, index)));
+			}
+			else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+				tracking.use(1);
+				return static_cast<T>(lua_tonumber(L, index));
+			}
+			else if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<T>) {
+					tracking.use(1);
+					return T(L, global_tag);
+				}
+				else {
+					tracking.use(1);
+					return T(L, index);
+				}
+			}
+			else if constexpr (is_unique_usertype_v<T>) {
+				using actual = unique_usertype_actual_t<T>;
+
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				void* aligned_memory = detail::align_usertype_unique<actual>(memory);
+				actual* typed_memory = static_cast<actual*>(aligned_memory);
+				return *typed_memory;
+			}
+			else if constexpr (meta::is_optional_v<T>) {
+				using ValueType = typename T::value_type;
+				return unqualified_check_getter<ValueType>::template get_using<T>(L, index, &no_panic, tracking);
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream*>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return pstream;
+			}
+			else if constexpr (std::is_same_v<T, luaL_Stream>) {
+				luaL_Stream* pstream = static_cast<luaL_Stream*>(lua_touserdata(L, index));
+				return *pstream;
+			}
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			else if constexpr (std::is_function_v<T> || (std::is_pointer_v<T> && std::is_function_v<std::remove_pointer_t<T>>)) {
+				return stack_detail::get_function_pointer<std::remove_pointer_t<T>>(L, index, tracking);
+			}
+#endif
+			else {
+				return stack_detail::unchecked_unqualified_get<detail::as_value_tag<T>>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename X, typename>
+	struct qualified_getter {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<X>;
+			static constexpr bool is_userdata_of_some_kind
+				= !std::is_reference_v<
+				       X> && is_container_v<Tu> && std::is_default_constructible_v<Tu> && !is_lua_primitive_v<Tu> && !is_transparent_argument_v<Tu>;
+			if constexpr (is_userdata_of_some_kind) {
+				if (type_of(L, index) == type::userdata) {
+					return static_cast<Tu>(stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking));
+				}
+				else {
+					return stack_detail::unchecked_unqualified_get<sol::nested<Tu>>(L, index, tracking);
+				}
+			}
+			else if constexpr (!std::is_reference_v<X> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				actual r {};
+				if constexpr (!derive<element>::value) {
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(std::move(r));
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return static_cast<actual>(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return static_cast<actual>(std::move(r));
+					default:
+						// uh oh..
+						break;
+					}
+#if SOL_IS_ON(SOL_DEBUG_BUILD)
+					// In debug mode we would rather abort you for this grave failure rather
+					// than let you deref a null pointer and fuck everything over
+					std::abort();
+#endif
+					return static_cast<actual>(r);
+				}
+			}
+			else {
+				return stack_detail::unchecked_unqualified_get<Tu>(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_table_t<T>> {
+		using Tu = meta::unqualified_t<T>;
+
+		template <typename V>
+		static void push_back_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			cont.push_back(stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void push_back_at_end(std::false_type, types<V> t, lua_State* L, T& cont, std::size_t idx) {
+			insert_at_end(meta::has_insert<Tu>(), t, L, cont, idx);
+		}
+
+		template <typename V>
+		static void insert_at_end(std::true_type, types<V>, lua_State* L, T& cont, std::size_t) {
+			using std::cend;
+			cont.insert(cend(cont), stack::get<V>(L, -lua_size<V>::value));
+		}
+
+		template <typename V>
+		static void insert_at_end(std::false_type, types<V>, lua_State* L, T& cont, std::size_t idx) {
+			cont[idx] = stack::get<V>(L, -lua_size<V>::value);
+		}
+
+		static bool max_size_check(std::false_type, T&, std::size_t) {
+			return false;
+		}
+
+		static bool max_size_check(std::true_type, T& cont, std::size_t idx) {
+			return idx >= cont.max_size();
+		}
+
+		static T get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::is_associative<Tu>(), L, relindex, tracking);
+		}
+
+		static T get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename Tu::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static T get(types<V> t, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+			// the W4 flag is really great,
+			// so great that it can tell my for loops (twice nested)
+			// below never actually terminate
+			// without hitting where the gotos have infested
+
+			// so now I would get the error W4XXX unreachable
+			// me that the return cont at the end of this function
+			// which is fair until other compilers complain
+			// that there isn't a return and that based on
+			// SOME MAGICAL FORCE
+			// control flow falls off the end of a non-void function
+			// so it needs to be there for the compilers that are
+			// too flimsy to analyze the basic blocks...
+			// (I'm sure I should file a bug but those compilers are already
+			// in the wild; it doesn't matter if I fix them,
+			// someone else is still going to get some old-ass compiler
+			// and then bother me about the unclean build for the 30th
+			// time)
+
+			// "Why not an IIFE?"
+			// Because additional lambdas / functions which serve as
+			// capture-all-and-then-invoke bloat binary sizes
+			// by an actually detectable amount
+			// (one user uses sol2 pretty heavily and 22 MB of binary size
+			// was saved by reducing reliance on lambdas in templates)
+
+			// This would really be solved by having break N;
+			// be a real, proper thing...
+			// but instead, we have to use labels and gotos
+			// and earn the universal vitriol of the dogmatic
+			// programming community
+
+			// all in all: W4 is great!~
+
+			int index = lua_absindex(L, relindex);
+			T cont;
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration
+			// thanks to the Lua API changes in 5.3
+			// Questionable in 5.4
+			for (lua_Integer i = 0;; i += lua_size<V>::value) {
+				if (max_size_check(meta::has_max_size<Tu>(), cont, idx)) {
+					// see above comment
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushinteger(L, static_cast<lua_Integer>(i + vi));
+					if (lua_keyin(L, index) == 0) {
+						// it's time to stop
+						isnil = true;
+					}
+					else {
+						// we have a key, have to get the value
+						lua_geti(L, index, i + vi);
+					}
+#else
+					type vt = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = vt == type::none || vt == type::lua_nil;
+#endif
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+						lua_pop(L, vi);
+#else
+						lua_pop(L, (vi + 1));
+#endif
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil) {
+#if SOL_IS_ON(SOL_LUA_NIL_IN_TABLES) && SOL_LUA_VERSION_I_ >= 600
+#else
+					lua_pop(L, lua_size<V>::value);
+#endif
+					continue;
+				}
+
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+				lua_pop(L, lua_size<V>::value);
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					// see above comment
+					goto done;
+				}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 2, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type vt = type_of(L, -1);
+					isnil = vt == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						// see above comment
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				push_back_at_end(meta::has_push_back<Tu>(), t, L, cont, idx);
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		static T get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename Tu::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		template <typename K, typename V>
+		static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			T associative;
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T, typename Al>
+	struct unqualified_getter<as_table_t<std::forward_list<T, Al>>> {
+		typedef std::forward_list<T, Al> C;
+
+		static C get(lua_State* L, int relindex, record& tracking) {
+			return get(meta::has_key_value_pair<C>(), L, relindex, tracking);
+		}
+
+		static C get(std::true_type, lua_State* L, int index, record& tracking) {
+			typedef typename T::value_type P;
+			typedef typename P::first_type K;
+			typedef typename P::second_type V;
+			return get(types<K, V>(), L, index, tracking);
+		}
+
+		static C get(std::false_type, lua_State* L, int relindex, record& tracking) {
+			typedef typename C::value_type V;
+			return get(types<V>(), L, relindex, tracking);
+		}
+
+		template <typename V>
+		static C get(types<V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			int index = lua_absindex(L, relindex);
+			C cont;
+			auto at = cont.cbefore_begin();
+			std::size_t idx = 0;
+#if SOL_LUA_VERSION_I_ >= 503
+			// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					type t = static_cast<type>(lua_geti(L, index, i + vi));
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#else
+			// Zzzz slower but necessary thanks to the lower version API and missing functions qq
+			for (lua_Integer i = 0;; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
+				if (idx >= cont.max_size()) {
+					goto done;
+				}
+				bool isnil = false;
+				for (int vi = 0; vi < lua_size<V>::value; ++vi) {
+					lua_pushinteger(L, i);
+					lua_gettable(L, index);
+					type t = type_of(L, -1);
+					isnil = t == type::lua_nil;
+					if (isnil) {
+						if (i == 0) {
+							break;
+						}
+						lua_pop(L, (vi + 1));
+						goto done;
+					}
+				}
+				if (isnil)
+					continue;
+				at = cont.insert_after(at, stack::get<V>(L, -lua_size<V>::value));
+				++idx;
+			}
+#endif
+		done:
+			return cont;
+		}
+
+		template <typename K, typename V>
+		static C get(types<K, V>, lua_State* L, int relindex, record& tracking) {
+			tracking.use(1);
+
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 3, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+
+			C associative;
+			auto at = associative.cbefore_begin();
+			int index = lua_absindex(L, relindex);
+			lua_pushnil(L);
+			while (lua_next(L, index) != 0) {
+				decltype(auto) key = stack::check_get<K>(L, -2);
+				if (!key) {
+					lua_pop(L, 1);
+					continue;
+				}
+				at = associative.emplace_after(at, std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
+				lua_pop(L, 1);
+			}
+			return associative;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<nested<T>> {
+		static T get(lua_State* L, int index, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_container_v<Tu>) {
+				if constexpr (meta::is_associative<Tu>::value) {
+					typedef typename T::value_type P;
+					typedef typename P::first_type K;
+					typedef typename P::second_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<K, nested<V>>(), L, index, tracking);
+				}
+				else {
+					typedef typename T::value_type V;
+					unqualified_getter<as_table_t<T>> g{};
+					return g.get(types<nested<V>>(), L, index, tracking);
+				}
+			}
+			else {
+				unqualified_getter<Tu> g{};
+				return g.get(L, index, tracking);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T>(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<as_container_t<T>*> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return stack::unqualified_get<T*>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<userdata_value> {
+		static userdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return userdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lightuserdata_value> {
+		static lightuserdata_value get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lightuserdata_value(lua_touserdata(L, index));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<light<T>> {
+		static light<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			return light<T>(static_cast<T*>(memory));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T>> {
+		static std::add_lvalue_reference_t<T> get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T>(memory);
+			return *static_cast<std::remove_reference_t<T>*>(memory);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<user<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			void* memory = lua_touserdata(L, index);
+			memory = detail::align_user<T*>(memory);
+			return static_cast<T*>(memory);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<type> {
+		static type get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return static_cast<type>(lua_type(L, index));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::string> {
+		static std::string get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			std::size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return std::string(str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const char*> {
+		static const char* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			return lua_tolstring(L, index, &sz);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char> {
+		static char get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t len;
+			auto str = lua_tolstring(L, index, &len);
+			return len > 0 ? str[0] : '\0';
+		}
+	};
+
+	template <typename Traits>
+	struct unqualified_getter<basic_string_view<char, Traits>> {
+		static string_view get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz;
+			const char* str = lua_tolstring(L, index, &sz);
+			return basic_string_view<char, Traits>(str, sz);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<wchar_t, Traits, Al>> {
+		using S = std::basic_string<wchar_t, Traits, Al>;
+		static S get(lua_State* L, int index, record& tracking) {
+			using Ch = meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t>;
+			return stack_detail::get_into<Ch, S>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char16_t, Traits, Al>> {
+		static std::basic_string<char16_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char16_t, std::basic_string<char16_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <typename Traits, typename Al>
+	struct unqualified_getter<std::basic_string<char32_t, Traits, Al>> {
+		static std::basic_string<char32_t, Traits, Al> get(lua_State* L, int index, record& tracking) {
+			return stack_detail::get_into<char32_t, std::basic_string<char32_t, Traits, Al>>(L, index, tracking);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char16_t> {
+		static char16_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf16(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<char32_t> {
+		static char32_t get(lua_State* L, int index, record& tracking) {
+			string_view utf8 = stack::get<string_view>(L, index, tracking);
+			const char* strb = utf8.data();
+			const char* stre = utf8.data() + utf8.size();
+			char32_t cp = 0;
+			auto dr = unicode::utf8_to_code_point(strb, stre);
+			if (dr.error != unicode::error_code::ok) {
+				cp = unicode::unicode_detail::replacement;
+			}
+			else {
+				cp = dr.codepoint;
+			}
+			auto er = unicode::code_point_to_utf32(cp);
+			return er.code_units[0];
+		}
+	};
+
+	template <>
+	struct unqualified_getter<wchar_t> {
+		static wchar_t get(lua_State* L, int index, record& tracking) {
+			typedef meta::conditional_t<sizeof(wchar_t) == 2, char16_t, char32_t> Ch;
+			unqualified_getter<Ch> g;
+			(void)g;
+			auto c = g.get(L, index, tracking);
+			return static_cast<wchar_t>(c);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<meta_function> {
+		static meta_function get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			const char* name = unqualified_getter<const char*> {}.get(L, index, tracking);
+			const auto& mfnames = meta_function_names();
+			for (std::size_t i = 0; i < mfnames.size(); ++i)
+				if (mfnames[i] == name)
+					return static_cast<meta_function>(i);
+			return meta_function::construct;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_nil_t> {
+		static lua_nil_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return lua_nil;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<std::nullptr_t> {
+		static std::nullptr_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullptr;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<nullopt_t> {
+		static nullopt_t get(lua_State*, int, record& tracking) {
+			tracking.use(1);
+			return nullopt;
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_state> {
+		static this_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_state(L);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<this_main_state> {
+		static this_main_state get(lua_State* L, int, record& tracking) {
+			tracking.use(0);
+			return this_main_state(main_thread(L, L));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<lua_CFunction> {
+		static lua_CFunction get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_tocfunction(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<c_closure> {
+		static c_closure get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return c_closure(lua_tocfunction(L, index), -1);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<error> {
+		static error get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			size_t sz = 0;
+			const char* err = lua_tolstring(L, index, &sz);
+			if (err == nullptr) {
+				return error(detail::direct_error, "");
+			}
+			return error(detail::direct_error, std::string(err, sz));
+		}
+	};
+
+	template <>
+	struct unqualified_getter<void*> {
+		static void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <>
+	struct unqualified_getter<const void*> {
+		static const void* get(lua_State* L, int index, record& tracking) {
+			tracking.use(1);
+			return lua_touserdata(L, index);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_value_tag<T>> {
+		static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
+			void* memory = lua_touserdata(L, index);
+#if SOL_IS_ON(SOL_USE_INTEROP)
+			auto ugr = stack_detail::interop_get<T>(L, index, memory, tracking);
+			if (ugr.first) {
+				return ugr.second;
+			}
+#endif // interop extensibility
+			tracking.use(1);
+			void* rawdata = detail::align_usertype_pointer(memory);
+			void** pudata = static_cast<void**>(rawdata);
+			void* udata = *pudata;
+			return get_no_lua_nil_from(L, udata, index, tracking);
+		}
+
+		static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
+			bool has_derived = derive<T>::value || weak_derive<T>::value;
+			if (has_derived) {
+				if (lua_getmetatable(L, index) == 1) {
+					lua_getfield(L, -1, &detail::base_class_cast_key()[0]);
+					if (type_of(L, -1) != type::lua_nil) {
+						void* basecastdata = lua_touserdata(L, -1);
+						detail::inheritance_cast_function ic = reinterpret_cast<detail::inheritance_cast_function>(basecastdata);
+						// use the casting function to properly adjust the pointer for the desired T
+						udata = ic(udata, usertype_traits<T>::qualified_name());
+					}
+					lua_pop(L, 2);
+				}
+			}
+			if constexpr (std::is_function_v<T>) {
+				T* func = reinterpret_cast<T*>(udata);
+				return func;
+			}
+			else {
+				T* obj = static_cast<T*>(udata);
+				return obj;
+			}
+		}
+
+		static T& get(lua_State* L, int index, record& tracking) {
+			return *get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<detail::as_pointer_tag<T>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			type t = type_of(L, index);
+			if (t == type::lua_nil) {
+				tracking.use(1);
+				return nullptr;
+			}
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<non_null<T*>> {
+		static T* get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get_no_lua_nil(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T&> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<detail::as_value_tag<T>> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<std::reference_wrapper<T>> {
+		static T& get(lua_State* L, int index, record& tracking) {
+			unqualified_getter<T&> g{};
+			return g.get(L, index, tracking);
+		}
+	};
+
+	template <typename T>
+	struct unqualified_getter<T*> {
+		static T* get(lua_State* L, int index, record& tracking) {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+			if constexpr (std::is_function_v<T>) {
+				return stack_detail::get_function_pointer<T>(L, index, tracking);
+			}
+			else {
+				unqualified_getter<detail::as_pointer_tag<T>> g{};
+				return g.get(L, index, tracking);
+			}
+#else
+			unqualified_getter<detail::as_pointer_tag<T>> g{};
+			return g.get(L, index, tracking);
+#endif
+		}
+	};
+
+	template <typename... Tn>
+	struct unqualified_getter<std::tuple<Tn...>> {
+		typedef std::tuple<decltype(stack::get<Tn>(nullptr, 0))...> R;
+
+		template <typename... Args>
+		static R apply(std::index_sequence<>, lua_State*, int, record&, Args&&... args) {
+			// Fuck you too, VC++
+			return R { std::forward<Args>(args)... };
+		}
+
+		template <std::size_t I, std::size_t... Ix, typename... Args>
+		static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, Args&&... args) {
+			// Fuck you too, VC++
+			typedef std::tuple_element_t<I, std::tuple<Tn...>> T;
+			return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<Args>(args)..., stack::get<T>(L, index + tracking.used, tracking));
+		}
+
+		static R get(lua_State* L, int index, record& tracking) {
+			return apply(std::make_index_sequence<sizeof...(Tn)>(), L, index, tracking);
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_getter<std::pair<A, B>> {
+		static decltype(auto) get(lua_State* L, int index, record& tracking) {
+			return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))> { stack::get<A>(L, index, tracking),
+				stack::get<B>(L, index + tracking.used, tracking) };
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+
+	template <typename... Tn>
+	struct unqualified_getter<std::variant<Tn...>> {
+		using V = std::variant<Tn...>;
+
+		static V get_one(std::integral_constant<std::size_t, std::variant_size_v<V>>, lua_State* L, int index, record& tracking) {
+			(void)L;
+			(void)index;
+			(void)tracking;
+			if constexpr (std::variant_size_v<V> == 0) {
+				return V();
+			}
+			else {
+				// using T = std::variant_alternative_t<0, V>;
+				std::abort();
+				// return V(std::in_place_index<0>, stack::get<T>(L, index, tracking));
+			}
+		}
+
+		template <std::size_t I>
+		static V get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, record& tracking) {
+			typedef std::variant_alternative_t<I, V> T;
+			record temp_tracking = tracking;
+			if (stack::check<T>(L, index, &no_panic, temp_tracking)) {
+				tracking = temp_tracking;
+				return V(std::in_place_index<I>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I + 1>(), L, index, tracking);
+		}
+
+		static V get(lua_State* L, int index, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, 0>(), L, index, tracking);
+		}
+	};
+#endif // variant
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_unqualified.hpp
+
+// beginning of sol/stack_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+	// There are no more enable_ifs that can be used here,
+	// so this is just for posterity, I guess?
+	// maybe I'll fill this file in later.
+
+}} // namespace sol::stack
+
+// end of sol/stack_get_qualified.hpp
+
+// end of sol/stack_get.hpp
+
+// beginning of sol/stack_check_get.hpp
+
+// beginning of sol/stack_check_get_unqualified.hpp
+
+#include <cstdlib>
+#include <cmath>
+#include <optional>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // variant shenanigans (thanks, Mac OSX)
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct unqualified_check_getter {
+		typedef decltype(stack_detail::unchecked_unqualified_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Optional, typename Handler>
+		static Optional get_using(lua_State* L, int index, Handler&& handler, record& tracking) {
+			if constexpr (!meta::meta_detail::is_adl_sol_lua_check_v<T> && !meta::meta_detail::is_adl_sol_lua_get_v<T>) {
+				if constexpr (is_lua_reference_v<T>) {
+					if constexpr (is_global_table_v<T>) {
+						(void)L;
+						(void)index;
+						(void)handler;
+						tracking.use(1);
+						return true;
+					}
+					else {
+						// actually check if it's none here, otherwise
+						// we'll have a none object inside an optional!
+						bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+						if (!success) {
+							// expected type, actual type
+							tracking.use(static_cast<int>(success));
+							handler(L, index, type::poly, type_of(L, index), "");
+							return detail::associated_nullopt_v<Optional>;
+						}
+						return stack_detail::unchecked_get<T>(L, index, tracking);
+					}
+				}
+				else if constexpr ((std::is_integral_v<T> || std::is_same_v<T, lua_Integer>)&&!std::is_same_v<T, bool>) {
+#if SOL_LUA_VERSION_I_ >= 503
+					if (lua_isinteger(L, index) != 0) {
+						tracking.use(1);
+						return static_cast<T>(lua_tointeger(L, index));
+					}
+#endif
+					int isnum = 0;
+					const lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum != 0) {
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+						const auto integer_value = llround(value);
+						if (static_cast<lua_Number>(integer_value) == value) {
+							tracking.use(1);
+							return static_cast<T>(integer_value);
+						}
+#else
+						tracking.use(1);
+						return static_cast<T>(value);
+#endif
+					}
+					const type t = type_of(L, index);
+					tracking.use(static_cast<int>(t != type::none));
+					handler(L, index, type::number, t, "not an integer");
+					return detail::associated_nullopt_v<Optional>;
+				}
+				else if constexpr (std::is_floating_point_v<T> || std::is_same_v<T, lua_Number>) {
+					int isnum = 0;
+					lua_Number value = lua_tonumberx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid floating point number");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else if constexpr (std::is_enum_v<T> && !meta::any_same_v<T, meta_function, type>) {
+					int isnum = 0;
+					lua_Integer value = lua_tointegerx(L, index, &isnum);
+					if (isnum == 0) {
+						type t = type_of(L, index);
+						tracking.use(static_cast<int>(t != type::none));
+						handler(L, index, type::number, t, "not a valid enumeration value");
+						return detail::associated_nullopt_v<Optional>;
+					}
+					tracking.use(1);
+					return static_cast<T>(value);
+				}
+				else {
+					if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+						tracking.use(static_cast<int>(!lua_isnone(L, index)));
+						return detail::associated_nullopt_v<Optional>;
+					}
+					return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+				}
+			}
+			else {
+				if (!unqualified_check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return detail::associated_nullopt_v<Optional>;
+				}
+				return stack_detail::unchecked_unqualified_get<T>(L, index, tracking);
+			}
+		}
+
+		template <typename Handler>
+		static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_using<optional<R>>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	template <typename... Tn, typename C>
+	struct unqualified_check_getter<std::variant<Tn...>, C> {
+		typedef std::variant<Tn...> V;
+		typedef std::variant_size<V> V_size;
+		typedef std::integral_constant<bool, V_size::value == 0> V_is_empty;
+
+		template <typename Handler>
+		static optional<V> get_empty(std::true_type, lua_State*, int, Handler&&, record&) {
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_empty(std::false_type, lua_State* L, int index, Handler&& handler, record&) {
+			// This should never be reached...
+			// please check your code and understand what you did to bring yourself here
+			// maybe file a bug report, or 5
+			handler(
+				L, index, type::poly, type_of(L, index), "this variant code should never be reached: if it has, you have done something so terribly wrong");
+			return nullopt;
+		}
+
+		template <typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, 0>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_empty(V_is_empty(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <std::size_t I, typename Handler>
+		static optional<V> get_one(std::integral_constant<std::size_t, I>, lua_State* L, int index, Handler&& handler, record& tracking) {
+			typedef std::variant_alternative_t<I - 1, V> T;
+			if (stack::check<T>(L, index, &no_panic, tracking)) {
+				return V(std::in_place_index<I - 1>, stack::get<T>(L, index));
+			}
+			return get_one(std::integral_constant<std::size_t, I - 1>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+
+		template <typename Handler>
+		static optional<V> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return get_one(std::integral_constant<std::size_t, V_size::value>(), L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+#endif // standard variant
+}}     // namespace sol::stack
+
+// end of sol/stack_check_get_unqualified.hpp
+
+// beginning of sol/stack_check_get_qualified.hpp
+
+namespace sol { namespace stack {
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+	namespace stack_detail {
+		template <typename OptionalType, typename T, typename Handler>
+		OptionalType get_optional(lua_State* L, int index, Handler&& handler, record& tracking) {
+			using Tu = meta::unqualified_t<T>;
+
+			if constexpr (is_lua_reference_v<T>) {
+				if constexpr (is_global_table_v<Tu>) {
+					(void)L;
+					(void)index;
+					(void)handler;
+					tracking.use(1);
+					return true;
+				}
+				else {
+					// actually check if it's none here, otherwise
+					// we'll have a none object inside an optional!
+					bool success = lua_isnoneornil(L, index) == 0 && stack::check<T>(L, index, &no_panic);
+					if (!success) {
+						// expected type, actual type
+						tracking.use(static_cast<int>(success));
+						handler(L, index, type::poly, type_of(L, index), "");
+						return {};
+					}
+					return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+				}
+			}
+			else if constexpr (!std::is_reference_v<T> && is_unique_usertype_v<Tu> && !is_actual_type_rebindable_for_v<Tu>) {
+				// we can take shortcuts here to save on separate checking, and just return nullopt!
+				using element = unique_usertype_element_t<Tu>;
+				using actual = unique_usertype_actual_t<Tu>;
+				tracking.use(1);
+				void* memory = lua_touserdata(L, index);
+				memory = detail::align_usertype_unique_destructor(memory);
+				detail::unique_destructor& pdx = *static_cast<detail::unique_destructor*>(memory);
+				if (&detail::usertype_unique_alloc_destroy<element, Tu> == pdx) {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					actual* mem = static_cast<actual*>(memory);
+					return static_cast<actual>(*mem);
+				}
+				if constexpr (!derive<element>::value) {
+					return OptionalType();
+				}
+				else {
+					memory = detail::align_usertype_unique_tag<true, false>(memory);
+					detail::unique_tag& ic = *reinterpret_cast<detail::unique_tag*>(memory);
+					memory = detail::align_usertype_unique<actual, true, false>(memory);
+					string_view ti = usertype_traits<element>::qualified_name();
+					int cast_operation;
+					actual r {};
+					if constexpr (is_actual_type_rebindable_for_v<Tu>) {
+						using rebound_actual_type = unique_usertype_rebind_actual_t<Tu, void>;
+						string_view rebind_ti = usertype_traits<rebound_actual_type>::qualified_name();
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					else {
+						string_view rebind_ti("");
+						cast_operation = ic(memory, &r, ti, rebind_ti);
+					}
+					switch (cast_operation) {
+					case 1: {
+						// it's a perfect match,
+						// alias memory directly
+						actual* mem = static_cast<actual*>(memory);
+						return OptionalType(*mem);
+					}
+					case 2:
+						// it's a base match, return the
+						// aliased creation
+						return OptionalType(std::move(r));
+					default:
+						break;
+					}
+					return OptionalType();
+				}
+			}
+			else {
+				if (!check<T>(L, index, std::forward<Handler>(handler))) {
+					tracking.use(static_cast<int>(!lua_isnone(L, index)));
+					return OptionalType();
+				}
+				return OptionalType(stack_detail::unchecked_get<T>(L, index, tracking));
+			}
+		}
+	} // namespace stack_detail
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+	template <typename T, typename>
+	struct qualified_check_getter {
+		typedef decltype(stack_detail::unchecked_get<T>(nullptr, -1, std::declval<record&>())) R;
+
+		template <typename Handler>
+		optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+			return stack_detail::get_optional<optional<R>, T>(L, index, std::forward<Handler>(handler), tracking);
+		}
+	};
+
+	template <typename Optional>
+	struct qualified_getter<Optional, std::enable_if_t<meta::is_optional_v<Optional>>> {
+		static Optional get(lua_State* L, int index, record& tracking) {
+			using T = typename meta::unqualified_t<Optional>::value_type;
+			return stack_detail::get_optional<Optional, T>(L, index, &no_panic, tracking);
+		}
+	};
+
+}} // namespace sol::stack
+
+// end of sol/stack_check_get_qualified.hpp
+
+// end of sol/stack_check_get.hpp
+
+// beginning of sol/stack_push.hpp
+
+#include <memory>
+#include <type_traits>
+#include <cassert>
+#include <limits>
+#include <cmath>
+#include <string_view>
+#if SOL_IS_ON(SOL_STD_VARIANT)
+#include <variant>
+#endif // Can use variant
+
+// beginning of sol/debug.hpp
+
+#include <iostream>
+
+namespace sol { namespace detail { namespace debug {
+	inline std::string dump_types(lua_State* L) {
+		std::string visual;
+		std::size_t size = lua_gettop(L) + 1;
+		for (std::size_t i = 1; i < size; ++i) {
+			if (i != 1) {
+				visual += " | ";
+			}
+			visual += type_name(L, stack::get<type>(L, static_cast<int>(i)));
+		}
+		return visual;
+	}
+
+	inline void print_stack(lua_State* L) {
+		std::cout << dump_types(L) << std::endl;
+	}
+
+	inline void print_section(const std::string& message, lua_State* L) {
+		std::cout << "-- " << message << " -- [ " << dump_types(L) << " ]" << std::endl;
+	}
+}}} // namespace sol::detail::debug
+
+// end of sol/debug.hpp
+
+namespace sol { namespace stack {
+	namespace stack_detail {
+		template <typename T>
+		inline bool integer_value_fits(const T& value) {
+			// We check if we can rely on casts or a lack of padding bits to satisfy
+			// the requirements here
+			// If it lacks padding bits, we can jump back and forth between lua_Integer and whatever type without
+			// loss of information
+			constexpr bool is_same_signedness
+				= (std::is_signed_v<T> && std::is_signed_v<lua_Integer>) || (std::is_unsigned_v<T> && std::is_unsigned_v<lua_Integer>);
+			constexpr bool probaby_fits_within_lua_Integer = sizeof(T) == sizeof(lua_Integer)
+#if SOL_IS_ON(SOL_ALL_INTEGER_VALUES_FIT)
+				&& ((std::has_unique_object_representations_v<T> && std::has_unique_object_representations_v<lua_Integer>) ? true : is_same_signedness)
+#else
+				&& is_same_signedness
+#endif
+				;
+			if constexpr (sizeof(T) < sizeof(lua_Integer) || probaby_fits_within_lua_Integer) {
+				(void)value;
+				return true;
+			}
+			else {
+				auto u_min = static_cast<std::intmax_t>((std::numeric_limits<lua_Integer>::min)());
+				auto u_max = static_cast<std::uintmax_t>((std::numeric_limits<lua_Integer>::max)());
+				auto t_min = static_cast<std::intmax_t>((std::numeric_limits<T>::min)());
+				auto t_max = static_cast<std::uintmax_t>((std::numeric_limits<T>::max)());
+				return (u_min <= t_min || value >= static_cast<T>(u_min)) && (u_max >= t_max || value <= static_cast<T>(u_max));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::true_type, lua_State* L, const T& value) {
+			if constexpr (meta::any_same_v<std::underlying_type_t<T>,
+				              char
+#if SOL_IS_ON(SOL_CHAR8_T)
+				              ,
+				              char8_t
+#endif
+				              ,
+				              char16_t,
+				              char32_t>) {
+				if constexpr (std::is_signed_v<T>) {
+					return stack::push(L, static_cast<std::int_least32_t>(value));
+				}
+				else {
+					return stack::push(L, static_cast<std::uint_least32_t>(value));
+				}
+			}
+			else {
+				return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
+			}
+		}
+
+		template <typename T>
+		int msvc_is_ass_with_if_constexpr_push_enum(std::false_type, lua_State*, const T&) {
+			return 0;
+		}
+	} // namespace stack_detail
+
+	inline int push_environment_of(lua_State* L, int target_index = -1) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+		luaL_checkstack(L, 1, detail::not_enough_stack_space_environment);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ < 502
+		// Use lua_getfenv
+		lua_getfenv(L, target_index);
+#else
+
+		if (lua_iscfunction(L, target_index) != 0) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+			if (maybe_upvalue_name != nullptr) {
+				// it worked, take this one
+				return 1;
+			}
+		}
+		// Nominally, we search for the `"_ENV"` value.
+		// If we don't find it.... uh, well. We've got a problem?
+		for (int upvalue_index = 1;; ++upvalue_index) {
+			const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+			if (maybe_upvalue_name == nullptr) {
+				push(L, lua_nil);
+				break;
+			}
+
+			string_view upvalue_name(maybe_upvalue_name);
+			if (upvalue_name == "_ENV") {
+				// Keep this one!
+				break;
+			}
+			// Discard what we received, loop back around
+			lua_pop(L, 1);
+		}
+#endif
+		return 1;
+	}
+
+	template <typename T>
+	int push_environment_of(const T& target) {
+		lua_State* target_L = target.lua_state();
+		int target_index = absolute_index(target_L, -target.push());
+		int env_count = push_environment_of(target_L, target_index);
+		sol_c_assert(env_count == 1);
+		lua_rotate(target_L, target_index, 1);
+		lua_pop(target_L, 1);
+		return env_count;
+	}
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_value_tag<T>> {
+		template <typename F, typename... Args>
+		static int push_fx(lua_State* L, F&& f, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // Basically, we store all user-data like this:
+       // If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
+       // data in the first sizeof(T*) bytes, and then however many bytes it takes to
+       // do the actual object. Things that are std::ref or plain T* are stored as
+       // just the sizeof(T*), and nothing else.
+			T* obj = detail::usertype_allocate<T>(L);
+			f();
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, obj, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename K, typename... Args>
+		static int push_keyed(lua_State* L, K&& k, Args&&... args) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<T>);
+			return push_fx(L, fx, std::forward<Args>(args)...);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L) {
+			return push_keyed(L, usertype_traits<T>::metatable());
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_pointer_tag<T>> {
+		typedef meta::unqualified_t<T> U;
+
+		template <typename F>
+		static int push_fx(lua_State* L, F&& f, T* obj) {
+			if (obj == nullptr)
+				return stack::push(L, lua_nil);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			T** pref = detail::usertype_allocate_pointer<T>(L);
+			f();
+			*pref = obj;
+			return 1;
+		}
+
+		template <typename K>
+		static int push_keyed(lua_State* L, K&& k, T* obj) {
+			stack_detail::undefined_metatable fx(L, &k[0], &stack::stack_detail::set_undefined_methods_on<U*>);
+			return push_fx(L, fx, obj);
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, detail::with_function_tag>) {
+				(void)arg;
+				return push_fx(L, std::forward<Args>(args)...);
+			}
+			else {
+				return push_keyed(L, usertype_traits<U*>::metatable(), std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::as_reference_tag> {
+		template <typename T>
+		static int push(lua_State* L, T&& obj) {
+			return stack::push(L, detail::ptr(obj));
+		}
+	};
+
+	namespace stack_detail {
+		template <typename T>
+		struct uu_pusher {
+			using element = unique_usertype_element_t<T>;
+			using actual = unique_usertype_actual_t<T>;
+
+			template <typename Arg, typename... Args>
+			static int push(lua_State* L, Arg&& arg, Args&&... args) {
+				if constexpr (std::is_base_of_v<actual, meta::unqualified_t<Arg>>) {
+					if (detail::unique_is_null(L, arg)) {
+						return stack::push(L, lua_nil);
+					}
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+				else {
+					return push_deep(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
+				}
+			}
+
+			template <typename... Args>
+			static int push_deep(lua_State* L, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+				element** pointer_to_memory = nullptr;
+				detail::unique_destructor* fx = nullptr;
+				detail::unique_tag* id = nullptr;
+				actual* typed_memory = detail::usertype_unique_allocate<element, actual>(L, pointer_to_memory, fx, id);
+				if (luaL_newmetatable(L, &usertype_traits<d::u<std::remove_cv_t<element>>>::metatable()[0]) == 1) {
+					detail::lua_reg_table registration_table {};
+					int index = 0;
+					detail::indexed_insert insert_callable(registration_table, index);
+					detail::insert_default_registrations<element>(insert_callable, detail::property_always_true);
+					registration_table[index] = { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+					luaL_setfuncs(L, registration_table, 0);
+				}
+				lua_setmetatable(L, -2);
+				*fx = detail::usertype_unique_alloc_destroy<element, actual>;
+				*id = &detail::inheritance<element>::template type_unique_cast<actual>;
+				detail::default_construct::construct(typed_memory, std::forward<Args>(args)...);
+				*pointer_to_memory = detail::unique_get<T>(L, *typed_memory);
+				return 1;
+			}
+		};
+	} // namespace stack_detail
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_unique_tag<T>> {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			stack_detail::uu_pusher<T> p;
+			(void)p;
+			return p.push(L, std::forward<Args>(args)...);
+		}
+	};
+
+	template <typename T, typename>
+	struct unqualified_pusher {
+		template <typename... Args>
+		static int push(lua_State* L, Args&&... args) {
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (is_lua_reference_v<Tu>) {
+				using int_arr = int[];
+				int_arr p { (std::forward<Args>(args).push(L))... };
+				return p[0];
+			}
+			else if constexpr (std::is_same_v<Tu, bool>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushboolean(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_integral_v<Tu> || std::is_same_v<Tu, lua_Integer>) {
+				const Tu& value(std::forward<Args>(args)...);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_integral);
+#endif // make sure stack doesn't overflow
+#if SOL_LUA_VERSION_I_ >= 503
+				if (stack_detail::integer_value_fits<Tu>(value)) {
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+				}
+#endif // Lua 5.3 and above
+#if SOL_IS_ON(SOL_NUMBER_PRECISION_CHECKS)
+				if (static_cast<T>(llround(static_cast<lua_Number>(value))) != value) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+					// Is this really worth it?
+					sol_m_assert(false, "integer value will be misrepresented in lua");
+					lua_pushinteger(L, static_cast<lua_Integer>(value));
+					return 1;
+#else
+					throw error(detail::direct_error, "integer value will be misrepresented in lua");
+#endif // No Exceptions
+				}
+#endif // Safe Numerics and Number Precision Check
+				lua_pushnumber(L, static_cast<lua_Number>(value));
+				return 1;
+			}
+			else if constexpr (std::is_floating_point_v<Tu> || std::is_same_v<Tu, lua_Number>) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_floating);
+#endif // make sure stack doesn't overflow
+				lua_pushnumber(L, std::forward<Args>(args)...);
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream*>) {
+				luaL_Stream* source { std::forward<Args>(args)... };
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source->f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source->closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_same_v<Tu, luaL_Stream>) {
+				luaL_Stream& source(std::forward<Args>(args)...);
+				luaL_Stream* stream = static_cast<luaL_Stream*>(detail::alloc_newuserdata(L, sizeof(luaL_Stream)));
+				stream->f = source.f;
+#if SOL_IS_ON(SOL_LUAL_STREAM_USE_CLOSE_FUNCTION)
+				stream->closef = source.closef;
+#endif // LuaJIT and Lua 5.1 and below do not have
+				return 1;
+			}
+			else if constexpr (std::is_enum_v<Tu>) {
+				return stack_detail::msvc_is_ass_with_if_constexpr_push_enum(std::true_type(), L, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_pointer_v<Tu>) {
+				return stack::push<detail::as_pointer_tag<std::remove_pointer_t<T>>>(L, std::forward<Args>(args)...);
+			}
+			else if constexpr (is_unique_usertype_v<Tu>) {
+				return stack::push<detail::as_unique_tag<T>>(L, std::forward<Args>(args)...);
+			}
+			else {
+				return stack::push<detail::as_value_tag<T>>(L, std::forward<Args>(args)...);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::reference_wrapper<T>> {
+		static int push(lua_State* L, const std::reference_wrapper<T>& t) {
+			return stack::push(L, std::addressof(detail::deref(t.get())));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<detail::as_table_tag<T>> {
+		using has_kvp = meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+		static int push(lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		static int push(lua_State* L, const T& tablecont, nested_tag_t) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::true_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::true_type(), L, tablecont);
+		}
+
+		static int push(std::false_type, lua_State* L, const T& tablecont) {
+			return push(has_kvp(), std::false_type(), L, tablecont);
+		}
+
+		template <bool is_nested>
+		static int push(std::true_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, static_cast<int>(cont.size()), 0);
+			int tableindex = lua_gettop(L);
+			for (const auto& pair : cont) {
+				if (is_nested) {
+					set_field(L, pair.first, as_nested_ref(pair.second), tableindex);
+				}
+				else {
+					set_field(L, pair.first, pair.second, tableindex);
+				}
+			}
+			return 1;
+		}
+
+		template <bool is_nested>
+		static int push(std::false_type, std::integral_constant<bool, is_nested>, lua_State* L, const T& tablecont) {
+			auto& cont = detail::deref(detail::unwrap(tablecont));
+			lua_createtable(L, stack_detail::get_size_hint(cont), 0);
+			int tableindex = lua_gettop(L);
+			std::size_t index = 1;
+			for (const auto& i : cont) {
+#if SOL_LUA_VERSION_I_ >= 503
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				for (int pi = 0; pi < p; ++pi) {
+					lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
+				}
+#else
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				lua_pushinteger(L, static_cast<lua_Integer>(index));
+				int p = is_nested ? stack::push(L, as_nested_ref(i)) : stack::push(L, i);
+				if (p == 1) {
+					++index;
+					lua_settable(L, tableindex);
+				}
+				else {
+					int firstindex = tableindex + 1 + 1;
+					for (int pi = 0; pi < p; ++pi) {
+						stack::push(L, index);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+						luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+						lua_pushvalue(L, firstindex);
+						lua_settable(L, tableindex);
+						++index;
+						++firstindex;
+					}
+					lua_pop(L, 1 + p);
+				}
+#endif // Lua Version 5.3 and others
+			}
+			// TODO: figure out a better way to do this...?
+			// set_field(L, -1, cont.size());
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<as_table_t<T>> {
+		static int push(lua_State* L, const as_table_t<T>& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_.value());
+			}
+			else {
+				return stack::push(L, value_.value());
+			}
+		}
+
+		static int push(lua_State* L, const T& value_) {
+			using inner_t = std::remove_pointer_t<meta::unwrap_unqualified_t<T>>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, value_);
+			}
+			else {
+				return stack::push(L, value_);
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<nested<T>> {
+		static int push(lua_State* L, const T& nested_value) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_value, nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_value);
+			}
+		}
+
+		static int push(lua_State* L, const nested<T>& nested_wrapper_) noexcept {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			using inner_t = std::remove_pointer_t<Tu>;
+			if constexpr (is_container_v<inner_t>) {
+				return stack::push<detail::as_table_tag<T>>(L, nested_wrapper_.value(), nested_tag);
+			}
+			else {
+				return stack::push<Tu>(L, nested_wrapper_.value());
+			}
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<std::initializer_list<T>> {
+		static int push(lua_State* L, const std::initializer_list<T>& il) noexcept {
+			unqualified_pusher<detail::as_table_tag<std::initializer_list<T>>> p {};
+			return p.push(L, il);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_nil_t> {
+		static int push(lua_State* L, lua_nil_t) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<stack_count> {
+		static int push(lua_State*, stack_count st) noexcept {
+			return st.count;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<metatable_key_t> {
+		static int push(lua_State* L, metatable_key_t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, to_string(meta_function::metatable).c_str(), 4);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<lua_CFunction>> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lua_CFunction> {
+		static int push(lua_State* L, lua_CFunction func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	template <>
+	struct unqualified_pusher<std::remove_pointer_t<detail::lua_CFunction_noexcept>> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<detail::lua_CFunction_noexcept> {
+		static int push(lua_State* L, detail::lua_CFunction_noexcept func, int n = 0) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, func, n);
+			return 1;
+		}
+	};
+#endif // noexcept function type
+
+	template <>
+	struct unqualified_pusher<c_closure> {
+		static int push(lua_State* L, c_closure cc) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushcclosure(L, cc.c_function, cc.upvalues);
+			return 1;
+		}
+	};
+
+	template <typename Arg, typename... Args>
+	struct unqualified_pusher<closure<Arg, Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
+			using f_tuple = decltype(std::forward<T>(c).upvalues);
+			int pushcount = multi_push(L, std::get<I>(std::forward<f_tuple>(std::forward<T>(c).upvalues))...);
+			return stack::push(L, c_closure(c.c_function, pushcount));
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& c) {
+			return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<void*> {
+		static int push(lua_State* L, void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const void*> {
+		static int push(lua_State* L, const void* userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, const_cast<void*>(userdata));
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<lightuserdata_value> {
+		static int push(lua_State* L, lightuserdata_value userdata) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, userdata);
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<light<T>> {
+		static int push(lua_State* L, light<T> l) noexcept {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, static_cast<void*>(l.value()));
+			return 1;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<user<T>> {
+		template <bool with_meta = true, typename Key, typename... Args>
+		static int push_with(lua_State* L, Key&& name, Args&&... args) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+       // A dumb pusher
+			T* data = detail::user_allocate<T>(L);
+			if (with_meta) {
+				// Make sure we have a plain GC set for this data
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				if (luaL_newmetatable(L, name) != 0) {
+					lua_CFunction cdel = detail::user_alloc_destroy<T>;
+					lua_pushcclosure(L, cdel, 0);
+					lua_setfield(L, -2, "__gc");
+				}
+				lua_setmetatable(L, -2);
+			}
+			std::allocator<T> alloc {};
+			std::allocator_traits<std::allocator<T>>::construct(alloc, data, std::forward<Args>(args)...);
+			return 1;
+		}
+
+		template <typename Arg, typename... Args>
+		static int push(lua_State* L, Arg&& arg, Args&&... args) {
+			if constexpr (std::is_same_v<meta::unqualified_t<Arg>, metatable_key_t>) {
+				const auto name = &arg[0];
+				return push_with<true>(L, name, std::forward<Args>(args)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Arg>, no_metatable_t>) {
+				(void)arg;
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with<false>(L, name, std::forward<Args>(args)...);
+			}
+			else {
+				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+				return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
+			}
+		}
+
+		static int push(lua_State* L, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, u.value);
+		}
+
+		static int push(lua_State* L, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with(L, name, std::move(u.value()));
+		}
+
+		static int push(lua_State* L, no_metatable_t, const user<T>& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, u.value());
+		}
+
+		static int push(lua_State* L, no_metatable_t, user<T>&& u) {
+			const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
+			return push_with<false>(L, name, std::move(u.value()));
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<userdata_value> {
+		static int push(lua_State* L, userdata_value data) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_userdata);
+#endif // make sure stack doesn't overflow
+			void** ud = detail::usertype_allocate_pointer<void>(L);
+			*ud = data.value();
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(str));
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char*> {
+		static int push_sized(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char* str) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char* strb, const char* stre) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char* str, std::size_t len) {
+			unqualified_pusher<const char*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char[N]> {
+		static int push(lua_State* L, const char (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, std::char_traits<char>::length(str));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char> {
+		static int push(lua_State* L, char c) {
+			const char str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char*>(str), 1u);
+		}
+	};
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+	template <>
+	struct unqualified_pusher<const char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, reinterpret_cast<const char*>(str), len);
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			if (str == nullptr)
+				return stack::push(L, lua_nil);
+			return push_sized(L, str, std::char_traits<char>::length(reinterpret_cast<const char*>(str)));
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			return push_sized(L, strb, static_cast<std::size_t>(stre - strb));
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			return push_sized(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t*> {
+		static int push_sized(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push_sized(L, str, len);
+		}
+
+		static int push(lua_State* L, const char8_t* str) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char8_t* strb, const char8_t* stre) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char8_t* str, std::size_t len) {
+			unqualified_pusher<const char8_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char8_t[N]> {
+		static int push(lua_State* L, const char8_t (&str)[N]) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			const char* str_as_char = reinterpret_cast<const char*>(static_cast<const char8_t*>(str));
+			lua_pushlstring(L, str_as_char, std::char_traits<char>::length(str_as_char));
+			return 1;
+		}
+
+		static int push(lua_State* L, const char8_t (&str)[N], std::size_t sz) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+			lua_pushlstring(L, str, sz);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char8_t> {
+		static int push(lua_State* L, char8_t c) {
+			const char8_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char8_t*>(str), 1u);
+		}
+	};
+#endif // char8_t
+
+	template <typename Ch, typename Traits, typename Al>
+	struct unqualified_pusher<std::basic_string<Ch, Traits, Al>> {
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), str.size());
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), str.size());
+				return 1;
+			}
+		}
+
+		static int push(lua_State* L, const std::basic_string<Ch, Traits, Al>& str, std::size_t sz) {
+			if constexpr (!std::is_same_v<Ch, char>) {
+				return stack::push(L, str.data(), sz);
+			}
+			else {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, 1, detail::not_enough_stack_space_string);
+#endif // make sure stack doesn't overflow
+				lua_pushlstring(L, str.c_str(), sz);
+				return 1;
+			}
+		}
+	};
+
+	template <typename Ch, typename Traits>
+	struct unqualified_pusher<basic_string_view<Ch, Traits>> {
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv) {
+			return stack::push(L, sv.data(), sv.length());
+		}
+
+		static int push(lua_State* L, const basic_string_view<Ch, Traits>& sv, std::size_t n) {
+			return stack::push(L, sv.data(), n);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<meta_function> {
+		static int push(lua_State* L, meta_function m) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_meta_function_name);
+#endif // make sure stack doesn't overflow
+			const std::string& str = to_string(m);
+			lua_pushlstring(L, str.c_str(), str.size());
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<absolute_index> {
+		static int push(lua_State* L, absolute_index ai) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ai);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<raw_index> {
+		static int push(lua_State* L, raw_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushvalue(L, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<ref_index> {
+		static int push(lua_State* L, ref_index ri) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_rawgeti(L, LUA_REGISTRYINDEX, ri);
+			return 1;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const wchar_t*> {
+		static int push(lua_State* L, const wchar_t* wstr) {
+			return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
+		}
+
+		static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
+			return push(L, wstr, wstr + sz);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			if constexpr (sizeof(wchar_t) == 2) {
+				const char16_t* sb = reinterpret_cast<const char16_t*>(strb);
+				const char16_t* se = reinterpret_cast<const char16_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+			else {
+				const char32_t* sb = reinterpret_cast<const char32_t*>(strb);
+				const char32_t* se = reinterpret_cast<const char32_t*>(stre);
+				return stack::push(L, sb, se);
+			}
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t*> {
+		static int push(lua_State* L, const wchar_t* str) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const wchar_t* str, std::size_t len) {
+			unqualified_pusher<const wchar_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char16_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char16_t* strb, const char16_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* utf8data = er.code_units.data();
+				std::memcpy(target, utf8data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char16_t* u16str) {
+			return push(L, u16str, std::char_traits<char16_t>::length(u16str));
+		}
+
+		static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
+			return push(L, u16str, u16str + sz);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char16_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf16_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t*> {
+		static int push(lua_State* L, const char16_t* str) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char16_t* str, std::size_t len) {
+			unqualified_pusher<const char16_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<const char32_t*> {
+		static int convert_into(lua_State* L, char* start, std::size_t, const char32_t* strb, const char32_t* stre) {
+			char* target = start;
+			char32_t cp = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				if (dr.error != unicode::error_code::ok) {
+					cp = unicode::unicode_detail::replacement;
+				}
+				else {
+					cp = dr.codepoint;
+				}
+				auto er = unicode::code_point_to_utf8(cp);
+				const char* data = er.code_units.data();
+				std::memcpy(target, data, er.code_units_size);
+				target += er.code_units_size;
+				strtarget = dr.next;
+			}
+			return stack::push(L, start, target);
+		}
+
+		static int push(lua_State* L, const char32_t* u32str) {
+			return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
+		}
+
+		static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
+			return push(L, u32str, u32str + sz);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			char sbo[SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_];
+			// if our max string space is small enough, use SBO
+			// right off the bat
+			std::size_t max_possible_code_units = static_cast<std::size_t>(static_cast<std::size_t>(stre - strb) * static_cast<std::size_t>(4));
+			if (max_possible_code_units <= SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, max_possible_code_units, strb, stre);
+			}
+			// otherwise, we must manually count/check size
+			std::size_t needed_size = 0;
+			for (const char32_t* strtarget = strb; strtarget < stre;) {
+				auto dr = unicode::utf32_to_code_point(strtarget, stre);
+				auto er = unicode::code_point_to_utf8(dr.codepoint);
+				needed_size += er.code_units_size;
+				strtarget = dr.next;
+			}
+			if (needed_size < SOL_OPTIMIZATION_STRING_CONVERSION_STACK_SIZE_I_) {
+				return convert_into(L, sbo, needed_size, strb, stre);
+			}
+			std::string u8str("", 0);
+			u8str.resize(needed_size);
+			char* target = const_cast<char*>(u8str.data());
+			return convert_into(L, target, needed_size, strb, stre);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t*> {
+		static int push(lua_State* L, const char32_t* str) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str);
+		}
+
+		static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, strb, stre);
+		}
+
+		static int push(lua_State* L, const char32_t* str, std::size_t len) {
+			unqualified_pusher<const char32_t*> p {};
+			(void)p;
+			return p.push(L, str, len);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<wchar_t[N]> {
+		static int push(lua_State* L, const wchar_t (&str)[N]) {
+			return push(L, str, std::char_traits<wchar_t>::length(str));
+		}
+
+		static int push(lua_State* L, const wchar_t (&str)[N], std::size_t sz) {
+			const wchar_t* str_ptr = static_cast<const wchar_t*>(str);
+			return stack::push<const wchar_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char16_t[N]> {
+		static int push(lua_State* L, const char16_t (&str)[N]) {
+			return push(L, str, std::char_traits<char16_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char16_t (&str)[N], std::size_t sz) {
+			const char16_t* str_ptr = static_cast<const char16_t*>(str);
+			return stack::push<const char16_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <size_t N>
+	struct unqualified_pusher<char32_t[N]> {
+		static int push(lua_State* L, const char32_t (&str)[N]) {
+			return push(L, str, std::char_traits<char32_t>::length(str));
+		}
+
+		static int push(lua_State* L, const char32_t (&str)[N], std::size_t sz) {
+			const char32_t* str_ptr = static_cast<const char32_t*>(str);
+			return stack::push<const char32_t*>(L, str_ptr, str_ptr + sz);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<wchar_t> {
+		static int push(lua_State* L, wchar_t c) {
+			const wchar_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const wchar_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char16_t> {
+		static int push(lua_State* L, char16_t c) {
+			const char16_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char16_t*>(str), 1u);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<char32_t> {
+		static int push(lua_State* L, char32_t c) {
+			const char32_t str[2] = { c, '\0' };
+			return stack::push(L, static_cast<const char32_t*>(str), 1u);
+		}
+	};
+
+	template <typename... Args>
+	struct unqualified_pusher<std::tuple<Args...>> {
+		template <std::size_t... I, typename T>
+		static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sizeof...(I)), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			int pushcount = 0;
+			(void)detail::swallow { 0, (pushcount += stack::push(L, std::get<I>(std::forward<T>(t))), 0)... };
+			return pushcount;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
+		}
+	};
+
+	template <typename A, typename B>
+	struct unqualified_pusher<std::pair<A, B>> {
+		template <typename T>
+		static int push(lua_State* L, T&& t) {
+			int pushcount = stack::push(L, std::get<0>(std::forward<T>(t)));
+			pushcount += stack::push(L, std::get<1>(std::forward<T>(t)));
+			return pushcount;
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<T, std::enable_if_t<meta::is_optional_v<T>>> {
+		using ValueType = typename meta::unqualified_t<T>::value_type;
+
+		template <typename Optional>
+		static int push(lua_State* L, Optional&& op) {
+			using QualifiedValueType = meta::conditional_t<std::is_lvalue_reference_v<Optional>, ValueType&, ValueType&&>;
+			if (!op) {
+				return stack::push(L, nullopt);
+			}
+			return stack::push(L, static_cast<QualifiedValueType>(op.value()));
+		}
+	};
+
+	template <typename T>
+	struct unqualified_pusher<forward_as_value_t<T>> {
+		static int push(lua_State* L, const forward_as_value_t<T>& value_) {
+			return stack::push<T>(L, value_.value());
+		}
+
+		static int push(lua_State* L, forward_as_value_t<T>&& value_) {
+			return stack::push<T>(L, std::move(value_).value());
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<nullopt_t> {
+		static int push(lua_State* L, nullopt_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<std::nullptr_t> {
+		static int push(lua_State* L, std::nullptr_t) noexcept {
+			return stack::push(L, lua_nil);
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_state> {
+		static int push(lua_State*, const this_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<this_main_state> {
+		static int push(lua_State*, const this_main_state&) noexcept {
+			return 0;
+		}
+	};
+
+	template <>
+	struct unqualified_pusher<new_table> {
+		static int push(lua_State* L, const new_table& nt) {
+			lua_createtable(L, nt.sequence_hint, nt.map_hint);
+			return 1;
+		}
+	};
+
+	template <typename Allocator>
+	struct unqualified_pusher<basic_bytecode<Allocator>> {
+		template <typename T>
+		static int push(lua_State* L, T&& bc, const char* bytecode_name) {
+			const auto first = bc.data();
+			const auto bcsize = bc.size();
+			// pushes either the function, or an error
+			// if it errors, shit goes south, and people can test that upstream
+			(void)luaL_loadbuffer(
+				L, reinterpret_cast<const char*>(first), static_cast<std::size_t>(bcsize * (sizeof(*first) / sizeof(const char))), bytecode_name);
+			return 1;
+		}
+
+		template <typename T>
+		static int push(lua_State* L, T&& bc) {
+			return push(L, std::forward<bc>(bc), "bytecode");
+		}
+	};
+
+#if SOL_IS_ON(SOL_STD_VARIANT)
+	namespace stack_detail {
+
+		struct push_function {
+			lua_State* L;
+
+			push_function(lua_State* L_) noexcept : L(L_) {
+			}
+
+			template <typename T>
+			int operator()(T&& value) const {
+				return stack::push<T>(L, std::forward<T>(value));
+			}
+		};
+
+	} // namespace stack_detail
+
+	template <typename... Tn>
+	struct unqualified_pusher<std::variant<Tn...>> {
+		static int push(lua_State* L, const std::variant<Tn...>& v) {
+			return std::visit(stack_detail::push_function(L), v);
+		}
+
+		static int push(lua_State* L, std::variant<Tn...>&& v) {
+			return std::visit(stack_detail::push_function(L), std::move(v));
+		}
+	};
+#endif // Variant because Clang is terrible
+
+}} // namespace sol::stack
+
+// end of sol/stack_push.hpp
+
+// beginning of sol/stack_pop.hpp
+
+#include <utility>
+#include <tuple>
+
+namespace sol { namespace stack {
+	template <typename T, typename>
+	struct popper {
+		inline static decltype(auto) pop(lua_State* L) {
+			if constexpr (is_stack_based_v<meta::unqualified_t<T>>) {
+				static_assert(!is_stack_based_v<meta::unqualified_t<T>>,
+					"You cannot pop something that lives solely on the stack: it will not remain on the stack when popped and thusly will go out of "
+					"scope!");
+			}
+			else {
+				record tracking {};
+				decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
+				lua_pop(L, tracking.used);
+				return r;
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_pop.hpp
+
+// beginning of sol/stack_field.hpp
+
+namespace sol { namespace stack {
+
+	namespace stack_detail {
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_get_direct_v = (is_get_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>)
+#endif // void pointer keys 5.2 or better
+			;
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_tableless_v = (global && !raw && meta::is_c_str_or_string_v<T>);
+
+		template <typename T, bool global, bool raw>
+		inline constexpr bool is_set_direct_v = (is_set_direct_tableless_v<T, global, raw>) // cf-hack
+			|| (!global && !raw && (meta::is_c_str_or_string_v<T> || meta::is_string_of_v<T, char>)) // cf-hack
+			|| (!global && raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))     // cf-hack
+#if SOL_LUA_VERSION_I_ >= 503
+			|| (!global && !raw && (std::is_integral_v<T> && !std::is_same_v<T, bool>))
+#endif // integer keys 5.3 or better
+#if SOL_LUA_VERSION_I_ >= 502
+			|| (!global && raw && (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>))
+#endif // void pointer keys 5.2 or better
+			;
+	} // namespace stack_detail
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_getter {
+		static inline constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_get_direct_v<T, global, raw>, std::integral_constant<int, -1>, std::integral_constant<int, -2>>::value;
+
+		template <typename Key>
+		void get(lua_State* L, Key&& key, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t> || std::is_same_v<T, create_if_nil_t>) {
+				(void)L;
+				(void)key;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, env_key_t>) {
+				(void)key;
+#if SOL_LUA_VERSION_I_ < 502
+				// Use lua_setfenv
+				lua_getfenv(L, tableindex);
+#else
+				// Use upvalues as explained in Lua 5.2 and beyond's manual
+				if (lua_getupvalue(L, tableindex, 1) == nullptr) {
+					push(L, lua_nil);
+				}
+#endif
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				if (lua_getmetatable(L, tableindex) == 0)
+					push(L, lua_nil);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					lua_rawgetp(L, tableindex, key);
+				}
+#endif // Lua 5.2.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_rawget(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						(void)tableindex;
+						lua_getglobal(L, &key[0]);
+					}
+					else {
+						lua_getfield(L, tableindex, &key[0]);
+					}
+				}
+				else if constexpr (std::is_same_v<T, meta_function>) {
+					const auto& real_key = to_string(key);
+					lua_getfield(L, tableindex, &real_key[0]);
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					lua_geti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x+
+				else {
+					push(L, std::forward<Key>(key));
+					lua_gettable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_getter<std::tuple<Args...>, b, raw, C> {
+		template <std::size_t... I, typename Keys>
+		void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			void(detail::swallow { (get_field<false, raw>(L, std::get<I>(std::forward<Keys>(keys))), 0)... });
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_getter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys, int tableindex) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+
+		template <typename Keys>
+		void get(lua_State* L, Keys&& keys) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)));
+			get_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)));
+			reference saved(L, -1);
+			lua_pop(L, static_cast<int>(2));
+			saved.push();
+		}
+	};
+
+	template <typename T, bool global, bool raw, typename>
+	struct field_setter {
+		static constexpr int default_table_index
+			= meta::conditional_t<stack_detail::is_set_direct_v<T, global, raw>, std::integral_constant<int, -2>, std::integral_constant<int, -3>>::value;
+
+		template <typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value, int tableindex = default_table_index) {
+			if constexpr (std::is_same_v<T, update_if_empty_t> || std::is_same_v<T, override_value_t>) {
+				(void)L;
+				(void)key;
+				(void)value;
+				(void)tableindex;
+			}
+			else if constexpr (std::is_same_v<T, metatable_key_t>) {
+				(void)key;
+				push(L, std::forward<Value>(value));
+				lua_setmetatable(L, tableindex);
+			}
+			else if constexpr (raw) {
+				if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#if SOL_LUA_VERSION_I_ >= 502
+				else if constexpr (std::is_pointer_v<T> && std::is_void_v<std::remove_pointer_t<T>>) {
+					push(L, std::forward<Value>(value));
+					lua_rawsetp(L, tableindex, std::forward<Key>(key));
+				}
+#endif // Lua 5.2.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_rawset(L, tableindex);
+				}
+			}
+			else {
+				if constexpr (meta::is_c_str_or_string_v<T>) {
+					if constexpr (global) {
+						push(L, std::forward<Value>(value));
+						lua_setglobal(L, &key[0]);
+						(void)tableindex;
+					}
+					else {
+						push(L, std::forward<Value>(value));
+						lua_setfield(L, tableindex, &key[0]);
+					}
+				}
+#if SOL_LUA_VERSION_I_ >= 503
+				else if constexpr (std::is_integral_v<T> && !std::is_same_v<bool, T>) {
+					push(L, std::forward<Value>(value));
+					lua_seti(L, tableindex, static_cast<lua_Integer>(key));
+				}
+#endif // Lua 5.3.x
+				else {
+					push(L, std::forward<Key>(key));
+					push(L, std::forward<Value>(value));
+					lua_settable(L, tableindex);
+				}
+			}
+		}
+	};
+
+	template <typename... Args, bool b, bool raw, typename C>
+	struct field_setter<std::tuple<Args...>, b, raw, C> {
+		template <bool g, std::size_t I, typename Keys, typename Value>
+		void apply(std::index_sequence<I>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I < 1 ? set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value), tableindex)
+				 : set_field<g, raw>(L, std::get<I>(std::forward<Keys>(keys)), std::forward<Value>(value));
+		}
+
+		template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
+		void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			I0 < 1 ? get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), tableindex)
+				  : get_field<g, raw>(L, std::get<I0>(std::forward<Keys>(keys)), -1);
+			apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
+		}
+
+		template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
+		void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
+			apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+			lua_pop(L, static_cast<int>(sizeof...(I)));
+		}
+
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
+			top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
+		}
+	};
+
+	template <typename A, typename B, bool b, bool raw, typename C>
+	struct field_setter<std::pair<A, B>, b, raw, C> {
+		template <typename Keys, typename Value>
+		void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
+			get_field<b, raw>(L, std::get<0>(std::forward<Keys>(keys)), tableindex);
+			set_field<false, raw>(L, std::get<1>(std::forward<Keys>(keys)), std::forward<Value>(value), lua_gettop(L));
+			lua_pop(L, 1);
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_field.hpp
+
+// beginning of sol/stack_probe.hpp
+
+namespace sol { namespace stack {
+	template <typename T, typename P, bool b, bool raw, typename>
+	struct probe_field_getter {
+		template <typename Key>
+		probe get(lua_State* L, Key&& key, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+			}
+			get_field<b, raw>(L, std::forward<Key>(key), tableindex);
+			return probe(check<P>(L), 1);
+		}
+	};
+
+	template <typename A, typename B, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::pair<A, B>, P, b, raw, C> {
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if (!b && !maybe_indexable(L, tableindex)) {
+				return probe(false, 0);
+			}
+			get_field<b, raw>(L, std::get<0>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, 1);
+			}
+			get_field<false, raw>(L, std::get<1>(keys), tableindex);
+			return probe(check<P>(L), 2);
+		}
+	};
+
+	template <typename... Args, typename P, bool b, bool raw, typename C>
+	struct probe_field_getter<std::tuple<Args...>, P, b, raw, C> {
+		template <std::size_t I, typename Keys>
+		probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field<(I < 1) && b, raw>(L, std::get<I>(keys), tableindex);
+			return probe(check<P>(L), sofar);
+		}
+
+		template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
+		probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
+			get_field < I<1 && b, raw>(L, std::get<I>(keys), tableindex);
+			if (!maybe_indexable(L)) {
+				return probe(false, sofar);
+			}
+			return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
+		}
+
+		template <typename Keys>
+		probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
+			if constexpr (!b) {
+				if (!maybe_indexable(L, tableindex)) {
+					return probe(false, 0);
+				}
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+			else {
+				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
+			}
+		}
+	};
+}} // namespace sol::stack
+
+// end of sol/stack_probe.hpp
+
+#include <cstring>
+#include <array>
+
+namespace sol {
+	namespace detail {
+		using typical_chunk_name_t = char[SOL_ID_SIZE_I_];
+		using typical_file_chunk_name_t = char[SOL_FILE_ID_SIZE_I_];
+
+		inline const std::string& default_chunk_name() {
+			static const std::string name = "";
+			return name;
+		}
+
+		template <std::size_t N>
+		const char* make_chunk_name(const string_view& code, const std::string& chunkname, char (&basechunkname)[N]) {
+			if (chunkname.empty()) {
+				auto it = code.cbegin();
+				auto e = code.cend();
+				std::size_t i = 0;
+				static const std::size_t n = N - 4;
+				for (i = 0; i < n && it != e; ++i, ++it) {
+					basechunkname[i] = *it;
+				}
+				if (it != e) {
+					for (std::size_t c = 0; c < 3; ++i, ++c) {
+						basechunkname[i] = '.';
+					}
+				}
+				basechunkname[i] = '\0';
+				return &basechunkname[0];
+			}
+			else {
+				return chunkname.c_str();
+			}
+		}
+
+		inline void clear_entries(stack_reference r) {
+			stack::push(r.lua_state(), lua_nil);
+			while (lua_next(r.lua_state(), -2)) {
+				absolute_index key(r.lua_state(), -2);
+				auto pn = stack::pop_n(r.lua_state(), 1);
+				stack::set_field<false, true>(r.lua_state(), key, lua_nil, r.stack_index());
+			}
+		}
+
+		inline void clear_entries(const reference& registry_reference) {
+			auto pp = stack::push_pop(registry_reference);
+			stack_reference ref(registry_reference.lua_state(), -1);
+			clear_entries(ref);
+		}
+	} // namespace detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T>
+			inline int push_as_upvalues(lua_State* L, T& item) {
+				typedef std::decay_t<T> TValue;
+				static const std::size_t itemsize = sizeof(TValue);
+				static const std::size_t voidsize = sizeof(void*);
+				static const std::size_t voidsizem1 = voidsize - 1;
+				static const std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
+				typedef std::array<void*, data_t_count> data_t;
+
+				data_t data { {} };
+				std::memcpy(&data[0], std::addressof(item), itemsize);
+				int pushcount = 0;
+				for (const auto& v : data) {
+					lua_pushlightuserdata(L, v);
+					pushcount += 1;
+				}
+				return pushcount;
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				data_t voiddata { {} };
+				for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
+					voiddata[i] = lua_touserdata(L, upvalue_index(index++));
+				}
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <typename T>
+			inline std::pair<T, int> get_as_upvalues_using_function(lua_State* L, int function_index = -1) {
+				static const std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
+				typedef std::array<void*, data_t_count> data_t;
+				function_index = lua_absindex(L, function_index);
+				int index = 0;
+				data_t voiddata { {} };
+				for (std::size_t d = 0; d < sizeof(T); d += sizeof(void*)) {
+					// first upvalue is nullptr to respect environment shenanigans
+					// So +2 instead of +1
+					const char* upvalue_name = lua_getupvalue(L, function_index, index + 2);
+					if (upvalue_name == nullptr) {
+						// We should freak out here...
+						break;
+					}
+					voiddata[index] = lua_touserdata(L, -1);
+					++index;
+				}
+				lua_pop(L, index);
+				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
+			}
+
+			template <bool checked, typename Handler, typename Fx, typename... Args>
+			static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, Handler&&, record&, Fx&& fx, Args&&... args) {
+				return std::forward<Fx>(fx)(std::forward<Args>(args)...);
+			}
+
+			template <bool checked, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename Handler, typename Fx, typename... FxArgs>
+			static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L_, int start_index_, Handler&& handler_,
+			     record& tracking_, Fx&& fx_, FxArgs&&... fxargs_) {
+#if SOL_IS_ON(SOL_PROPAGATE_EXCEPTIONS)
+				// We can save performance/time by letting errors unwind produced arguments
+				// rather than checking everything once, and then potentially re-doing work
+				if constexpr (checked) {
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     *stack_detail::check_get_arg<Arg>(L_, start_index_ + tracking_.used, handler_, tracking_));
+				}
+				else
+#endif
+				{
+					return eval<checked>(types<Args...>(),
+					     std::index_sequence<Is...>(),
+					     L_,
+					     start_index_,
+					     std::forward<Handler>(handler_),
+					     tracking_,
+					     std::forward<Fx>(fx_),
+					     std::forward<FxArgs>(fxargs_)...,
+					     stack_detail::unchecked_get_arg<Arg>(L_, start_index_ + tracking_.used, tracking_));
+				}
+			}
+
+			template <bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs>
+			inline decltype(auto) call(types<R>, types<Args...> argument_types_, std::index_sequence<I...> argument_indices_, lua_State* L_,
+			     int start_index_, Fx&& fx_, FxArgs&&... args_) {
+				static_assert(meta::all_v<meta::is_not_move_only<Args>...>,
+				     "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take "
+				     "a reference and std::move it manually if this was your intention.");
+				argument_handler<types<R, Args...>> handler {};
+				record tracking {};
+#if SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+				if constexpr (checkargs) {
+					multi_check<Args...>(L_, start_index_, handler);
+				}
+#endif
+				if constexpr (std::is_void_v<R>) {
+					eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+				else {
+					return eval<checkargs>(
+					     argument_types_, argument_indices_, L_, start_index_, handler, tracking, std::forward<Fx>(fx_), std::forward<FxArgs>(args_)...);
+				}
+			}
+
+			template <typename T>
+			void raw_table_set(lua_State* L, T&& arg, int tableindex = -2) {
+				int push_count = push(L, std::forward<T>(arg));
+				sol_c_assert(push_count == 1);
+				std::size_t unique_index = static_cast<std::size_t>(luaL_len(L, tableindex) + 1u);
+				lua_rawseti(L, tableindex, unique_index);
+			}
+
+		} // namespace stack_detail
+
+		template <typename T>
+		int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
+			int push_count = push(L, std::forward<T>(arg));
+			sol_c_assert(push_count == 1);
+			return luaL_ref(L, tableindex);
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
+			using args_indices = std::make_index_sequence<sizeof...(Args)>;
+			if constexpr (std::is_void_v<R>) {
+				stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, typename R, typename... Args, typename Fx, typename... FxArgs>
+		inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
+			using expected_count_t = meta::count_for_pack<lua_size, Args...>;
+			if constexpr (std::is_void_v<R>) {
+				call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+			else {
+				return call<check_args>(tr,
+				     ta,
+				     L,
+				     (std::max)(static_cast<int>(lua_gettop(L) - expected_count_t::value), static_cast<int>(0)),
+				     std::forward<Fx>(fx),
+				     std::forward<FxArgs>(args)...);
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0, typename... Ret, typename... Args,
+		     typename Fx, typename... FxArgs>
+		inline int call_into_lua(types<Ret0, Ret...> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			if constexpr (std::is_void_v<Ret0>) {
+				call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				if constexpr (clean_stack) {
+					lua_settop(L, 0);
+				}
+				return 0;
+			}
+			else {
+				(void)tr;
+				decltype(auto) r
+				     = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+				using R = meta::unqualified_t<decltype(r)>;
+				using is_stack = meta::any<is_stack_based<R>, std::is_same<R, absolute_index>, std::is_same<R, ref_index>, std::is_same<R, raw_index>>;
+				if constexpr (clean_stack && !is_stack::value) {
+					lua_settop(L, 0);
+				}
+				return push_reference(L, std::forward<decltype(r)>(r));
+			}
+		}
+
+		template <bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx, typename... FxArgs>
+		inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
+			using traits_type = lua_bind_traits<meta::unqualified_t<Fx>>;
+			using args_list = typename traits_type::args_list;
+			using returns_list = typename traits_type::returns_list;
+			return call_into_lua<check_args, clean_stack>(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
+		}
+
+		inline call_syntax get_call_syntax(lua_State* L, const string_view& key, int index) {
+			if (lua_gettop(L) < 1) {
+				return call_syntax::dot;
+			}
+			luaL_getmetatable(L, key.data());
+			auto pn = pop_n(L, 1);
+			if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
+				return call_syntax::dot;
+			}
+			return call_syntax::colon;
+		}
+
+		inline void script(
+		     lua_State* L, lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script(
+		     lua_State* L, const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void script_file(lua_State* L, const std::string& filename, load_mode mode = load_mode::any) {
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()) || lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+		}
+
+		inline void luajit_exception_handler(lua_State* L, int (*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushlightuserdata(L, (void*)handler);
+			auto pn = pop_n(L, 1);
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
+#else
+			(void)L;
+			(void)handler;
+#endif
+		}
+
+		inline void luajit_exception_off(lua_State* L) {
+#if SOL_IS_ON(SOL_USE_LUAJIT_EXCEPTION_TRAMPOLINE)
+			if (L == nullptr) {
+				return;
+			}
+			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
+#else
+			(void)L;
+#endif
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack.hpp
+
+// beginning of sol/object.hpp
+
+// beginning of sol/make_reference.hpp
+
+namespace sol {
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference(lua_State* L, T&& value) {
+		int backpedal = stack::push(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference(lua_State* L, Args&&... args) {
+		int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename R = reference, bool should_pop = !is_stack_based_v<R>, typename T>
+	R make_reference_userdata(lua_State* L, T&& value) {
+		int backpedal = stack::push_userdata(L, std::forward<T>(value));
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+	template <typename T, typename R = reference, bool should_pop = !is_stack_based_v<R>, typename... Args>
+	R make_reference_userdata(lua_State* L, Args&&... args) {
+		int backpedal = stack::push_userdata<T>(L, std::forward<Args>(args)...);
+		R r = stack::get<R>(L, -backpedal);
+		if (should_pop) {
+			lua_pop(L, backpedal);
+		}
+		return r;
+	}
+
+} // namespace sol
+
+// end of sol/make_reference.hpp
+
+// beginning of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	class basic_object_base : public ref_t {
+	private:
+		using base_t = ref_t;
+
+		template <typename T>
+		decltype(auto) as_stack(std::true_type) const {
+			return stack::get<T>(base_t::lua_state(), base_t::stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as_stack(std::false_type) const {
+			base_t::push();
+			return stack::pop<T>(base_t::lua_state());
+		}
+
+		template <typename T>
+		bool is_stack(std::true_type) const {
+			return stack::check<T>(base_t::lua_state(), base_t::stack_index(), &no_panic);
+		}
+
+		template <typename T>
+		bool is_stack(std::false_type) const {
+			int r = base_t::registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(*this);
+			return stack::check<T>(base_t::lua_state(), -1, &no_panic);
+		}
+
+	public:
+		basic_object_base() noexcept = default;
+		basic_object_base(const basic_object_base&) = default;
+		basic_object_base(basic_object_base&&) = default;
+		basic_object_base& operator=(const basic_object_base&) = default;
+		basic_object_base& operator=(basic_object_base&&) = default;
+		template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
+		basic_object_base(T&& arg, Args&&... args) : base_t(std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return as_stack<T>(is_stack_based<base_t>());
+		}
+
+		template <typename T>
+		bool is() const {
+			return is_stack<T>(is_stack_based<base_t>());
+		}
+	};
+} // namespace sol
+
+// end of sol/object_base.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_object : public basic_object_base<base_type> {
+	private:
+		typedef basic_object_base<base_type> base_t;
+
+		template <bool invert_and_pop = false>
+		basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+			if (invert_and_pop) {
+				lua_pop(L_, -index_);
+			}
+		}
+
+	protected:
+		basic_object(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, int index_) : base_t(L_, index_) {
+		}
+		basic_object(detail::no_safety_tag, lua_State* L_, ref_index index_) : base_t(L_, index_) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(detail::no_safety_tag, lua_State* L_, T&& r) noexcept : base_t(L_, std::forward<T>(r)) {
+		}
+
+	public:
+		basic_object() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(T&& r) : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_object(lua_State* L_, T&& r) : base_t(L_, std::forward<T>(r)) {
+		}
+		basic_object(lua_State* L_, global_tag_t t) : base_t(L_, t) {
+		}
+		basic_object(lua_nil_t r) : base_t(r) {
+		}
+		basic_object(const basic_object&) = default;
+		basic_object(basic_object&&) = default;
+		basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {
+		}
+		template <typename Super>
+		basic_object(const proxy_base<Super>& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		template <typename Super>
+		basic_object(proxy_base<Super>&& r) noexcept : basic_object(r.operator basic_object()) {
+		}
+		basic_object(lua_State* L_, lua_nil_t r) noexcept : base_t(L_, r) {
+		}
+		basic_object(lua_State* L_, int index_ = -1) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, absolute_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, raw_index index_) noexcept : base_t(L_, index_) {
+		}
+		basic_object(lua_State* L_, ref_index index_) noexcept : base_t(L_, index_) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_type_t<T>, Args&&... args) noexcept
+		: basic_object(std::integral_constant<bool, !is_stack_based<base_t>::value>(), L_, -stack::push<T>(L_, std::forward<Args>(args)...)) {
+		}
+		template <typename T, typename... Args>
+		basic_object(lua_State* L_, in_place_t, T&& arg, Args&&... args) noexcept
+		: basic_object(L_, in_place_type<T>, std::forward<T>(arg), std::forward<Args>(args)...) {
+		}
+		basic_object& operator=(const basic_object&) = default;
+		basic_object& operator=(basic_object&&) = default;
+		basic_object& operator=(const base_type& b) {
+			base_t::operator=(b);
+			return *this;
+		}
+		basic_object& operator=(base_type&& b) {
+			base_t::operator=(std::move(b));
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(const proxy_base<Super>& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+		template <typename Super>
+		basic_object& operator=(proxy_base<Super>&& r) {
+			this->operator=(r.operator basic_object());
+			return *this;
+		}
+	};
+
+	template <typename T>
+	object make_object(lua_State* L_, T&& value) {
+		return make_reference<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object(lua_State* L_, Args&&... args) {
+		return make_reference<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+
+	template <typename T>
+	object make_object_userdata(lua_State* L_, T&& value) {
+		return make_reference_userdata<object, true>(L_, std::forward<T>(value));
+	}
+
+	template <typename T, typename... Args>
+	object make_object_userdata(lua_State* L_, Args&&... args) {
+		return make_reference_userdata<T, object, true>(L_, std::forward<Args>(args)...);
+	}
+} // namespace sol
+
+// end of sol/object.hpp
+
+// beginning of sol/function.hpp
+
+// beginning of sol/unsafe_function.hpp
+
+// beginning of sol/function_result.hpp
+
+// beginning of sol/protected_function_result.hpp
+
+// beginning of sol/proxy_base.hpp
+
+namespace sol {
+	struct proxy_base_tag { };
+
+	namespace detail {
+		template <typename T>
+		using proxy_key_t = meta::conditional_t<meta::is_specialization_of_v<meta::unqualified_t<T>, std::tuple>, T,
+		     std::tuple<meta::conditional_t<std::is_array_v<meta::unqualified_t<T>>, std::remove_reference_t<T>&, meta::unqualified_t<T>>>>;
+	}
+
+	template <typename Super>
+	struct proxy_base : public proxy_base_tag {
+		lua_State* lua_state() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.lua_state();
+		}
+
+		operator std::string() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<std::string>();
+		}
+
+		template <typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
+		operator T() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T>();
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
+		operator T&() const {
+			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
+			return super.template get<T&>();
+		}
+	};
+
+} // namespace sol
+
+// end of sol/proxy_base.hpp
+
+// beginning of sol/stack_iterator.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	template <typename proxy_t, bool is_const>
+	struct stack_iterator {
+		typedef meta::conditional_t<is_const, const proxy_t, proxy_t> reference;
+		typedef meta::conditional_t<is_const, const proxy_t*, proxy_t*> pointer;
+		typedef proxy_t value_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::random_access_iterator_tag iterator_category;
+		lua_State* L;
+		int index;
+		int stacktop;
+		proxy_t sp;
+
+		stack_iterator() : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()), sp() {
+		}
+		stack_iterator(const stack_iterator<proxy_t, true>& r) : L(r.L), index(r.index), stacktop(r.stacktop), sp(r.sp) {
+		}
+		stack_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {
+		}
+
+		reference operator*() {
+			return proxy_t(L, index);
+		}
+
+		reference operator*() const {
+			return proxy_t(L, index);
+		}
+
+		pointer operator->() {
+			sp = proxy_t(L, index);
+			return &sp;
+		}
+
+		pointer operator->() const {
+			const_cast<proxy_t&>(sp) = proxy_t(L, index);
+			return &sp;
+		}
+
+		stack_iterator& operator++() {
+			++index;
+			return *this;
+		}
+
+		stack_iterator operator++(int) {
+			auto r = *this;
+			this->operator++();
+			return r;
+		}
+
+		stack_iterator& operator--() {
+			--index;
+			return *this;
+		}
+
+		stack_iterator operator--(int) {
+			auto r = *this;
+			this->operator--();
+			return r;
+		}
+
+		stack_iterator& operator+=(difference_type idx) {
+			index += static_cast<int>(idx);
+			return *this;
+		}
+
+		stack_iterator& operator-=(difference_type idx) {
+			index -= static_cast<int>(idx);
+			return *this;
+		}
+
+		difference_type operator-(const stack_iterator& r) const {
+			return index - r.index;
+		}
+
+		stack_iterator operator+(difference_type idx) const {
+			stack_iterator r = *this;
+			r += idx;
+			return r;
+		}
+
+		reference operator[](difference_type idx) const {
+			return proxy_t(L, index + static_cast<int>(idx));
+		}
+
+		bool operator==(const stack_iterator& r) const {
+			if (stacktop == (std::numeric_limits<int>::max)()) {
+				return r.index == r.stacktop;
+			}
+			else if (r.stacktop == (std::numeric_limits<int>::max)()) {
+				return index == stacktop;
+			}
+			return index == r.index;
+		}
+
+		bool operator!=(const stack_iterator& r) const {
+			return !(this->operator==(r));
+		}
+
+		bool operator<(const stack_iterator& r) const {
+			return index < r.index;
+		}
+
+		bool operator>(const stack_iterator& r) const {
+			return index > r.index;
+		}
+
+		bool operator<=(const stack_iterator& r) const {
+			return index <= r.index;
+		}
+
+		bool operator>=(const stack_iterator& r) const {
+			return index >= r.index;
+		}
+	};
+
+	template <typename proxy_t, bool is_const>
+	inline stack_iterator<proxy_t, is_const> operator+(
+	     typename stack_iterator<proxy_t, is_const>::difference_type n, const stack_iterator<proxy_t, is_const>& r) {
+		return r + n;
+	}
+} // namespace sol
+
+// end of sol/stack_iterator.hpp
+
+// beginning of sol/stack_proxy.hpp
+
+// beginning of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy_base : public proxy_base<stack_proxy_base> {
+	private:
+		lua_State* m_L;
+		int m_index;
+
+	public:
+		stack_proxy_base() : m_L(nullptr), m_index(0) {
+		}
+		stack_proxy_base(lua_State* L_, int index_) : m_L(L_), m_index(index_) {
+		}
+
+		template <typename T>
+		decltype(auto) get() const {
+			return stack::get<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		bool is() const {
+			return stack::check<T>(m_L, stack_index());
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			return get<T>();
+		}
+
+		type get_type() const noexcept {
+			return type_of(lua_state(), stack_index());
+		}
+
+		int push() const {
+			return push(m_L);
+		}
+
+		int push(lua_State* L_) const {
+			lua_pushvalue(L_, m_index);
+			return 1;
+		}
+
+		lua_State* lua_state() const {
+			return m_L;
+		}
+		int stack_index() const {
+			return m_index;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy_base> {
+			static stack_proxy_base get(lua_State* L_, int index_ = -1) {
+				return stack_proxy_base(L_, index_);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy_base> {
+			static int push(lua_State*, const stack_proxy_base& proxy_reference) {
+				return proxy_reference.push();
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/stack_proxy_base.hpp
+
+namespace sol {
+	struct stack_proxy : public stack_proxy_base {
+	public:
+		stack_proxy() : stack_proxy_base() {
+		}
+		stack_proxy(lua_State* L, int index) : stack_proxy_base(L, index) {
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args);
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<stack_proxy> {
+			static stack_proxy get(lua_State* L, int index, record& tracking) {
+				tracking.use(0);
+				return stack_proxy(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<stack_proxy> {
+			static int push(lua_State*, const stack_proxy& ref) {
+				return ref.push();
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/stack_proxy.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct protected_function_result : public proxy_base<protected_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		call_status err;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		protected_function_result() noexcept : protected_function_result(nullptr) {}
+		protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept
+		: L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		protected_function_result(const protected_function_result&) = delete;
+		protected_function_result& operator=(const protected_function_result&) = delete;
+
+		protected_function_result(protected_function_result&& o) noexcept
+		: L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+		}
+		protected_function_result& operator=(protected_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		protected_function_result(const unsafe_function_result& o) = delete;
+		protected_function_result& operator=(const unsafe_function_result& o) = delete;
+		protected_function_result(unsafe_function_result&& o) noexcept;
+		protected_function_result& operator=(unsafe_function_result&& o) noexcept;
+
+		call_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
+
+		template <typename T>
+		decltype(auto) get(int index_offset = 0) const {
+			using UT = meta::unqualified_t<T>;
+			int target = index + index_offset;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT();
+					}
+					return UT(error(detail::direct_error, stack::get<std::string>(L, target)));
+				}
+				else {
+					if (!valid()) {
+						return UT();
+					}
+					return stack::get<UT>(L, target);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is an error)");
+					}
+#endif // Check Argument Safety
+					return error(detail::direct_error, stack::get<std::string>(L, target));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type t = type_of(L, target);
+						type_panic_c_str(L, target, t, type::none, "bad get from protected_function_result (is not an error)");
+					}
+#endif // Check Argument Safety
+					return stack::get<T>(L, target);
+				}
+			}
+		}
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#endif
+
+		type get_type(int index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+		int return_count() const noexcept {
+			return returncount;
+		};
+		int pop_count() const noexcept {
+			return popcount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+			popcount = 0;
+			err = call_status::runtime;
+		}
+		~protected_function_result() {
+			if (L == nullptr)
+				return;
+			stack::remove(L, index, popcount);
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<protected_function_result> {
+			static int push(lua_State* L, const protected_function_result& pfr) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+				luaL_checkstack(L, static_cast<int>(pfr.pop_count()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+				int p = 0;
+				for (int i = 0; i < pfr.pop_count(); ++i) {
+					lua_pushvalue(L, i + pfr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/protected_function_result.hpp
+
+// beginning of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct unsafe_function_result : public proxy_base<unsafe_function_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		unsafe_function_result() noexcept : unsafe_function_result(nullptr) {}
+		unsafe_function_result(lua_State* Ls, int idx = -1, int retnum = 0) noexcept : L(Ls), index(idx), returncount(retnum) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		unsafe_function_result(const unsafe_function_result&) = delete;
+		unsafe_function_result& operator=(const unsafe_function_result&) = delete;
+
+		unsafe_function_result(unsafe_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+		}
+		unsafe_function_result& operator=(unsafe_function_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.abandon();
+			return *this;
+		}
+
+		unsafe_function_result(const protected_function_result& o) = delete;
+		unsafe_function_result& operator=(const protected_function_result& o) = delete;
+		unsafe_function_result(protected_function_result&& o) noexcept;
+		unsafe_function_result& operator=(protected_function_result&& o) noexcept;
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		iterator begin() {
+			return iterator(L, index, stack_index() + return_count());
+		}
+		iterator end() {
+			return iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stack_index() + return_count());
+		}
+		const_iterator end() const {
+			return const_iterator(L, stack_index() + return_count(), stack_index() + return_count());
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		call_status status() const noexcept {
+			return call_status::ok;
+		}
+
+		bool valid() const noexcept {
+			return status() == call_status::ok || status() == call_status::yielded;
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int return_count() const {
+			return returncount;
+		};
+		void abandon() noexcept {
+			// L = nullptr;
+			index = 0;
+			returncount = 0;
+		}
+		~unsafe_function_result() {
+			if (L != nullptr) {
+				lua_pop(L, returncount);
+			}
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<unsafe_function_result> {
+			static int push(lua_State* L, const unsafe_function_result& fr) {
+				int p = 0;
+				for (int i = 0; i < fr.return_count(); ++i) {
+					lua_pushvalue(L, i + fr.stack_index());
+					++p;
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/unsafe_function_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+
+	namespace detail {
+		template <>
+		struct is_speshul<unsafe_function_result> : std::true_type { };
+		template <>
+		struct is_speshul<protected_function_result> : std::true_type { };
+
+		template <std::size_t I, typename... Args, typename T>
+		stack_proxy get(types<Args...>, meta::index_value<0>, meta::index_value<I>, const T& fr) {
+			return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+		}
+
+		template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
+		stack_proxy get(types<Arg, Args...>, meta::index_value<N>, meta::index_value<I>, const T& fr) {
+			return get(types<Args...>(), meta::index_value<N - 1>(), meta::index_value<I + lua_size<Arg>::value>(), fr);
+		}
+	} // namespace detail
+
+	template <>
+	struct tie_size<unsafe_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <>
+	struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> { };
+
+	template <std::size_t I>
+	stack_proxy get(const unsafe_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const unsafe_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+
+	template <std::size_t I>
+	stack_proxy get(const protected_function_result& fr) {
+		return stack_proxy(fr.lua_state(), fr.stack_index() + static_cast<int>(I));
+	}
+
+	template <std::size_t I, typename... Args>
+	stack_proxy get(types<Args...> t, const protected_function_result& fr) {
+		return detail::get(t, meta::index_value<I>(), meta::index_value<0>(), fr);
+	}
+} // namespace sol
+
+// end of sol/function_result.hpp
+
+// beginning of sol/function_types.hpp
+
+// beginning of sol/function_types_core.hpp
+
+// beginning of sol/wrapper.hpp
+
+namespace sol {
+
+	namespace detail {
+		template <typename T>
+		using array_return_type = meta::conditional_t<std::is_array<T>::value, std::add_lvalue_reference_t<T>, T>;
+	}
+
+	template <typename F, typename = void>
+	struct wrapper {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <typename... Args>
+		static decltype(auto) call(F& f, Args&&... args) {
+			return f(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_function<std::remove_pointer_t<meta::unqualified_t<F>>>::value>> {
+		typedef lua_bind_traits<std::remove_pointer_t<meta::unqualified_t<F>>> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef typename traits_type::args_list free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx, typename... Args>
+		static decltype(auto) invoke(Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static decltype(auto) call(F& fx, Args&&... args) {
+			return fx(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename... Args>
+			decltype(auto) operator()(F& fx, Args&&... args) const {
+				return call(fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F>
+	struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
+		typedef lua_bind_traits<meta::unqualified_t<F>> traits_type;
+		typedef typename traits_type::object_type object_type;
+		typedef typename traits_type::return_type return_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, return_type> free_args_list;
+		typedef typename traits_type::returns_list returns_list;
+
+		template <F fx>
+		static auto call(object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <F fx, typename Arg, typename... Args>
+		static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
+			return mem.*fx = std::forward<Arg>(arg);
+		}
+
+		template <typename Fx>
+		static auto call(Fx&& fx, object_type& mem) -> detail::array_return_type<decltype(mem.*fx)> {
+			return mem.*fx;
+		}
+
+		template <typename Fx, typename Arg, typename... Args>
+		static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
+			using actual_type = meta::unqualified_t<detail::array_return_type<decltype(mem.*fx)>>;
+			if constexpr (std::is_array_v<actual_type>) {
+				using std::cbegin;
+				using std::cend;
+				auto first = cbegin(arg);
+				auto last = cend(arg);
+				for (std::size_t i = 0; first != last; ++i, ++first) {
+					(mem.*fx)[i] = *first;
+				}
+			}
+			else {
+				(mem.*fx) = std::forward<Arg>(arg);
+			}
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(Args&&... args) const {
+				return invoke<fx>(std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename F, typename R, typename O, typename... FArgs>
+	struct member_function_wrapper {
+		typedef O object_type;
+		typedef lua_bind_traits<F> traits_type;
+		typedef typename traits_type::args_list args_list;
+		typedef types<object_type&, FArgs...> free_args_list;
+		typedef meta::tuple_types<R> returns_list;
+
+		template <F fx, typename... Args>
+		static R invoke(O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		template <typename Fx, typename... Args>
+		static R call(Fx&& fx, O& mem, Args&&... args) {
+			return (mem.*fx)(std::forward<Args>(args)...);
+		}
+
+		struct caller {
+			template <typename Fx, typename... Args>
+			decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
+				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
+			}
+		};
+
+		template <F fx>
+		struct invoker {
+			template <typename... Args>
+			decltype(auto) operator()(O& mem, Args&&... args) const {
+				return invoke<fx>(mem, std::forward<Args>(args)...);
+			}
+		};
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)> : public member_function_wrapper<R (O::*)(Args...), R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const> : public member_function_wrapper<R (O::*)(Args...) const, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile> : public member_function_wrapper<R (O::*)(Args...) const volatile, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) &&> : public member_function_wrapper<R (O::*)(Args...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&&> : public member_function_wrapper<R (O::*)(Args...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&&> : public member_function_wrapper<R (O::*)(Args...) const volatile&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) &&> : public member_function_wrapper<R (O::*)(Args..., ...)&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&&> : public member_function_wrapper<R (O::*)(Args..., ...) const&, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&&> : public member_function_wrapper<R (O::*)(Args..., ...) const volatile&, R, O, Args...> { };
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+	// noexcept has become a part of a function's type
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) noexcept> : public member_function_wrapper<R (O::*)(Args...) noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const noexcept> : public member_function_wrapper<R (O::*)(Args...) const noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...)&& noexcept> : public member_function_wrapper<R (O::*)(Args...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args...) const volatile&& noexcept> : public member_function_wrapper<R (O::*)(Args...) const volatile& noexcept, R, O, Args...> {
+	};
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...)&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...)& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const&& noexcept> : public member_function_wrapper<R (O::*)(Args..., ...) const& noexcept, R, O, Args...> { };
+
+	template <typename R, typename O, typename... Args>
+	struct wrapper<R (O::*)(Args..., ...) const volatile&& noexcept>
+	: public member_function_wrapper<R (O::*)(Args..., ...) const volatile& noexcept, R, O, Args...> { };
+
+#endif // noexcept is part of a function's type
+
+} // namespace sol
+
+// end of sol/wrapper.hpp
+
+#include <memory>
+
+namespace sol { namespace function_detail {
+	template <typename Fx, int start = 1, bool is_yielding = false>
+	int call(lua_State* L) {
+		Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
+		int nr = fx(L);
+		if (is_yielding) {
+			return lua_yield(L, nr);
+		}
+		else {
+			return nr;
+		}
+	}
+}} // namespace sol::function_detail
+
+// end of sol/function_types_core.hpp
+
+// beginning of sol/function_types_templated.hpp
+
+// beginning of sol/call.hpp
+
+// beginning of sol/property.hpp
+
+#include <type_traits>
+#include <utility>
+
+namespace sol {
+	namespace detail {
+		struct no_prop { };
+	} // namespace detail
+
+	template <typename R, typename W>
+	struct property_wrapper : detail::ebco<R, 0>, detail::ebco<W, 1> {
+	private:
+		using read_base_t = detail::ebco<R, 0>;
+		using write_base_t = detail::ebco<W, 1>;
+
+	public:
+		template <typename Rx, typename Wx>
+		property_wrapper(Rx&& r, Wx&& w) : read_base_t(std::forward<Rx>(r)), write_base_t(std::forward<Wx>(w)) {
+		}
+
+		W& write() {
+			return write_base_t::value();
+		}
+
+		const W& write() const {
+			return write_base_t::value();
+		}
+
+		R& read() {
+			return read_base_t::value();
+		}
+
+		const R& read() const {
+			return read_base_t::value();
+		}
+	};
+
+	template <typename F, typename G>
+	inline decltype(auto) property(F&& f, G&& g) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
+		if constexpr (left_traits::free_arity < right_traits::free_arity) {
+			return property_wrapper<std::decay_t<F>, std::decay_t<G>>(std::forward<F>(f), std::forward<G>(g));
+		}
+		else {
+			return property_wrapper<std::decay_t<G>, std::decay_t<F>>(std::forward<G>(g), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) property(F&& f) {
+		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
+		if constexpr (left_traits::free_arity < 2) {
+			return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+		}
+		else {
+			return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+		}
+	}
+
+	template <typename F>
+	inline decltype(auto) readonly_property(F&& f) {
+		return property_wrapper<std::decay_t<F>, detail::no_prop>(std::forward<F>(f), detail::no_prop());
+	}
+
+	template <typename F>
+	inline decltype(auto) writeonly_property(F&& f) {
+		return property_wrapper<detail::no_prop, std::decay_t<F>>(detail::no_prop(), std::forward<F>(f));
+	}
+
+	template <typename T>
+	struct readonly_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+
+		operator T&() {
+			return base_t::value();
+		}
+		operator const T&() const {
+			return base_t::value();
+		}
+	};
+
+	// Allow someone to make a member variable readonly (const)
+	template <typename R, typename T>
+	inline auto readonly(R T::*v) {
+		return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
+	}
+
+	template <typename T>
+	struct var_wrapper : detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename V>
+	inline auto var(V&& v) {
+		typedef std::decay_t<V> T;
+		return var_wrapper<T>(std::forward<V>(v));
+	}
+
+	namespace meta {
+		template <typename T>
+		using is_member_object = std::integral_constant<bool, std::is_member_object_pointer_v<T> || is_specialization_of_v<T, readonly_wrapper>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_v = is_member_object<T>::value;
+
+		template <typename T>
+		using is_member_object_or_function = std::integral_constant<bool, is_member_object_v<T> || std::is_member_pointer_v<T>>;
+
+		template <typename T>
+		inline constexpr bool is_member_object_or_function_v = is_member_object_or_function<T>::value;
+	} // namespace meta
+
+} // namespace sol
+
+// end of sol/property.hpp
+
+// beginning of sol/protect.hpp
+
+#include <utility>
+
+namespace sol {
+
+	template <typename T>
+	struct protect_t {
+		T value;
+
+		template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
+		protect_t(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {
+		}
+
+		protect_t(const protect_t&) = default;
+		protect_t(protect_t&&) = default;
+		protect_t& operator=(const protect_t&) = default;
+		protect_t& operator=(protect_t&&) = default;
+	};
+
+	template <typename T>
+	auto protect(T&& value) {
+		return protect_t<std::decay_t<T>>(std::forward<T>(value));
+	}
+
+} // namespace sol
+
+// end of sol/protect.hpp
+
+namespace sol {
+	namespace u_detail {
+
+	} // namespace u_detail
+
+	namespace policy_detail {
+		template <int I, int... In>
+		inline void handle_policy(static_stack_dependencies<I, In...>, lua_State* L, int&) {
+			if constexpr (sizeof...(In) == 0) {
+				(void)L;
+				return;
+			}
+			else {
+				absolute_index ai(L, I);
+				if (type_of(L, ai) != type::userdata) {
+					return;
+				}
+				lua_createtable(L, static_cast<int>(sizeof...(In)), 0);
+				stack_reference deps(L, -1);
+				auto per_dep = [&L, &deps](int i) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+					luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+					lua_pushvalue(L, i);
+					luaL_ref(L, deps.stack_index());
+				};
+				(void)per_dep;
+				(void)detail::swallow { int(), (per_dep(In), int())... };
+				lua_setuservalue(L, ai);
+			}
+		}
+
+		template <int... In>
+		inline void handle_policy(returns_self_with<In...>, lua_State* L, int& pushed) {
+			pushed = stack::push(L, raw_index(1));
+			handle_policy(static_stack_dependencies<-1, In...>(), L, pushed);
+		}
+
+		inline void handle_policy(const stack_dependencies& sdeps, lua_State* L, int&) {
+			absolute_index ai(L, sdeps.target);
+			if (type_of(L, ai) != type::userdata) {
+				return;
+			}
+			lua_createtable(L, static_cast<int>(sdeps.size()), 0);
+			stack_reference deps(L, -1);
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, static_cast<int>(sdeps.size()), detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			for (std::size_t i = 0; i < sdeps.size(); ++i) {
+				lua_pushvalue(L, sdeps.stack_indices[i]);
+				luaL_ref(L, deps.stack_index());
+			}
+			lua_setuservalue(L, ai);
+		}
+
+		template <typename P, meta::disable<std::is_base_of<detail::policy_base_tag, meta::unqualified_t<P>>> = meta::enabler>
+		inline void handle_policy(P&& p, lua_State* L, int& pushed) {
+			pushed = std::forward<P>(p)(L, pushed);
+		}
+	} // namespace policy_detail
+
+	namespace function_detail {
+		inline int no_construction_error(lua_State* L) {
+			return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
+		}
+	} // namespace function_detail
+
+	namespace call_detail {
+
+		template <typename R, typename W>
+		inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
+			return f.read();
+		}
+
+		template <typename R, typename W>
+		inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
+			return f.write();
+		}
+
+		template <typename T, typename List>
+		struct void_call : void_call<T, meta::function_args_t<List>> { };
+
+		template <typename T, typename... Args>
+		struct void_call<T, types<Args...>> {
+			static void call(Args...) {
+			}
+		};
+
+		template <typename T, bool checked, bool clean_stack>
+		struct constructor_match {
+			T* obj_;
+			reference* obj_lua_ref_;
+			stack::stack_detail::undefined_metatable* p_umf_;
+
+			constructor_match(T* obj_ptr, reference& obj_lua_ref, stack::stack_detail::undefined_metatable& umf)
+			: obj_(obj_ptr), obj_lua_ref_(&obj_lua_ref), p_umf_(&umf) {
+			}
+
+			template <typename Fx, std::size_t I, typename... R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
+				detail::default_construct func {};
+				int result = stack::call_into_lua<checked, clean_stack>(r, a, L, start, func, this->obj_);
+				// construct userdata table
+				// SPECIFICALLY, after we've created it successfully.
+				// If the constructor exits for any reason we have to break things down...
+				if constexpr (clean_stack) {
+					obj_lua_ref_->push();
+					(*this->p_umf_)();
+					obj_lua_ref_->pop();
+				}
+				else {
+					(*this->p_umf_)();
+				}
+				return result;
+			}
+		};
+
+		namespace overload_detail {
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
+				return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
+			}
+
+			template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L,
+			     int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fxs...>(),
+					     std::index_sequence<In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fxs...>(),
+							     std::index_sequence<In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fxs...>(),
+						     std::index_sequence<In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+
+			template <std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				return overload_match_arity(types<>(),
+				     std::index_sequence<>(),
+				     std::index_sequence<M...>(),
+				     std::forward<Match>(matchfx),
+				     L,
+				     fxarity,
+				     start,
+				     std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
+			inline int overload_match_arity_single(
+			     types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<>(),
+					     std::index_sequence<>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				if constexpr (!traits::runtime_variadics_t::value) {
+					if (traits::free_arity != fxarity) {
+						return overload_match_arity(types<>(),
+						     std::index_sequence<>(),
+						     std::index_sequence<traits::free_arity, M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+				}
+				return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+			}
+
+			template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match,
+			     typename... Args>
+			inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx,
+			     lua_State* L, int fxarity, int start, Args&&... args) {
+				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
+				typedef meta::tuple_types<typename traits::return_type> return_types;
+				typedef typename traits::free_args_list args_list;
+				// compile-time eliminate any functions that we know ahead of time are of improper arity
+				if constexpr (!traits::runtime_variadics_t::value
+				     && meta::find_in_pack_v<meta::index_value<traits::free_arity>, meta::index_value<M>...>::value) {
+					return overload_match_arity(types<Fx1, Fxs...>(),
+					     std::index_sequence<I1, In...>(),
+					     std::index_sequence<M...>(),
+					     std::forward<Match>(matchfx),
+					     L,
+					     fxarity,
+					     start,
+					     std::forward<Args>(args)...);
+				}
+				else {
+					if constexpr (!traits::runtime_variadics_t::value) {
+						if (traits::free_arity != fxarity) {
+							return overload_match_arity(types<Fx1, Fxs...>(),
+							     std::index_sequence<I1, In...>(),
+							     std::index_sequence<traits::free_arity, M...>(),
+							     std::forward<Match>(matchfx),
+							     L,
+							     fxarity,
+							     start,
+							     std::forward<Args>(args)...);
+						}
+					}
+					stack::record tracking {};
+					if (!stack::stack_detail::check_types(args_list(), L, start, &no_panic, tracking)) {
+						return overload_match_arity(types<Fx1, Fxs...>(),
+						     std::index_sequence<I1, In...>(),
+						     std::index_sequence<M...>(),
+						     std::forward<Match>(matchfx),
+						     L,
+						     fxarity,
+						     start,
+						     std::forward<Args>(args)...);
+					}
+					return matchfx(types<Fx>(), meta::index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
+				}
+			}
+		} // namespace overload_detail
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			return overload_detail::overload_match_arity_single(types<Functions...>(),
+			     std::make_index_sequence<sizeof...(Functions)>(),
+			     std::index_sequence<>(),
+			     std::forward<Match>(matchfx),
+			     L,
+			     fxarity,
+			     start,
+			     std::forward<Args>(args)...);
+		}
+
+		template <typename... Functions, typename Match, typename... Args>
+		inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
+			int fxarity = lua_gettop(L) - (start - 1);
+			return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, typename... TypeLists, typename Match, typename... Args>
+		inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
+			// use same overload resolution matching as all other parts of the framework
+			return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(
+			     std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct_trampolined(lua_State* L) {
+			static const auto& meta = usertype_traits<T>::metatable();
+			int argcount = lua_gettop(L);
+			call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+			argcount -= static_cast<int>(syntax);
+
+			T* obj = detail::usertype_allocate<T>(L);
+			reference userdataref(L, -1);
+			stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+			// put userdata at the first index
+			lua_insert(L, 1);
+			construct_match<T, TypeLists...>(constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, 1 + static_cast<int>(syntax));
+
+			userdataref.push();
+			return 1;
+		}
+
+		template <typename T, bool checked, bool clean_stack, typename... TypeLists>
+		inline int construct(lua_State* L) {
+			return detail::static_trampoline<&construct_trampolined<T, checked, clean_stack, TypeLists...>>(L);
+		}
+
+		template <typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename = void>
+		struct agnostic_lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& f, Args&&... args) {
+				using uFx = meta::unqualified_t<Fx>;
+				static constexpr bool is_ref = is_lua_reference_v<uFx>;
+				if constexpr (is_ref) {
+					if constexpr (is_index) {
+						return stack::push(L, std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+					else {
+						std::forward<Fx>(f) = stack::unqualified_get<F>(L, boost + (is_variable ? 3 : 1));
+						return 0;
+					}
+				}
+				else {
+					using wrap = wrapper<uFx>;
+					using traits_type = typename wrap::traits_type;
+					using fp_t = typename traits_type::function_pointer_type;
+					constexpr bool is_function_pointer_convertible = std::is_class_v<uFx> && std::is_convertible_v<std::decay_t<Fx>, fp_t>;
+					if constexpr (is_function_pointer_convertible) {
+						fp_t fx = f;
+						return agnostic_lua_call_wrapper<fp_t, is_index, is_variable, checked, boost, clean_stack> {}.call(
+						     L, fx, std::forward<Args>(args)...);
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::free_args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
+					}
+				}
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<var_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (is_index) {
+					constexpr bool is_stack = is_stack_based_v<meta::unqualified_t<decltype(detail::unwrap(f.value()))>>;
+					if constexpr (clean_stack && !is_stack) {
+						lua_settop(L, 0);
+					}
+					return stack::push_reference(L, detail::unwrap(f.value()));
+				}
+				else {
+					if constexpr (std::is_const_v<meta::unwrapped_t<T>>) {
+						(void)f;
+						return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+					}
+					else {
+						using R = meta::unwrapped_t<T>;
+						if constexpr (std::is_assignable_v<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>) {
+							detail::unwrap(f.value()) = stack::unqualified_get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
+							if (clean_stack) {
+								lua_settop(L, 0);
+							}
+							return 0;
+						}
+						else {
+							return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+						}
+					}
+				}
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction_ref f) {
+				return f(L);
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, lua_CFunction f) {
+				return f(L);
+			}
+		};
+
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::lua_CFunction_noexcept, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, detail::lua_CFunction_noexcept f) {
+				return f(L);
+			}
+		};
+#endif // noexcept function types
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<detail::no_prop, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const detail::no_prop&) {
+				return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
+			}
+		};
+
+		template <bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const no_construction&) {
+				return function_detail::no_construction_error(L);
+			}
+		};
+
+		template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State*, const bases<Args...>&) {
+				// Uh. How did you even call this, lul
+				return 0;
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, std::reference_wrapper<T> f) {
+				agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost, clean_stack> alcw {};
+				return alcw.call(L, f.get());
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked = detail::default_safe_function_calls, int boost = 0,
+		     bool clean_stack = true, typename = void>
+		struct lua_call_wrapper {
+			template <typename Fx, typename... Args>
+			static int call(lua_State* L, Fx&& fx, Args&&... args) {
+				if constexpr (std::is_member_function_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (sizeof...(Args) < 1) {
+						using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+						static_assert(std::is_base_of_v<object_type, Ta>,
+						     "It seems like you might have accidentally bound a class type with a member function method that does not correspond to the "
+						     "class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one class \"T\" "
+						     "but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							return luaL_error(L,
+							     "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are "
+							     "preceeded by the "
+							     "actual object with '.' syntax)");
+						}
+						object_type* o = static_cast<object_type*>(maybeo.value());
+						return call(L, std::forward<Fx>(fx), *o);
+#else
+						object_type& o = static_cast<object_type&>(*stack::unqualified_get<non_null<Ta*>>(L, 1));
+						return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+					}
+					else {
+						using returns_list = typename wrap::returns_list;
+						using args_list = typename wrap::args_list;
+						using caller = typename wrap::caller;
+						return stack::call_into_lua<checked, clean_stack>(
+						     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), std::forward<Args>(args)...);
+					}
+				}
+				else if constexpr (std::is_member_object_pointer_v<F>) {
+					using wrap = wrapper<F>;
+					using object_type = typename wrap::object_type;
+					if constexpr (is_index) {
+						if constexpr (sizeof...(Args) < 1) {
+							using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+							static_assert(std::is_base_of_v<object_type, Ta>,
+							     "It seems like you might have accidentally bound a class type with a member function method that does not correspond "
+							     "to the class. For example, there could be a small type in your new_usertype<T>(...) binding, where you specify one "
+							     "class \"T\" but then bind member methods from a complete unrelated class. Check things over!");
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+							auto maybeo = stack::check_get<Ta*>(L, 1);
+							if (!maybeo || maybeo.value() == nullptr) {
+								if (is_variable) {
+									return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+								}
+								return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+							}
+							object_type* o = static_cast<object_type*>(maybeo.value());
+							return call(L, std::forward<Fx>(fx), *o);
+#else
+							object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+							return call(L, std::forward<Fx>(fx), o);
+#endif // Safety
+						}
+						else {
+							using returns_list = typename wrap::returns_list;
+							using caller = typename wrap::caller;
+							return stack::call_into_lua<checked, clean_stack>(returns_list(),
+							     types<>(),
+							     L,
+							     boost + (is_variable ? 3 : 2),
+							     caller(),
+							     std::forward<Fx>(fx),
+							     std::forward<Args>(args)...);
+						}
+					}
+					else {
+						using traits_type = lua_bind_traits<F>;
+						using return_type = typename traits_type::return_type;
+						constexpr bool ret_is_const = std::is_const_v<std::remove_reference_t<return_type>>;
+						if constexpr (ret_is_const) {
+							(void)fx;
+							(void)detail::swallow { 0, (static_cast<void>(args), 0)... };
+							return luaL_error(L, "sol: cannot write to a readonly (const) variable");
+						}
+						else {
+							using u_return_type = meta::unqualified_t<return_type>;
+							constexpr bool is_assignable = std::is_copy_assignable_v<u_return_type> || std::is_array_v<u_return_type>;
+							if constexpr (!is_assignable) {
+								(void)fx;
+								(void)detail::swallow { 0, ((void)args, 0)... };
+								return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
+							}
+							else {
+								using args_list = typename wrap::args_list;
+								using caller = typename wrap::caller;
+								if constexpr (sizeof...(Args) > 0) {
+									return stack::call_into_lua<checked, clean_stack>(types<void>(),
+									     args_list(),
+									     L,
+									     boost + (is_variable ? 3 : 2),
+									     caller(),
+									     std::forward<Fx>(fx),
+									     std::forward<Args>(args)...);
+								}
+								else {
+									using Ta = meta::conditional_t<std::is_void_v<T>, object_type, T>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+									auto maybeo = stack::check_get<Ta*>(L, 1);
+									if (!maybeo || maybeo.value() == nullptr) {
+										if (is_variable) {
+											return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
+										}
+										return luaL_error(L, "sol: received nil for 'self' argument (pass 'self' as first argument)");
+									}
+									object_type* po = static_cast<object_type*>(maybeo.value());
+									object_type& o = *po;
+#else
+									object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+
+									return stack::call_into_lua<checked, clean_stack>(
+									     types<void>(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), std::forward<Fx>(fx), o);
+								}
+							}
+						}
+					}
+				}
+				else {
+					agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost, clean_stack> alcw {};
+					return alcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+		};
+
+		template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, readonly_wrapper<F>, is_index, is_variable, checked, boost, clean_stack, C> {
+			using traits_type = lua_bind_traits<F>;
+			using wrap = wrapper<F>;
+			using object_type = typename wrap::object_type;
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, std::move(rw.value()));
+				}
+			}
+
+			static int call(lua_State* L, readonly_wrapper<F>&& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, std::move(rw));
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw) {
+				if constexpr (!is_index) {
+					(void)rw;
+					return luaL_error(L, "sol: cannot write to a sol::readonly variable");
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value());
+				}
+			}
+
+			static int call(lua_State* L, const readonly_wrapper<F>& rw, object_type& o) {
+				if constexpr (!is_index) {
+					(void)o;
+					return call(L, rw);
+				}
+				else {
+					lua_call_wrapper<T, F, true, is_variable, checked, boost, clean_stack, C> lcw;
+					return lcw.call(L, rw.value(), o);
+				}
+			}
+		};
+
+		template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_list<Args...> F;
+
+			static int call(lua_State* L, F&) {
+				const auto& meta = usertype_traits<T>::metatable();
+				int argcount = lua_gettop(L);
+				call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1) : call_syntax::dot;
+				argcount -= static_cast<int>(syntax);
+
+				T* obj = detail::usertype_allocate<T>(L);
+				reference userdataref(L, -1);
+				stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+
+				// put userdata at the first index
+				lua_insert(L, 1);
+				// Because of the way constructors work,
+				// we have to kill the data, but only if the cosntructor is successfulyl invoked...
+				// if it's not successfully invoked and we panic,
+				// we cannot actually deallcoate/delete the data.
+				construct_match<T, Args...>(
+				     constructor_match<T, checked, clean_stack>(obj, userdataref, umf), L, argcount, boost + 1 + 1 + static_cast<int>(syntax));
+
+				userdataref.push();
+				return 1;
+			}
+		};
+
+		template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef constructor_wrapper<Cxs...> F;
+
+			struct onmatch {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
+					const auto& meta = usertype_traits<T>::metatable();
+					T* obj = detail::usertype_allocate<T>(L);
+					reference userdataref(L, -1);
+					stack::stack_detail::undefined_metatable umf(L, &meta[0], &stack::stack_detail::set_undefined_methods_on<T>);
+					umf();
+
+					auto& func = std::get<I>(f.functions);
+					// put userdata at the first index
+					lua_insert(L, 1);
+					stack::call_into_lua<checked, clean_stack>(r, a, L, boost + 1 + start, func, detail::implicit_wrapper<T>(obj));
+
+					userdataref.push();
+					return 1;
+				}
+			};
+
+			static int call(lua_State* L, F& f) {
+				call_syntax syntax = stack::get_call_syntax(L, usertype_traits<T>::user_metatable(), 1);
+				int syntaxval = static_cast<int>(syntax);
+				int argcount = lua_gettop(L) - syntaxval;
+				return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
+			}
+		};
+
+		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, clean_stack, C> {
+
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				if constexpr (std::is_void_v<Fx>) {
+					return detail::usertype_alloc_destroy<T>(L);
+				}
+				else {
+					using uFx = meta::unqualified_t<Fx>;
+					lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+					return lcw.call(L, std::forward<F>(f).fx);
+				}
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef overload_set<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
+			}
+		};
+
+		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef factory_wrapper<Fs...> F;
+
+			struct on_match {
+				template <typename Fx, std::size_t I, typename... R, typename... Args>
+				int operator()(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
+					auto& f = std::get<I>(fx.functions);
+					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f);
+				}
+			};
+
+			static int call(lua_State* L, F& fx) {
+				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
+			}
+		};
+
+		template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef meta::conditional_t<is_index, R, W> P;
+			typedef meta::unqualified_t<P> U;
+			typedef wrapper<U> wrap;
+			typedef lua_bind_traits<U> traits_type;
+			typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
+
+			template <typename F, typename... Args>
+			static int call(lua_State* L, F&& f, Args&&... args) {
+				constexpr bool is_specialized = meta::any<std::is_same<U, detail::no_prop>,
+				     meta::is_specialization_of<U, var_wrapper>,
+				     meta::is_specialization_of<U, constructor_wrapper>,
+				     meta::is_specialization_of<U, constructor_list>,
+				     std::is_member_pointer<U>>::value;
+				if constexpr (is_specialized) {
+					if constexpr (is_index) {
+						decltype(auto) p = f.read();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+					else {
+						decltype(auto) p = f.write();
+						lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+						return lcw.call(L, p, std::forward<Args>(args)...);
+					}
+				}
+				else {
+					constexpr bool non_class_object_type = meta::any<std::is_void<object_type>,
+					     meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>::value;
+					if constexpr (non_class_object_type) {
+						// The type being void means we don't have any arguments, so it might be a free functions?
+						using args_list = typename traits_type::free_args_list;
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf);
+						}
+					}
+					else {
+						using args_list = meta::pop_front_type_t<typename traits_type::free_args_list>;
+						using Ta = T;
+						using Oa = std::remove_pointer_t<object_type>;
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+						auto maybeo = stack::check_get<Ta*>(L, 1);
+						if (!maybeo || maybeo.value() == nullptr) {
+							if (is_variable) {
+								return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
+							}
+							return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
+						}
+						Oa* o = static_cast<Oa*>(maybeo.value());
+#else
+						Oa* o = static_cast<Oa*>(stack::get<non_null<Ta*>>(L, 1));
+#endif // Safety
+						using returns_list = typename wrap::returns_list;
+						using caller = typename wrap::caller;
+						if constexpr (is_index) {
+							decltype(auto) pf = f.read();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+						else {
+							decltype(auto) pf = f.write();
+							return stack::call_into_lua<checked, clean_stack>(
+							     returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), pf, detail::implicit_wrapper<Oa>(*o));
+						}
+					}
+				}
+			}
+		};
+
+		template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef protect_t<V> F;
+
+			template <typename... Args>
+			static int call(lua_State* L, F& fx, Args&&... args) {
+				return lua_call_wrapper<T, V, is_index, is_variable, true, boost, clean_stack> {}.call(L, fx.value, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T, typename F, typename... Policies, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, policy_wrapper<F, Policies...>, is_index, is_variable, checked, boost, clean_stack, C> {
+			typedef policy_wrapper<F, Policies...> P;
+
+			template <std::size_t... In>
+			static int call(std::index_sequence<In...>, lua_State* L, P& fx) {
+				int pushed = lua_call_wrapper<T, F, is_index, is_variable, checked, boost, false, C> {}.call(L, fx.value);
+				(void)detail::swallow { int(), (policy_detail::handle_policy(std::get<In>(fx.policies), L, pushed), int())... };
+				return pushed;
+			}
+
+			static int call(lua_State* L, P& fx) {
+				typedef typename P::indices indices;
+				return call(indices(), L, fx);
+			}
+		};
+
+		template <typename T, typename Y, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, yielding_t<Y>, is_index, is_variable, checked, boost, clean_stack, C> {
+			template <typename F>
+			static int call(lua_State* L, F&& f) {
+				return lua_call_wrapper<T, meta::unqualified_t<Y>, is_index, is_variable, checked, boost, clean_stack> {}.call(L, f.func);
+			}
+		};
+
+		template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, bool clean_stack, typename C>
+		struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, clean_stack, C> {
+			static int call(lua_State* L, const function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(f.arguments));
+			}
+
+			static int call(lua_State* L, function_arguments<Sig, P>&& f) {
+				lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::get<0>(std::move(f.arguments)));
+			}
+		};
+
+		template <typename T, bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true,
+		     typename Fx, typename... Args>
+		inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				using real_fx = meta::unqualified_t<decltype(std::forward<Fx>(fx).func)>;
+				lua_call_wrapper<T, real_fx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx).func, std::forward<Args>(args)...);
+			}
+			else {
+				lua_call_wrapper<T, uFx, is_index, is_variable, checked, boost, clean_stack> lcw {};
+				return lcw.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <typename T, bool is_index, bool is_variable, typename F, int start = 1, bool checked = detail::default_safe_function_calls,
+		     bool clean_stack = true>
+		inline int call_user(lua_State* L) {
+			auto& fx = stack::unqualified_get<user<F>>(L, upvalue_index(start));
+			using uFx = meta::unqualified_t<F>;
+			int nr = call_wrapped<T, is_index, is_variable, 0, checked, clean_stack>(L, fx);
+			if constexpr (meta::is_specialization_of_v<uFx, yielding_t>) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <typename T, typename = void>
+		struct is_var_bind : std::false_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<T, std::enable_if_t<is_lua_reference_or_proxy<T>::value>> : std::true_type { };
+
+		template <>
+		struct is_var_bind<detail::no_prop> : std::true_type { };
+
+		template <typename R, typename W>
+		struct is_var_bind<property_wrapper<R, W>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<var_wrapper<T>> : std::true_type { };
+
+		template <typename T>
+		struct is_var_bind<readonly_wrapper<T>> : is_var_bind<meta::unqualified_t<T>> { };
+
+		template <typename F, typename... Policies>
+		struct is_var_bind<policy_wrapper<F, Policies...>> : is_var_bind<meta::unqualified_t<F>> { };
+	} // namespace call_detail
+
+	template <typename T>
+	struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> { };
+
+	template <typename T>
+	using is_var_wrapper = meta::is_specialization_of<T, var_wrapper>;
+
+	template <typename T>
+	struct is_function_binding : meta::neg<is_variable_binding<T>> { };
+
+} // namespace sol
+
+// end of sol/call.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename F, F fx>
+		inline int call_wrapper_variable(std::false_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
+			typedef typename traits_type::args_list args_list;
+			typedef meta::tuple_types<typename traits_type::return_type> return_type;
+			return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
+			return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
+			(mem.*variable) = stack::get<R>(L, 2);
+			return 0;
+		}
+
+		template <typename R, typename V, V, typename T>
+		inline int call_set_variable(std::false_type, lua_State* L, T&&) {
+			return luaL_error(L, "cannot write to a const variable");
+		}
+
+		template <typename R, typename V, V variable, typename T>
+		inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
+			return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
+		}
+
+		template <typename V, V variable>
+		inline int call_wrapper_variable(std::true_type, lua_State* L) {
+			typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
+			typedef typename traits_type::object_type T;
+			typedef typename traits_type::return_type R;
+			auto& mem = stack::get<T>(L, 1);
+			switch (lua_gettop(L)) {
+			case 1: {
+				decltype(auto) r = (mem.*variable);
+				stack::push_reference(L, std::forward<decltype(r)>(r));
+				return 1;
+			}
+			case 2:
+				return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
+			default:
+				return luaL_error(L, "incorrect number of arguments to member variable function call");
+			}
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::false_type, lua_State* L) {
+			return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
+		}
+
+		template <typename F, F fx>
+		inline int call_wrapper_function(std::true_type, lua_State* L) {
+			return call_detail::call_wrapped<void, false, false>(L, fx);
+		}
+
+		template <typename F, F fx>
+		int call_wrapper_entry(lua_State* L) noexcept(meta::bind_traits<F>::is_noexcept) {
+			return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
+		}
+
+		template <typename... Fxs>
+		struct c_call_matcher {
+			template <typename Fx, std::size_t I, typename R, typename... Args>
+			int operator()(types<Fx>, meta::index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
+				typedef meta::at_in_pack_t<I, Fxs...> target;
+				return target::call(L);
+			}
+		};
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::true_type, lua_State* L) {
+			return fx(L);
+		}
+
+		template <typename F, F fx>
+		inline int c_call_raw(std::false_type, lua_State* L) {
+#ifdef __clang__
+			return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
+#else
+			return detail::typed_static_trampoline<decltype(&function_detail::call_wrapper_entry<F, fx>), (&function_detail::call_wrapper_entry<F, fx>)>(L);
+#endif // fuck you clang :c
+		}
+
+	} // namespace function_detail
+
+	template <typename F, F fx>
+	inline int c_call(lua_State* L) {
+		typedef meta::unqualified_t<F> Fu;
+		typedef std::integral_constant<bool,
+		     std::is_same<Fu, lua_CFunction>::value
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          || std::is_same<Fu, detail::lua_CFunction_noexcept>::value
+#endif
+		     >
+		     is_raw;
+		return function_detail::c_call_raw<F, fx>(is_raw(), L);
+	}
+
+	template <typename F, F f>
+	struct wrap {
+		typedef F type;
+
+		static int call(lua_State* L) noexcept(noexcept(c_call<type, f>(L))) {
+			return c_call<type, f>(L);
+		}
+	};
+
+	template <typename... Fxs>
+	inline int c_call(lua_State* L) {
+		if constexpr (sizeof...(Fxs) < 2) {
+			using target = meta::at_in_pack_t<0, Fxs...>;
+			return target::call(L);
+		}
+		else {
+			return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
+		}
+	}
+
+} // namespace sol
+
+// end of sol/function_types_templated.hpp
+
+// beginning of sol/function_types_stateless.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Function>
+	struct upvalue_free_function {
+		using function_type = std::remove_pointer_t<std::decay_t<Function>>;
+		using traits_type = meta::bind_traits<function_type>;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
+			function_type* fx = udata.first;
+			return call_detail::call_wrapped<void, true, false>(L, fx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member function pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			auto& item = *static_cast<T*>(stack::get<void*>(L, upvalue_index(3)));
+			return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			case 1:
+				return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			// idx n + 1: is the object's void pointer
+			// We don't need to store the size, because the other side is templated
+			// with the same member function pointer type
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
+			auto& mem = *objdata.first;
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 0:
+				return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			function_type& memfx = stack::get<user<function_type>>(L, upvalue_index(2));
+			return call_detail::call_wrapped<T, false, false>(L, memfx);
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			case 2:
+				return call_detail::call_wrapped<T, false, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+
+	template <typename T, typename Function>
+	struct upvalue_this_member_variable<T, readonly_wrapper<Function>> {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef lua_bind_traits<function_type> traits_type;
+
+		static int real_call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			// Layout:
+			// idx 1...n: verbatim data of member variable pointer
+			auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
+			function_type& var = memberdata.first;
+			switch (lua_gettop(L)) {
+			case 1:
+				return call_detail::call_wrapped<T, true, false>(L, var);
+			default:
+				return luaL_error(L, "sol: incorrect number of arguments to member variable function");
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline>
+		static int call(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			if constexpr (no_trampoline) {
+				nr = real_call(L);
+			}
+			else {
+				nr = detail::typed_static_trampoline<decltype(&real_call), (&real_call)>(L);
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			return call(L);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateless.hpp
+
+// beginning of sol/function_types_stateful.hpp
+
+namespace sol { namespace function_detail {
+	template <typename Func, bool is_yielding, bool no_trampoline>
+	struct functor_function {
+		typedef std::decay_t<meta::unwrap_unqualified_t<Func>> function_type;
+		function_type invocation;
+
+		template <typename... Args>
+		functor_function(function_type f, Args&&... args) noexcept(std::is_nothrow_constructible_v<function_type, function_type, Args...>)
+		: invocation(std::move(f), std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, functor_function& self) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, self.invocation))) {
+			int nr = call_detail::call_wrapped<void, true, false>(L, self.invocation);
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(noexcept(call_detail::call_wrapped<void, true, false>(L, invocation))) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_function {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef meta::function_return_t<function_type> return_type;
+		typedef meta::function_args_t<function_type> args_lists;
+		using traits_type = meta::bind_traits<function_type>;
+		function_type invocation;
+		T member;
+
+		template <typename... Args>
+		member_function(function_type f, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: invocation(std::move(f)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_function& self)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			int nr = call_detail::call_wrapped<T, true, false, -1>(L, self.invocation, detail::unwrap(detail::deref(self.member)));
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L)
+#if SOL_IS_ON(SOL_COMPILER_VCXX)
+		// MSVC is broken, what a surprise...
+#else
+			noexcept(traits_type::is_noexcept)
+#endif
+		{
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+
+	template <typename T, typename Function, bool is_yielding, bool no_trampoline>
+	struct member_variable {
+		typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
+		typedef typename meta::bind_traits<function_type>::return_type return_type;
+		typedef typename meta::bind_traits<function_type>::args_list args_lists;
+		function_type var;
+		T member;
+		typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
+
+		template <typename... Args>
+		member_variable(function_type v, Args&&... args) noexcept(
+			std::is_nothrow_constructible_v<function_type, function_type>&& std::is_nothrow_constructible_v<T, Args...>)
+		: var(std::move(v)), member(std::forward<Args>(args)...) {
+		}
+
+		static int call(lua_State* L, member_variable& self) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			int nr;
+			{
+				M mem = detail::unwrap(detail::deref(self.member));
+				switch (lua_gettop(L)) {
+				case 0:
+					nr = call_detail::call_wrapped<T, true, false, -1>(L, self.var, mem);
+					break;
+				case 1:
+					nr = call_detail::call_wrapped<T, false, false, -1>(L, self.var, mem);
+					break;
+				default:
+					nr = luaL_error(L, "sol: incorrect number of arguments to member variable function");
+					break;
+				}
+			}
+			if (is_yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		int operator()(lua_State* L) noexcept(std::is_nothrow_copy_assignable_v<T>) {
+			if constexpr (no_trampoline) {
+				return call(L, *this);
+			}
+			else {
+				return detail::trampoline(L, &call, *this);
+			}
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_stateful.hpp
+
+// beginning of sol/function_types_overloaded.hpp
+
+namespace sol { namespace function_detail {
+	template <int start_skew, typename... Functions>
+	struct overloaded_function {
+		typedef std::tuple<Functions...> overload_list;
+		typedef std::make_index_sequence<sizeof...(Functions)> indices;
+		overload_list overloads;
+
+		overloaded_function(overload_list set) : overloads(std::move(set)) {
+		}
+
+		overloaded_function(Functions... fxs) : overloads(fxs...) {
+		}
+
+		template <typename Fx, std::size_t I, typename... R, typename... Args>
+		static int call(types<Fx>, meta::index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, overload_list& ol) {
+			auto& func = std::get<I>(ol);
+			int nr = call_detail::call_wrapped<void, true, false, start_skew>(L, func);
+			return nr;
+		}
+
+		struct on_success {
+			template <typename... Args>
+			int operator()(Args&&... args) const {
+				return call(std::forward<Args>(args)...);
+			}
+		};
+
+		int operator()(lua_State* L) {
+			on_success call_obj {};
+			return call_detail::overload_match<Functions...>(call_obj, L, 1 + start_skew, overloads);
+		}
+	};
+}} // namespace sol::function_detail
+
+// end of sol/function_types_overloaded.hpp
+
+// beginning of sol/resolve.hpp
+
+namespace sol {
+
+#ifndef __clang__
+	// constexpr is fine for not-clang
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline constexpr auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline constexpr void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline constexpr Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline constexpr auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline constexpr Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline constexpr auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline constexpr Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
+	inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+#else
+
+	// Clang has distinct problems with constexpr arguments,
+	// so don't use the constexpr versions inside of clang.
+
+	namespace detail {
+		template <typename R, typename... Args, typename F, typename = std::invoke_result_t<meta::unqualified_t<F>, Args...>>
+		inline auto resolve_i(types<R(Args...)>, F&&) -> R (meta::unqualified_t<F>::*)(Args...) {
+			using Sig = R(Args...);
+			typedef meta::unqualified_t<F> Fu;
+			return static_cast<Sig Fu::*>(&Fu::operator());
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_f(std::true_type, F&& f)
+		     -> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
+			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
+		}
+
+		template <typename F>
+		inline void resolve_f(std::false_type, F&&) {
+			static_assert(meta::call_operator_deducible_v<F>, "Cannot use no-template-parameter call with an overloaded functor: specify the signature");
+		}
+
+		template <typename F, typename U = meta::unqualified_t<F>>
+		inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::call_operator_deducible<U>(), std::forward<F>(f))) {
+			return resolve_f(meta::call_operator_deducible<U> {}, std::forward<F>(f));
+		}
+
+		template <typename... Args, typename F, typename R = std::invoke_result_t<F&, Args...>>
+		inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
+			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::false_type, Sig C::*mem_func_ptr) {
+			return mem_func_ptr;
+		}
+
+		template <typename Sig, typename C>
+		inline Sig C::*resolve_v(std::true_type, Sig C::*mem_variable_ptr) {
+			return mem_variable_ptr;
+		}
+	} // namespace detail
+
+	template <typename... Args, typename R>
+	inline auto resolve(R fun_ptr(Args...)) -> R (*)(Args...) {
+		return fun_ptr;
+	}
+
+	template <typename Sig>
+	inline Sig* resolve(Sig* fun_ptr) {
+		return fun_ptr;
+	}
+
+	template <typename... Args, typename R, typename C>
+	inline auto resolve(R (C::*mem_ptr)(Args...)) -> R (C::*)(Args...) {
+		return mem_ptr;
+	}
+
+	template <typename Sig, typename C>
+	inline Sig C::*resolve(Sig C::*mem_ptr) {
+		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
+	}
+
+	template <typename... Sig, typename F>
+	inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
+		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
+	}
+
+#endif
+
+} // namespace sol
+
+// end of sol/resolve.hpp
+
+namespace sol {
+	namespace function_detail {
+		template <typename T>
+		struct class_indicator {
+			using type = T;
+		};
+
+		struct call_indicator { };
+
+		template <bool yielding>
+		int lua_c_wrapper(lua_State* L) {
+			lua_CFunction cf = lua_tocfunction(L, lua_upvalueindex(2));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		template <bool yielding>
+		int lua_c_noexcept_wrapper(lua_State* L) noexcept {
+			detail::lua_CFunction_noexcept cf = reinterpret_cast<detail::lua_CFunction_noexcept>(lua_tocfunction(L, lua_upvalueindex(2)));
+			int nr = cf(L);
+			if constexpr (yielding) {
+				return lua_yield(L, nr);
+			}
+			else {
+				return nr;
+			}
+		}
+
+		struct c_function_invocation { };
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args);
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_set_fx(lua_State* L, Args&&... args) {
+			lua_CFunction freefunc = no_trampoline ? function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>
+			                                       : detail::static_trampoline<function_detail::call<meta::unqualified_t<Fx>, 2, is_yielding>>;
+
+			int upvalues = 0;
+			upvalues += stack::push(L, nullptr);
+			upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
+			stack::push(L, c_closure(freefunc, upvalues));
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename R, typename... A, typename Fx, typename... Args>
+		void select_convertible(types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<meta::unwrap_unqualified_t<Fx>>;
+			using fx_ptr_t = R (*)(A...);
+			constexpr bool is_convertible = std::is_convertible_v<dFx, fx_ptr_t>;
+			if constexpr (is_convertible) {
+				fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
+				select<is_yielding, no_trampoline>(L, std::move(fxptr), std::forward<Args>(args)...);
+			}
+			else {
+				using F = function_detail::functor_function<dFx, false, true>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
+			typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
+			select_convertible<is_yielding, no_trampoline>(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_variable(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (sizeof...(Args) < 2) {
+				using Tu = typename meta::meta_detail::unqualified_non_alias<Args...>::type;
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_this_member_variable<typename Tu::type, Fx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, fx);
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else if constexpr (is_reference) {
+					typedef std::decay_t<Fx> dFx;
+					dFx memfxptr(std::forward<Fx>(fx));
+					auto userptr = detail::ptr(std::forward<Args>(args)...);
+					lua_CFunction freefunc = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>,
+					     meta::unqualified_t<Fx>>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
+					upvalues += stack::push(L, static_cast<void const*>(userptr));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+					using F = function_detail::member_variable<Tu, clean_fx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				}
+			}
+			else {
+				using C = typename meta::bind_traits<uFx>::object_type;
+				using clean_fx = std::remove_pointer_t<std::decay_t<Fx>>;
+				using F = function_detail::member_variable<C, clean_fx, is_yielding, no_trampoline>;
+				select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename T, typename... Args>
+		void select_member_function_with(lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			using Tu = meta::unqualified_t<T>;
+			if constexpr (meta::is_specialization_of_v<Tu, function_detail::class_indicator>) {
+				(void)obj;
+				using C = typename Tu::type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				constexpr bool is_reference = meta::is_specialization_of_v<Tu, std::reference_wrapper> || std::is_pointer_v<Tu>;
+				if constexpr (is_reference) {
+					auto userptr = detail::ptr(std::forward<T>(obj));
+					lua_CFunction freefunc
+					     = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, dFx>::template call<is_yielding, no_trampoline>;
+
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+					upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
+					stack::push(L, c_closure(freefunc, upvalues));
+				}
+				else {
+					using F = function_detail::member_function<Tu, dFx, is_yielding, no_trampoline>;
+					select_set_fx<is_yielding, no_trampoline, F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
+				}
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select_member_function(lua_State* L, Fx&& fx, Args&&... args) {
+			using dFx = std::decay_t<Fx>;
+			if constexpr (sizeof...(Args) < 1) {
+				using C = typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type;
+				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, dFx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<dFx>>(L, std::forward<Fx>(fx));
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else {
+				select_member_function_with<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+
+		template <bool is_yielding, bool no_trampoline, typename Fx, typename... Args>
+		void select(lua_State* L, Fx&& fx, Args&&... args) {
+			using uFx = meta::unqualified_t<Fx>;
+			if constexpr (is_lua_reference_v<uFx>) {
+				// TODO: hoist into lambda in this case for yielding???
+				stack::push(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (is_lua_c_function_v<uFx>) {
+				if constexpr (no_trampoline) {
+					if (is_yielding) {
+						int upvalues = 0;
+						upvalues += stack::push(L, nullptr);
+						upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+						if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+							detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<true>;
+							lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+						}
+						else
+#endif
+						{
+							lua_CFunction cf = &function_detail::lua_c_wrapper<true>;
+							lua_pushcclosure(L, cf, upvalues);
+						}
+					}
+					else {
+						lua_pushcclosure(L, std::forward<Fx>(fx), 0);
+					}
+				}
+				else {
+					int upvalues = 0;
+					upvalues += stack::push(L, nullptr);
+					upvalues += stack::push(L, std::forward<Fx>(fx));
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+					if constexpr (std::is_nothrow_invocable_r_v<int, uFx, lua_State*>) {
+						detail::lua_CFunction_noexcept cf = &lua_c_noexcept_wrapper<is_yielding>;
+						lua_pushcclosure(L, reinterpret_cast<lua_CFunction>(cf), upvalues);
+					}
+					else {
+						lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+						lua_pushcclosure(L, cf, upvalues);
+					}
+#else
+					lua_CFunction cf = &function_detail::lua_c_wrapper<is_yielding>;
+					lua_pushcclosure(L, cf, upvalues);
+#endif
+				}
+			}
+			else if constexpr (std::is_function_v<std::remove_pointer_t<uFx>>) {
+				std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
+				lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx>::template call<is_yielding, no_trampoline>;
+
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::stack_detail::push_as_upvalues(L, target);
+				stack::push(L, c_closure(freefunc, upvalues));
+			}
+			else if constexpr (std::is_member_function_pointer_v<uFx>) {
+				select_member_function<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else if constexpr (meta::is_member_object_v<uFx>) {
+				select_member_variable<is_yielding, no_trampoline>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+			else {
+				select_convertible<is_yielding, no_trampoline>(types<>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
+			}
+		}
+	} // namespace function_detail
+
+	namespace stack {
+		template <typename... Sigs>
+		struct unqualified_pusher<function_sig<Sigs...>> {
+			template <bool is_yielding, typename Arg0, typename... Args>
+			static int push_yielding(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, std::function>) {
+					if constexpr (is_yielding) {
+						return stack::push<meta::unqualified_t<Arg0>>(L, detail::yield_tag, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+					else {
+						return stack::push(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					}
+				}
+				else {
+					function_detail::select<is_yielding, false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename Arg0, typename... Args>
+			static int push(lua_State* L, Arg0&& arg0, Args&&... args) {
+				if constexpr (std::is_same_v<meta::unqualified_t<Arg0>, detail::yield_tag_t>) {
+					push_yielding<true>(L, std::forward<Args>(args)...);
+				}
+				else if constexpr (meta::is_specialization_of_v<meta::unqualified_t<Arg0>, yielding_t>) {
+					push_yielding<true>(L, std::forward<Arg0>(arg0).func, std::forward<Args>(args)...);
+				}
+				else {
+					push_yielding<false>(L, std::forward<Arg0>(arg0), std::forward<Args>(args)...);
+				}
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<yielding_t<T>> {
+			template <typename... Args>
+			static int push(lua_State* L, const yielding_t<T>& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, f.func, std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, f.func, std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+
+			template <typename... Args>
+			static int push(lua_State* L, yielding_t<T>&& f, Args&&... args) {
+				if constexpr (meta::is_specialization_of_v<meta::unqualified_t<T>, std::function>) {
+					return stack::push<T>(L, detail::yield_tag, std::move(f.func), std::forward<Args>(args)...);
+				}
+				else {
+					function_detail::select<true, false>(L, std::move(f.func), std::forward<Args>(args)...);
+					return 1;
+				}
+			}
+		};
+
+		template <typename T, typename... Args>
+		struct unqualified_pusher<function_arguments<T, Args...>> {
+			template <std::size_t... I, typename FP>
+			static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
+				return stack::push<T>(L, std::get<I>(std::forward<FP>(fp).arguments)...);
+			}
+
+			static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
+			}
+
+			static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
+				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<std::function<Signature>> {
+			using TargetFunctor = function_detail::functor_function<std::function<Signature>, false, true>;
+
+			static int push(lua_State* L, detail::yield_tag_t, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, detail::yield_tag_t, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<true, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, const std::function<Signature>& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, fx);
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+
+			static int push(lua_State* L, std::function<Signature>&& fx) {
+				if (fx) {
+					function_detail::select_set_fx<false, false, TargetFunctor>(L, std::move(fx));
+					return 1;
+				}
+				return stack::push(L, lua_nil);
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature, std::enable_if_t<meta::is_member_object_or_function_v<Signature>>> {
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				function_detail::select<false, false>(L, std::forward<Args>(args)...);
+				return 1;
+			}
+		};
+
+		template <typename Signature>
+		struct unqualified_pusher<Signature,
+		     std::enable_if_t<meta::all<std::is_function<std::remove_pointer_t<Signature>>, meta::neg<std::is_same<Signature, lua_CFunction>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>
+#if SOL_IS_ON(SOL_USE_NOEXCEPT_FUNCTION_TYPE)
+		          ,
+		          meta::neg<std::is_same<Signature, detail::lua_CFunction_noexcept>>,
+		          meta::neg<std::is_same<Signature, std::remove_pointer_t<detail::lua_CFunction_noexcept>>>
+#endif // noexcept function types
+		          >::value>> {
+			template <typename F>
+			static int push(lua_State* L, F&& f) {
+				function_detail::select<false, true>(L, std::forward<F>(f));
+				return 1;
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<overload_set<Functions...>> {
+			static int push(lua_State* L, overload_set<Functions...>&& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(set.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const overload_set<Functions...>& set) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, set.functions);
+				return 1;
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<protect_t<T>> {
+			static int push(lua_State* L, protect_t<T>&& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const protect_t<T>& pw) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename G>
+		struct unqualified_pusher<property_wrapper<F, G>> {
+			static int push(lua_State* L, property_wrapper<F, G>&& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, std::move(pw.write()));
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, std::move(pw.read()));
+				}
+				else {
+					return stack::push(L, overload(std::move(pw.read()), std::move(pw.write())));
+				}
+			}
+
+			static int push(lua_State* L, const property_wrapper<F, G>& pw) {
+				if constexpr (std::is_void_v<F>) {
+					return stack::push(L, pw.write);
+				}
+				else if constexpr (std::is_void_v<G>) {
+					return stack::push(L, pw.read);
+				}
+				else {
+					return stack::push(L, overload(pw.read, pw.write));
+				}
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<var_wrapper<T>> {
+			static int push(lua_State* L, var_wrapper<T>&& vw) {
+				return stack::push(L, std::move(vw.value()));
+			}
+			static int push(lua_State* L, const var_wrapper<T>& vw) {
+				return stack::push(L, vw.value());
+			}
+		};
+
+		template <typename... Functions>
+		struct unqualified_pusher<factory_wrapper<Functions...>> {
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
+				using F = function_detail::overloaded_function<0, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+
+			static int push(lua_State* L, const factory_wrapper<Functions...>& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, fw.functions);
+				return 1;
+			}
+
+			static int push(lua_State* L, factory_wrapper<Functions...>&& fw, function_detail::call_indicator) {
+				using F = function_detail::overloaded_function<1, Functions...>;
+				function_detail::select_set_fx<false, false, F>(L, std::move(fw.functions));
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<no_construction> {
+			static int push(lua_State* L, no_construction) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
+				return push(L, c);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, no_construction>> {
+			static int push(lua_State* L, detail::tagged<T, no_construction>) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, no_construction, function_detail::call_indicator) {
+				lua_CFunction cf = &function_detail::no_construction_error;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename... Lists>
+		struct unqualified_pusher<detail::tagged<T, constructor_list<Lists...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+
+			static int push(lua_State* L, constructor_list<Lists...>) {
+				lua_CFunction cf = call_detail::construct<T, detail::default_safe_function_calls, true, Lists...>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename L0, typename... Lists>
+		struct unqualified_pusher<constructor_list<L0, Lists...>> {
+			typedef constructor_list<L0, Lists...> cl_t;
+			static int push(lua_State* L, cl_t cl) {
+				typedef typename meta::bind_traits<L0>::return_type T;
+				return stack::push<detail::tagged<T, cl_t>>(L, cl);
+			}
+		};
+
+		template <typename T, typename... Fxs>
+		struct unqualified_pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
+			static int push(lua_State* L, detail::tagged<T, constructor_wrapper<Fxs...>>&& c) {
+				return push(L, std::move(c.value()));
+			}
+
+			static int push(lua_State* L, const detail::tagged<T, const constructor_wrapper<Fxs...>>& c) {
+				return push(L, c.value());
+			}
+
+			static int push(lua_State* L, constructor_wrapper<Fxs...>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const constructor_wrapper<Fxs...>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Fxs>
+		struct unqualified_pusher<constructor_wrapper<F, Fxs...>> {
+			static int push(lua_State* L, const constructor_wrapper<F, Fxs...>& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, c);
+			}
+
+			static int push(lua_State* L, constructor_wrapper<F, Fxs...>&& c) {
+				typedef typename meta::bind_traits<F>::template arg_at<0> arg0;
+				typedef meta::unqualified_t<std::remove_pointer_t<arg0>> T;
+				return stack::push<detail::tagged<T, constructor_wrapper<F, Fxs...>>>(L, std::move(c));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<void>>> {
+			static int push(lua_State* L, destructor_wrapper<void>) {
+				lua_CFunction cf = detail::usertype_alloc_destroy<T>;
+				return stack::push(L, cf);
+			}
+		};
+
+		template <typename T, typename Fx>
+		struct unqualified_pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename Fx>
+		struct unqualified_pusher<destructor_wrapper<Fx>> {
+			static int push(lua_State* L, destructor_wrapper<Fx>&& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, std::move(c));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, const destructor_wrapper<Fx>& c) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, destructor_wrapper<Fx>, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<destructor_wrapper<Fx>>>(L, c);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename F, typename... Policies>
+		struct unqualified_pusher<policy_wrapper<F, Policies...>> {
+			using P = policy_wrapper<F, Policies...>;
+
+			static int push(lua_State* L, const P& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p);
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, P&& p) {
+				lua_CFunction cf = call_detail::call_user<void, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T, typename F, typename... Policies>
+		struct unqualified_pusher<detail::tagged<T, policy_wrapper<F, Policies...>>> {
+			using P = policy_wrapper<F, Policies...>;
+			using Tagged = detail::tagged<T, P>;
+
+			static int push(lua_State* L, const Tagged& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, p.value());
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+
+			static int push(lua_State* L, Tagged&& p) {
+				lua_CFunction cf = call_detail::call_user<T, false, false, P, 2>;
+				int upvalues = 0;
+				upvalues += stack::push(L, nullptr);
+				upvalues += stack::push<user<P>>(L, std::move(p.value()));
+				return stack::push(L, c_closure(cf, upvalues));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<push_invoke_t<T>> {
+			static int push(lua_State* L, push_invoke_t<T>&& pi) {
+				if constexpr (std::is_invocable_v<std::add_rvalue_reference_t<T>, lua_State*>) {
+					return stack::push(L, std::move(pi.value())(L));
+				}
+				else {
+					return stack::push(L, std::move(pi.value())());
+				}
+			}
+
+			static int push(lua_State* L, const push_invoke_t<T>& pi) {
+				if constexpr (std::is_invocable_v<const T, lua_State*>) {
+					return stack::push(L, pi.value()(L));
+				}
+				else {
+					return stack::push(L, pi.value()());
+				}
+			}
+		};
+
+		namespace stack_detail {
+			template <typename Function, typename Handler>
+			bool check_function_pointer(lua_State* L, int index, Handler&& handler, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				bool success = lua_iscfunction(L, index) == 1;
+				if (success) {
+					// there must be at LEAST 2 upvalues; otherwise, we didn't serialize it.
+					const char* upvalue_name = lua_getupvalue(L, index, 2);
+					lua_pop(L, 1);
+					success = upvalue_name != nullptr;
+				}
+				if (!success) {
+					// expected type, actual type
+					handler(
+					     L, index, type::function, type_of(L, index), "type must be a Lua C Function gotten from a function pointer serialized by sol2");
+				}
+				return success;
+#else
+				(void)L;
+				(void)index;
+				(void)handler;
+				(void)tracking;
+				return false;
+#endif
+			}
+
+			template <typename Function>
+			Function* get_function_pointer(lua_State* L, int index, record& tracking) noexcept {
+#if SOL_IS_ON(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				tracking.use(1);
+				auto udata = stack::stack_detail::get_as_upvalues_using_function<Function*>(L, index);
+				Function* fx = udata.first;
+				return fx;
+#else
+				(void)L;
+				(void)index;
+				(void)tracking;
+				static_assert(meta::meta_detail::always_true<Function>::value,
+#if SOL_IS_DEFAULT_OFF(SOL_GET_FUNCTION_POINTER_UNSAFE)
+				     "You are attempting to retrieve a function pointer type. "
+				     "This is inherently unsafe in sol2. In order to do this, you must turn on the "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE configuration macro, as detailed in the documentation. "
+				     "Please be careful!"
+#else
+				     "You are attempting to retrieve a function pointer type. "
+				     "You explicitly turned off the ability to do this by defining "
+				     "SOL_GET_FUNCTION_POINTER_UNSAFE or similar to be off. "
+				     "Please reconsider this!"
+#endif
+				);
+				return nullptr;
+#endif
+			}
+		} // namespace stack_detail
+	}      // namespace stack
+} // namespace sol
+
+// end of sol/function_types.hpp
+
+// beginning of sol/dump_handler.hpp
+
+#include <cstdint>
+#include <exception>
+
+namespace sol {
+
+	class dump_error : public error {
+	private:
+		int m_ec;
+
+	public:
+		dump_error(int error_code_) : error("dump returned non-zero error of " + std::to_string(error_code_)), m_ec(error_code_) {
+		}
+
+		int error_code() const {
+			return m_ec;
+		}
+	};
+
+	inline int dump_pass_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return result_code;
+	}
+
+	inline int dump_panic_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		return luaL_error(L_, "a non-zero error code (%d) was returned by the lua_Writer for the dump function", result_code);
+	}
+
+	inline int dump_throw_on_error(lua_State* L_, int result_code, lua_Writer writer_function, void* userdata_pointer_, bool strip) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return dump_panic_on_error(L_, result_code, writer_function, userdata_pointer_, strip);
+#else
+		(void)L_;
+		(void)writer_function;
+		(void)userdata_pointer_;
+		(void)strip;
+		throw dump_error(result_code);
+#endif // no exceptions stuff
+	}
+
+} // namespace sol
+
+// end of sol/dump_handler.hpp
+
+#include <cstdint>
+
+namespace sol {
+	template <typename ref_t, bool aligned = false>
+	class basic_function : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
+			lua_call(lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount));
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<std::tuple<Ret...>>::value);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret, meta::enable<meta::neg<std::is_void<Ret>>> = meta::enabler>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, lua_size<Ret>::value);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
+			luacall(n, 0);
+		}
+
+		unsafe_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
+			int stacksize = lua_gettop(lua_state());
+			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			return unsafe_function_result(lua_state(), firstreturn, returncount);
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_function(const basic_function&) = default;
+		basic_function& operator=(const basic_function&) = default;
+		basic_function(basic_function&&) = default;
+		basic_function& operator=(basic_function&&) = default;
+		basic_function(const stack_reference& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(stack_reference&& r) : basic_function(r.lua_state(), r.stack_index()) {
+		}
+		basic_function(lua_nil_t n) : base_t(n) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_function(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_function>(L, index, handler);
+#endif // Safety
+		}
+		basic_function(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata, bool strip = false) const {
+			return dump(writer, userdata, strip, &dump_throw_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_panic_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		unsafe_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if (!aligned) {
+				base_t::push();
+			}
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), static_cast<std::ptrdiff_t>(pushcount));
+		}
+	};
+} // namespace sol
+
+// end of sol/unsafe_function.hpp
+
+// beginning of sol/protected_function.hpp
+
+// beginning of sol/protected_handler.hpp
+
+#include <cstdint>
+
+namespace sol { namespace detail {
+	inline const char (&default_handler_name())[9] {
+		static const char name[9] = "sol.\xF0\x9F\x94\xA9";
+		return name;
+	}
+
+	template <bool ShouldPush, typename Target = reference>
+	struct protected_handler {
+		lua_State* m_L;
+		const Target& target;
+		int stack_index;
+
+		protected_handler(std::false_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = lua_gettop(L_) + 1;
+				target.push(L_);
+			}
+		}
+
+		protected_handler(std::true_type, lua_State* L_, const Target& target_) : m_L(L_), target(target_), stack_index(0) {
+			if (ShouldPush) {
+				stack_index = target.stack_index();
+			}
+		}
+
+		protected_handler(lua_State* L_, const Target& target_) : protected_handler(meta::boolean<is_stack_based_v<Target>>(), L_, target_) {
+		}
+
+		bool valid() const noexcept {
+			return ShouldPush;
+		}
+
+		~protected_handler() {
+			if constexpr (!is_stack_based_v<Target>) {
+				if (stack_index != 0) {
+					lua_remove(m_L, stack_index);
+				}
+			}
+		}
+	};
+
+	template <typename Base, typename T>
+	inline basic_function<Base> force_cast(T& p) {
+		return p;
+	}
+
+	template <typename Reference, bool IsMainReference = false>
+	inline Reference get_default_handler(lua_State* L_) {
+		if (is_stack_based_v<Reference> || L_ == nullptr)
+			return Reference(L_, lua_nil);
+		L_ = IsMainReference ? main_thread(L_, L_) : L_;
+		lua_getglobal(L_, default_handler_name());
+		auto pp = stack::pop_n(L_, 1);
+		return Reference(L_, -1);
+	}
+
+	template <typename T>
+	inline void set_default_handler(lua_State* L, const T& ref) {
+		if (L == nullptr) {
+			return;
+		}
+		if (!ref.valid()) {
+#if SOL_IS_ON(SOL_SAFE_STACK_CHECK)
+			luaL_checkstack(L, 1, detail::not_enough_stack_space_generic);
+#endif // make sure stack doesn't overflow
+			lua_pushnil(L);
+			lua_setglobal(L, default_handler_name());
+		}
+		else {
+			ref.push(L);
+			lua_setglobal(L, default_handler_name());
+		}
+	}
+}} // namespace sol::detail
+
+// end of sol/protected_handler.hpp
+
+#include <cstdint>
+#include <algorithm>
+
+namespace sol {
+
+	namespace detail {
+		template <bool ShouldPush_, typename Handler_>
+		inline void handle_protected_exception(
+		     lua_State* L_, optional<const std::exception&> maybe_ex, const char* error, detail::protected_handler<ShouldPush_, Handler_>& handler_) {
+			handler_.stack_index = 0;
+			if (ShouldPush_) {
+				handler_.target.push(L_);
+				detail::call_exception_handler(L_, maybe_ex, error);
+				lua_call(L_, 1, 1);
+			}
+			else {
+				detail::call_exception_handler(L_, maybe_ex, error);
+			}
+		}
+	} // namespace detail
+
+	template <typename Reference, bool Aligned = false, typename Handler = reference>
+	class basic_protected_function : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = Handler;
+		inline static constexpr bool is_stack_handler_v = is_stack_based_v<handler_t>;
+
+		basic_protected_function(std::true_type, const basic_protected_function& other_) noexcept
+		: base_t(other_), m_error_handler(other_.m_error_handler.copy(lua_state())) {
+		}
+
+		basic_protected_function(std::false_type, const basic_protected_function& other_) noexcept : base_t(other_), m_error_handler(other_.m_error_handler) {
+		}
+
+	public:
+		basic_protected_function() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)), m_error_handler(get_default_handler(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_protected_function>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_protected_function(const basic_protected_function& other_) noexcept
+		: basic_protected_function(meta::boolean<is_stateless_lua_reference_v<Handler>>(), other_) {
+		}
+		basic_protected_function& operator=(const basic_protected_function& other_) {
+			base_t::operator=(other_);
+			if constexpr (is_stateless_lua_reference_v<Handler>) {
+				m_error_handler.copy_assign(lua_state(), other_.m_error_handler);
+			}
+			else {
+				m_error_handler = other_.m_error_handler;
+			}
+			return *this;
+		}
+		basic_protected_function(basic_protected_function&&) = default;
+		basic_protected_function& operator=(basic_protected_function&&) = default;
+		basic_protected_function(const basic_function<base_t>& b) : basic_protected_function(b, get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(basic_function<base_t>&& b) : basic_protected_function(std::move(b), get_default_handler(b.lua_state())) {
+		}
+		basic_protected_function(const basic_function<base_t>& b, handler_t eh) : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(basic_function<base_t>&& b, handler_t eh) : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_protected_function(const stack_reference& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(stack_reference&& r) : basic_protected_function(r.lua_state(), r.stack_index(), get_default_handler(r.lua_state())) {
+		}
+		basic_protected_function(const stack_reference& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_protected_function(stack_reference&& r, handler_t eh) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_protected_function(const proxy_base<Super>& p) : basic_protected_function(p, get_default_handler(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_protected_function(proxy_base<Super>&& p) : basic_protected_function(std::move(p), get_default_handler(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_protected_function(Proxy&& p, HandlerReference&& eh)
+		: basic_protected_function(detail::force_cast<base_t>(p), make_reference<handler_t>(p.lua_state(), std::forward<HandlerReference>(eh))) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r) : basic_protected_function(L_, std::forward<T>(r), get_default_handler(L_)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_protected_function(lua_State* L_, T&& r, handler_t eh) : base_t(L_, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_protected_function(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_protected_function(lua_State* L_, int index_ = -1) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, int index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, absolute_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, raw_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, raw_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(L_, index_, handler);
+#endif // Safety
+		}
+		basic_protected_function(lua_State* L_, ref_index index_) : basic_protected_function(L_, index_, get_default_handler(L_)) {
+		}
+		basic_protected_function(lua_State* L_, ref_index index_, handler_t eh) : base_t(L_, index_), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_protected_function>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		using base_t::lua_state;
+
+		template <typename Fx>
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip, Fx&& on_error) const {
+			this->push();
+			auto ppn = stack::push_popper_n<false>(this->lua_state(), 1);
+			int r = lua_dump(this->lua_state(), writer, userdata_pointer_, strip ? 1 : 0);
+			if (r != 0) {
+				return on_error(this->lua_state(), r, writer, userdata_pointer_, strip);
+			}
+			return r;
+		}
+
+		int dump(lua_Writer writer, void* userdata_pointer_, bool strip = false) const {
+			return dump(writer, userdata_pointer_, strip, &dump_pass_on_error);
+		}
+
+		template <typename Container = bytecode>
+		Container dump() const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, &dump_throw_on_error);
+			return bc;
+		}
+
+		template <typename Container = bytecode, typename Fx>
+		Container dump(Fx&& on_error) const {
+			Container bc;
+			(void)dump(static_cast<lua_Writer>(&basic_insert_dump_writer<Container>), static_cast<void*>(&bc), false, std::forward<Fx>(on_error));
+			return bc;
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) const {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) const {
+			if constexpr (!Aligned) {
+				// we do not expect the function to already be on the stack: push it
+				if (m_error_handler.valid(lua_state())) {
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					base_t::push();
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+			else {
+				// the function is already on the stack at the right location
+				if (m_error_handler.valid()) {
+					// the handler will be pushed onto the stack manually,
+					// since it's not already on the stack this means we need to push our own
+					// function on the stack too and swap things to be in-place
+					if constexpr (!is_stack_handler_v) {
+						// so, we need to remove the function at the top and then dump the handler out ourselves
+						base_t::push();
+					}
+					detail::protected_handler<true, handler_t> h(lua_state(), m_error_handler);
+					if constexpr (!is_stack_handler_v) {
+						lua_replace(lua_state(), -3);
+						h.stack_index = lua_absindex(lua_state(), -2);
+					}
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+				else {
+					detail::protected_handler<false, handler_t> h(lua_state(), m_error_handler);
+					int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+					return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
+				}
+			}
+		}
+
+		~basic_protected_function() {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				this->m_error_handler.reset(lua_state());
+			}
+		}
+
+		static handler_t get_default_handler(lua_State* L_) {
+			return detail::get_default_handler<handler_t, is_main_threaded_v<base_t>>(L_);
+		}
+
+		template <typename T>
+		static void set_default_handler(const T& ref) {
+			detail::set_default_handler(ref.lua_state(), ref);
+		}
+
+		auto get_error_handler() const noexcept {
+			if constexpr (is_stateless_lua_reference_v<handler_t>) {
+				if constexpr (is_stack_based_v<handler_t>) {
+					return stack_reference(lua_state(), m_error_handler.stack_index());
+				}
+				else {
+					return basic_reference<is_main_threaded_v<base_t>>(lua_state(), ref_index(m_error_handler.registry_index()));
+				}
+			}
+			else {
+				return m_error_handler;
+			}
+		}
+
+		template <typename ErrorHandler_>
+		void set_error_handler(ErrorHandler_&& error_handler_) noexcept {
+			static_assert(!is_stack_based_v<handler_t> || is_stack_based_v<ErrorHandler_>,
+			     "A stack-based error handler can only be set from a parameter that is also stack-based.");
+			if constexpr (std::is_rvalue_reference_v<ErrorHandler_>) {
+				m_error_handler = std::forward<ErrorHandler_>(error_handler_);
+			}
+			else {
+				m_error_handler.copy_assign(lua_state(), std::forward<ErrorHandler_>(error_handler_));
+			}
+		}
+
+		void abandon () noexcept {
+			this->m_error_handler.abandon();
+			base_t::abandon();
+		}
+
+	private:
+		handler_t m_error_handler;
+
+		template <bool b>
+		call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t result_count_, detail::protected_handler<b, handler_t>& h) const {
+			return static_cast<call_status>(lua_pcall(lua_state(), static_cast<int>(argcount), static_cast<int>(result_count_), h.stack_index));
+		}
+
+		template <std::size_t... I, bool b, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, sizeof...(Ret), h);
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, bool b, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 1, h);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I, bool b>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			luacall(n, 0, h);
+		}
+
+		template <bool b>
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::protected_handler<b, handler_t>& h) const {
+			int stacksize = lua_gettop(lua_state());
+			int poststacksize = stacksize;
+			int firstreturn = 1;
+			int returncount = 0;
+			call_status code = call_status::ok;
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			try {
+#endif // No Exceptions
+				firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid() && !is_stack_handler_v)));
+				code = luacall(n, LUA_MULTRET, h);
+				poststacksize = lua_gettop(lua_state()) - static_cast<int>(h.valid() && !is_stack_handler_v);
+				returncount = poststacksize - (firstreturn - 1);
+#if SOL_IS_ON(SOL_EXCEPTIONS) && SOL_IS_OFF(SOL_PROPAGATE_EXCEPTIONS)
+			}
+			// Handle C++ errors thrown from C++ functions bound inside of lua
+			catch (const char* error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::string& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), error.c_str(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+			catch (const std::exception& error) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(error), error.what(), h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#if SOL_IS_ON(SOL_EXCEPTIONS_CATCH_ALL)
+			// LuaJIT cannot have the catchall when the safe propagation is on
+			// but LuaJIT will swallow all C++ errors
+			// if we don't at least catch std::exception ones
+			catch (...) {
+				detail::handle_protected_exception(lua_state(), optional<const std::exception&>(nullopt), detail::protected_function_error, h);
+				firstreturn = lua_gettop(lua_state());
+				return protected_function_result(lua_state(), firstreturn, 0, 1, call_status::runtime);
+			}
+#endif // Always catch edge case
+#else
+			// do not handle exceptions: they can be propogated into C++ and keep all type information / rich information
+#endif // Exceptions vs. No Exceptions
+			return protected_function_result(lua_state(), firstreturn, returncount, returncount, code);
+		}
+	};
+} // namespace sol
+
+// end of sol/protected_function.hpp
+
+#include <functional>
+
+namespace sol {
+	template <typename... Ret, typename... Args>
+	decltype(auto) stack_proxy::call(Args&&... args) {
+		stack_function sf(this->lua_state(), this->stack_index());
+		return sf.template call<Ret...>(std::forward<Args>(args)...);
+	}
+
+	inline protected_function_result::protected_function_result(unsafe_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()), popcount(o.return_count()), err(o.status()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+
+	inline protected_function_result& protected_function_result::operator=(unsafe_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		popcount = o.return_count();
+		err = o.status();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	inline unsafe_function_result::unsafe_function_result(protected_function_result&& o) noexcept
+	: L(o.lua_state()), index(o.stack_index()), returncount(o.return_count()) {
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+	}
+	inline unsafe_function_result& unsafe_function_result::operator=(protected_function_result&& o) noexcept {
+		L = o.lua_state();
+		index = o.stack_index();
+		returncount = o.return_count();
+		// Must be manual, otherwise destructor will screw us
+		// return count being 0 is enough to keep things clean
+		// but we will be thorough
+		o.abandon();
+		return *this;
+	}
+
+	namespace detail {
+		template <typename... R>
+		struct std_shim {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			meta::return_type_t<R...> operator()(Args&&... args) {
+				return lua_func_.call<R...>(std::forward<Args>(args)...);
+			}
+		};
+
+		template <>
+		struct std_shim<void> {
+			unsafe_function lua_func_;
+
+			std_shim(unsafe_function lua_func) : lua_func_(std::move(lua_func)) {
+			}
+
+			template <typename... Args>
+			void operator()(Args&&... args) {
+				lua_func_.call<void>(std::forward<Args>(args)...);
+			}
+		};
+	} // namespace detail
+
+	namespace stack {
+		template <typename Signature>
+		struct unqualified_getter<std::function<Signature>> {
+			typedef meta::bind_traits<Signature> fx_t;
+			typedef typename fx_t::args_list args_lists;
+			typedef meta::tuple_types<typename fx_t::return_type> return_types;
+
+			template <typename... R>
+			static std::function<Signature> get_std_func(types<R...>, lua_State* L, int index) {
+				detail::std_shim<R...> fx(unsafe_function(L, index));
+				return fx;
+			}
+
+			static std::function<Signature> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				type t = type_of(L, index);
+				if (t == type::none || t == type::lua_nil) {
+					return nullptr;
+				}
+				return get_std_func(return_types(), L, index);
+			}
+		};
+
+		template <typename Allocator>
+		struct unqualified_getter<basic_bytecode<Allocator>> {
+			static basic_bytecode<Allocator> get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				stack_function sf(L, index);
+				return sf.dump(&dump_panic_on_error);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/function.hpp
+
+// beginning of sol/usertype.hpp
+
+// beginning of sol/usertype_core.hpp
+
+// beginning of sol/deprecate.hpp
+
+#ifndef SOL_DEPRECATED
+#ifdef _MSC_VER
+#define SOL_DEPRECATED __declspec(deprecated)
+#elif __GNUC__
+#define SOL_DEPRECATED __attribute__((deprecated))
+#else
+#define SOL_DEPRECATED [[deprecated]]
+#endif // compilers
+#endif // SOL_DEPRECATED
+
+namespace sol { namespace detail {
+	template <typename T>
+	struct SOL_DEPRECATED deprecate_type {
+		using type = T;
+	};
+}} // namespace sol::detail
+
+// end of sol/deprecate.hpp
+
+// beginning of sol/usertype_container_launch.hpp
+
+// beginning of sol/usertype_container.hpp
+
+namespace sol {
+
+	template <typename T>
+	struct usertype_container;
+
+	namespace container_detail {
+
+		template <typename T>
+		struct has_clear_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::clear));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_empty_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::empty));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_after_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(
+			     decltype(std::declval<C>().erase_after(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T, typename = void>
+		struct has_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_find_test<T, std::enable_if_t<meta::is_lookup<T>::value>> {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::key_type>>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::iterator>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_erase_key_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(std::declval<C>().erase(std::declval<typename C::key_type>()))*);
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_find_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::find));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_of_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_of));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_insert_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::insert));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_erase_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::erase));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_index_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::index_get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_set_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::set));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_get_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::get));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_at_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::at));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_pairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::pairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_ipairs_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::ipairs));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_next_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::next));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_add_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::add));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		struct has_traits_size_test {
+		private:
+			template <typename C>
+			static meta::sfinae_yes_t test(decltype(&C::size));
+			template <typename C>
+			static meta::sfinae_no_t test(...);
+
+		public:
+			static constexpr bool value = std::is_same_v<decltype(test<T>(0)), meta::sfinae_yes_t>;
+		};
+
+		template <typename T>
+		using has_clear = meta::boolean<has_clear_test<T>::value>;
+
+		template <typename T>
+		using has_empty = meta::boolean<has_empty_test<T>::value>;
+
+		template <typename T>
+		using has_find = meta::boolean<has_find_test<T>::value>;
+
+		template <typename T>
+		using has_erase = meta::boolean<has_erase_test<T>::value>;
+
+		template <typename T>
+		using has_erase_key = meta::boolean<has_erase_key_test<T>::value>;
+
+		template <typename T>
+		using has_erase_after = meta::boolean<has_erase_after_test<T>::value>;
+
+		template <typename T>
+		using has_traits_get = meta::boolean<has_traits_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_at = meta::boolean<has_traits_at_test<T>::value>;
+
+		template <typename T>
+		using has_traits_set = meta::boolean<has_traits_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_get = meta::boolean<has_traits_index_get_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_set = meta::boolean<has_traits_index_set_test<T>::value>;
+
+		template <typename T>
+		using has_traits_pairs = meta::boolean<has_traits_pairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_ipairs = meta::boolean<has_traits_ipairs_test<T>::value>;
+
+		template <typename T>
+		using has_traits_next = meta::boolean<has_traits_next_test<T>::value>;
+
+		template <typename T>
+		using has_traits_add = meta::boolean<has_traits_add_test<T>::value>;
+
+		template <typename T>
+		using has_traits_size = meta::boolean<has_traits_size_test<T>::value>;
+
+		template <typename T>
+		using has_traits_clear = has_clear<T>;
+
+		template <typename T>
+		using has_traits_empty = has_empty<T>;
+
+		template <typename T>
+		using has_traits_find = meta::boolean<has_traits_find_test<T>::value>;
+
+		template <typename T>
+		using has_traits_index_of = meta::boolean<has_traits_index_of_test<T>::value>;
+
+		template <typename T>
+		using has_traits_insert = meta::boolean<has_traits_insert_test<T>::value>;
+
+		template <typename T>
+		using has_traits_erase = meta::boolean<has_traits_erase_test<T>::value>;
+
+		template <typename T>
+		struct is_forced_container : is_container<T> { };
+
+		template <typename T>
+		struct is_forced_container<as_container_t<T>> : std::true_type { };
+
+		template <typename T>
+		struct container_decay {
+			typedef T type;
+		};
+
+		template <typename T>
+		struct container_decay<as_container_t<T>> {
+			typedef T type;
+		};
+
+		template <typename T>
+		using container_decay_t = typename container_decay<meta::unqualified_t<T>>::type;
+
+		template <typename T>
+		decltype(auto) get_key(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_key(std::true_type, T&& t) {
+			return t.first;
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::false_type, T&& t) {
+			return std::forward<T>(t);
+		}
+
+		template <typename T>
+		decltype(auto) get_value(std::true_type, T&& t) {
+			return t.second;
+		}
+
+		template <typename X, typename = void>
+		struct usertype_container_default {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+
+		public:
+			typedef lua_nil_t iterator;
+			typedef lua_nil_t value_type;
+
+			static int at(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'at(index)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'get(key)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_get(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'container[key]' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int set(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'set(key, value)' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_set(lua_State* L_) {
+				return luaL_error(
+				     L_, "sol: cannot call 'container[key] = value' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int find(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int index_of(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'index_of' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int size(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int empty(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'empty' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int next(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'next' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int pairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__pairs/pairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static int ipairs(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call '__ipairs' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+			}
+
+			static iterator begin(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'being' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+
+			static iterator end(lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call 'end' on type '%s': it is not recognized as a container", detail::demangle<T>().c_str());
+				return lua_nil;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X,
+		     std::enable_if_t<meta::all<is_forced_container<meta::unqualified_t<X>>, meta::has_value_type<meta::unqualified_t<container_decay_t<X>>>,
+		          meta::has_iterator<meta::unqualified_t<container_decay_t<X>>>>::value>> {
+		private:
+			using T = std::remove_pointer_t<meta::unwrap_unqualified_t<container_decay_t<X>>>;
+
+		private:
+			using deferred_uc = usertype_container<X>;
+			using is_associative = meta::is_associative<T>;
+			using is_lookup = meta::is_lookup<T>;
+			using is_ordered = meta::is_ordered<T>;
+			using is_matched_lookup = meta::is_matched_lookup<T>;
+			using iterator = typename T::iterator;
+			using value_type = typename T::value_type;
+			typedef meta::conditional_t<is_matched_lookup::value, std::pair<value_type, value_type>,
+			     meta::conditional_t<is_associative::value || is_lookup::value, value_type, std::pair<std::ptrdiff_t, value_type>>>
+			     KV;
+			typedef typename KV::first_type K;
+			typedef typename KV::second_type V;
+			typedef meta::conditional_t<is_matched_lookup::value, std::ptrdiff_t, K> next_K;
+			typedef decltype(*std::declval<iterator&>()) iterator_return;
+			typedef meta::conditional_t<is_associative::value || is_matched_lookup::value, std::add_lvalue_reference_t<V>,
+			     meta::conditional_t<is_lookup::value, V, iterator_return>>
+			     captured_type;
+			typedef typename meta::iterator_tag<iterator>::type iterator_category;
+			typedef std::is_same<iterator_category, std::input_iterator_tag> is_input_iterator;
+			typedef meta::conditional_t<is_input_iterator::value, V, decltype(detail::deref_move_only(std::declval<captured_type>()))> push_type;
+			typedef std::is_copy_assignable<V> is_copyable;
+			typedef meta::neg<meta::any<std::is_const<V>, std::is_const<std::remove_reference_t<iterator_return>>, meta::neg<is_copyable>>> is_writable;
+			typedef meta::unqualified_t<decltype(get_key(is_associative(), std::declval<std::add_lvalue_reference_t<value_type>>()))> key_type;
+			typedef meta::all<std::is_integral<K>, meta::neg<meta::any<is_associative, is_lookup>>> is_linear_integral;
+
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+				std::size_t index;
+
+				iter(lua_State* L_, int stack_index, T& source_, iterator it_) : keep_alive(sol::main_thread(L_, L_), stack_index), source(source_), it(std::move(it_)), index(0) {
+				}
+
+				~iter() {
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+				return *p.value();
+#else
+				return stack::unqualified_get<T>(L_, 1);
+#endif // Safe getting with error
+			}
+
+			static detail::error_result at_category(std::input_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (pos > 0) {
+					--pos;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_category(std::random_access_iterator_tag, lua_State* L_, T& self, std::ptrdiff_t pos) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				pos += deferred_uc::index_adjustment(L_, self);
+				if (pos < 0 || pos >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), pos);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result at_start(lua_State* L_, T& self, std::ptrdiff_t pos) {
+				return at_category(iterator_category(), L_, self, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::true_type, lua_State* L_, Iter& it) {
+				decltype(auto) v = *it;
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(v.second));
+			}
+
+			template <typename Iter>
+			static detail::error_result get_associative(std::false_type, lua_State* L_, Iter& it) {
+				return stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+			}
+
+			static detail::error_result get_category(std::input_iterator_tag, lua_State* L_, T& self, K& key) {
+				key = static_cast<K>(key + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				while (key > 0) {
+					--key;
+					++it;
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_category(std::random_access_iterator_tag, lua_State* L_, T& self, K& key) {
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0 || key >= len) {
+					return stack::push(L_, lua_nil);
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_it(std::true_type, lua_State* L_, T& self, K& key) {
+				return get_category(iterator_category(), L_, self, key);
+			}
+
+			static detail::error_result get_comparative(std::true_type, lua_State* L_, T& self, K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return stack::push(L_, lua_nil);
+				}
+				return get_associative(is_associative(), L_, it);
+			}
+
+			static detail::error_result get_comparative(std::false_type, lua_State*, T&, K&) {
+				return detail::error_result("cannot get this key on '%s': no suitable way to increment iterator and compare to key value '%s'",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			static detail::error_result get_it(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_comparative(meta::supports_op_equal<K, key_type>(), L_, self, key);
+			}
+
+			static detail::error_result set_associative(std::true_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v.second = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_associative(std::false_type, iterator& it, stack_object value) {
+				decltype(auto) v = *it;
+				v = value.as<V>();
+				return {};
+			}
+
+			static detail::error_result set_writable(std::true_type, lua_State*, T&, iterator& it, stack_object value) {
+				return set_associative(is_associative(), it, std::move(value));
+			}
+
+			static detail::error_result set_writable(std::false_type, lua_State*, T&, iterator&, stack_object) {
+				return detail::error_result(
+				     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+			}
+
+			static detail::error_result set_category(std::input_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				auto e = deferred_uc::end(L_, self);
+				auto it = deferred_uc::begin(L_, self);
+				auto backit = it;
+				for (; key > 0 && it != e; --key, ++it) {
+					backit = it;
+				}
+				if (it == e) {
+					if (key == 0) {
+						return add_copyable(is_copyable(), L_, self, std::move(value), meta::has_insert_after<T>::value ? backit : it);
+					}
+					return detail::error_result("out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_category(std::random_access_iterator_tag, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				if (key < 0) {
+					return detail::error_result("sol: out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				std::ptrdiff_t len = static_cast<std::ptrdiff_t>(size_start(L_, self));
+				if (key == len) {
+					return add_copyable(is_copyable(), L_, self, std::move(value));
+				}
+				else if (key >= len) {
+					return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				auto it = std::next(deferred_uc::begin(L_, self), key);
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				if (!is_writable::value) {
+					return detail::error_result(
+					     "cannot perform a 'set': '%s's iterator reference is not writable (non-copy-assignable or const)", detail::demangle<T>().data());
+				}
+				auto fx = [&](const value_type& r) -> bool { return key == get_key(is_associative(), r); };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_comparative(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot set this value on '%s': no suitable way to increment iterator or compare to '%s' key",
+				     detail::demangle<T>().data(),
+				     detail::demangle<K>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::true_type, lua_State*, T& self, Iter& it, K& key, stack_object value) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, value_type(key, value.as<V>()));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key, value.as<V>()));
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			template <typename Iter>
+			static detail::error_result set_associative_insert(std::false_type, lua_State*, T& self, Iter& it, K& key, stack_object) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(it, key);
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(key);
+					return {};
+				}
+				else {
+					(void)self;
+					(void)it;
+					(void)key;
+					return detail::error_result(
+					     "cannot call 'set' on '%s': there is no 'insert' function on this non-associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result set_associative_find(std::true_type, lua_State* L_, T& self, stack_object okey, stack_object value) {
+				decltype(auto) key = okey.as<K>();
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					return set_associative_insert(is_associative(), L_, self, it, key, std::move(value));
+				}
+				return set_writable(is_writable(), L_, self, it, std::move(value));
+			}
+
+			static detail::error_result set_associative_find(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_comparative(meta::supports_op_equal<K, key_type>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_category(iterator_category(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result set_it(std::false_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_associative_find(meta::all<has_find<T>, meta::any<is_associative, is_lookup>>(), L_, self, std::move(key), std::move(value));
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::true_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					auto it = self.find(key);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has_associative_lookup(std::false_type, lua_State* L_, T& self) {
+				if constexpr (!is_ordered::value && idx_of) {
+					(void)L_;
+					(void)self;
+					return detail::error_result("cannot perform an 'index_of': '%s's is not an ordered container", detail::demangle<T>().data());
+				}
+				else {
+					decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+					auto it = self.find(value);
+					if (it == deferred_uc::end(L_, self)) {
+						return stack::push(L_, lua_nil);
+					}
+					if constexpr (idx_of) {
+						auto dist = std::distance(deferred_uc::begin(L_, self), it);
+						dist -= deferred_uc::index_adjustment(L_, self);
+						return stack::push(L_, dist);
+					}
+					else {
+						return get_associative(is_associative(), L_, it);
+					}
+				}
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::true_type, lua_State* L_, T& self) {
+				return find_has_associative_lookup<idx_of>(meta::any<is_lookup, is_associative>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::true_type, lua_State* L_, T&, Iter& it, std::size_t) {
+				return get_associative(is_associative(), L_, it);
+			}
+
+			template <typename Iter>
+			static detail::error_result find_associative_lookup(std::false_type, lua_State* L_, T& self, Iter&, std::size_t idx) {
+				idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+				return stack::push(L_, idx);
+			}
+
+			template <bool = false>
+			static detail::error_result find_comparative(std::false_type, lua_State*, T&) {
+				return detail::error_result("cannot call 'find' on '%s': there is no 'find' function and the value_type is not equality comparable",
+				     detail::demangle<T>().c_str());
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_comparative(std::true_type, lua_State* L_, T& self) {
+				decltype(auto) value = stack::unqualified_get<V>(L_, 2);
+				auto it = deferred_uc::begin(L_, self);
+				auto e = deferred_uc::end(L_, self);
+				std::size_t idx = 0;
+				for (;; ++it, ++idx) {
+					if (it == e) {
+						return stack::push(L_, lua_nil);
+					}
+					if (value == get_value(is_associative(), *it)) {
+						break;
+					}
+				}
+				return find_associative_lookup(meta::all<meta::boolean<!idx_of>, meta::any<is_lookup, is_associative>>(), L_, self, it, idx);
+			}
+
+			template <bool idx_of = false>
+			static detail::error_result find_has(std::false_type, lua_State* L_, T& self) {
+				return find_comparative<idx_of>(meta::supports_op_equal<V>(), L_, self);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_insert_after(std::false_type(), L_, self, value);
+			}
+
+			static detail::error_result add_insert_after(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on type '%s': no suitable insert/push_back C++ functions", detail::demangle<T>().data());
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert_after(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert_after(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert_after(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto backit = self.before_begin();
+				{
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); it != e; ++backit, ++it) { }
+				}
+				return add_insert_after(std::true_type(), L_, self, value, backit);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::true_type, lua_State*, T& self, stack_object value, Iter& pos) {
+				self.insert(pos, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_insert(std::true_type, lua_State* L_, T& self, stack_object value) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_insert(std::true_type(), L_, self, value, pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_insert(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert_after(meta::has_insert_after<T>(), L_, self, std::move(value));
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value, Iter&) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			static detail::error_result add_push_back(std::true_type, lua_State*, T& self, stack_object value) {
+				self.push_back(value.as<V>());
+				return {};
+			}
+
+			template <typename Iter>
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value, pos);
+			}
+
+			static detail::error_result add_push_back(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_insert(
+				     std::integral_constant < bool, meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key, Iter& pos) {
+				if constexpr (meta::has_insert_with_iterator<T>::value) {
+					self.insert(pos, value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else if constexpr (meta::has_insert<T>::value) {
+					self.insert(value_type(key.as<K>(), stack::unqualified_get<V>(L_, 3)));
+					return {};
+				}
+				else {
+					(void)L_;
+					(void)self;
+					(void)key;
+					(void)pos;
+					return detail::error_result(
+					     "cannot call 'insert' on '%s': there is no 'insert' function on this associative type", detail::demangle<T>().c_str());
+				}
+			}
+
+			static detail::error_result add_associative(std::true_type, lua_State* L_, T& self, stack_object key) {
+				auto pos = deferred_uc::end(L_, self);
+				return add_associative(std::true_type(), L_, self, std::move(key), pos);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value, pos);
+			}
+
+			static detail::error_result add_associative(std::false_type, lua_State* L_, T& self, stack_object value) {
+				return add_push_back(meta::has_push_back<T>(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value, Iter& pos) {
+				return add_associative(is_associative(), L_, self, std::move(value), pos);
+			}
+
+			static detail::error_result add_copyable(std::true_type, lua_State* L_, T& self, stack_object value) {
+				return add_associative(is_associative(), L_, self, value);
+			}
+
+			template <typename Iter>
+			static detail::error_result add_copyable(std::false_type, lua_State* L_, T& self, stack_object value, Iter&) {
+				return add_copyable(std::false_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result add_copyable(std::false_type, lua_State*, T&, stack_object) {
+				return detail::error_result("cannot call 'add' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_lookup(std::true_type, lua_State* L_, T& self, stack_object, stack_object value) {
+				// TODO: should we warn or error about someone calling insert on an ordered / lookup container with no associativity?
+				return add_copyable(std::true_type(), L_, self, std::move(value));
+			}
+
+			static detail::error_result insert_lookup(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto it = deferred_uc::begin(L_, self);
+				auto key = where.as<K>();
+				key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.insert(it, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::true_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				auto key = where.as<K>();
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.insert_after(backit, value.as<V>());
+				return {};
+			}
+
+			static detail::error_result insert_after_has(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result(
+				     "cannot call 'insert' on '%s': no suitable or similar functionality detected on this container", detail::demangle<T>().data());
+			}
+
+			static detail::error_result insert_has(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_lookup(meta::any<is_associative, is_lookup>(), L_, self, std::move(key), std::move(value));
+			}
+
+			static detail::error_result insert_has(std::false_type, lua_State* L_, T& self, stack_object where, stack_object value) {
+				return insert_after_has(meta::has_insert_after<T>(), L_, self, where, value);
+			}
+
+			static detail::error_result insert_copyable(std::true_type, lua_State* L_, T& self, stack_object key, stack_object value) {
+				return insert_has(std::integral_constant < bool,
+				     meta::has_insert<T>::value || meta::has_insert_with_iterator<T>::value > (),
+				     L_,
+				     self,
+				     std::move(key),
+				     std::move(value));
+			}
+
+			static detail::error_result insert_copyable(std::false_type, lua_State*, T&, stack_object, stack_object) {
+				return detail::error_result("cannot call 'insert' on '%s': value_type is non-copyable", detail::demangle<T>().data());
+			}
+
+			static detail::error_result erase_integral(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = deferred_uc::begin(L_, self);
+				key = (static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+				std::advance(it, key);
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_integral(std::false_type, lua_State* L_, T& self, const K& key) {
+				auto fx = [&](const value_type& r) -> bool { return key == r; };
+				auto e = deferred_uc::end(L_, self);
+				auto it = std::find_if(deferred_uc::begin(L_, self), e, std::ref(fx));
+				if (it == e) {
+					return {};
+				}
+				self.erase(it);
+
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::true_type, lua_State*, T& self, const K& key) {
+				self.erase(key);
+				return {};
+			}
+
+			static detail::error_result erase_associative_lookup(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_integral(std::is_integral<K>(), L_, self, key);
+			}
+
+			static detail::error_result erase_after_has(std::true_type, lua_State* L_, T& self, K& key) {
+				auto backit = self.before_begin();
+				{
+					key = static_cast<K>(static_cast<std::ptrdiff_t>(key) + deferred_uc::index_adjustment(L_, self));
+					auto e = deferred_uc::end(L_, self);
+					for (auto it = deferred_uc::begin(L_, self); key > 0; ++backit, ++it, --key) {
+						if (backit == e) {
+							return detail::error_result("sol: out of bounds for erase on '%s'", detail::demangle<T>().c_str());
+						}
+					}
+				}
+				self.erase_after(backit);
+				return {};
+			}
+
+			static detail::error_result erase_after_has(std::false_type, lua_State*, T&, const K&) {
+				return detail::error_result("sol: cannot call erase on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static detail::error_result erase_key_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_key_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_after_has(has_erase_after<T>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::true_type, lua_State* L_, T& self, K& key) {
+				return erase_associative_lookup(meta::any<is_associative, is_lookup>(), L_, self, key);
+			}
+
+			static detail::error_result erase_has(std::false_type, lua_State* L_, T& self, K& key) {
+				return erase_key_has(has_erase_key<T>(), L_, self, key);
+			}
+
+			static auto size_has(std::false_type, lua_State* L_, T& self) {
+				return std::distance(deferred_uc::begin(L_, self), deferred_uc::end(L_, self));
+			}
+
+			static auto size_has(std::true_type, lua_State*, T& self) {
+				return self.size();
+			}
+
+			static void clear_has(std::true_type, lua_State*, T& self) {
+				self.clear();
+			}
+
+			static void clear_has(std::false_type, lua_State* L_, T&) {
+				luaL_error(L_, "sol: cannot call clear on '%s'", detail::demangle<T>().c_str());
+			}
+
+			static bool empty_has(std::true_type, lua_State*, T& self) {
+				return self.empty();
+			}
+
+			static bool empty_has(std::false_type, lua_State* L_, T& self) {
+				return deferred_uc::begin(L_, self) == deferred_uc::end(L_, self);
+			}
+
+			static detail::error_result get_associative_find(std::true_type, lua_State* L_, T& self, K& key) {
+				auto it = self.find(key);
+				if (it == deferred_uc::end(L_, self)) {
+					stack::push(L_, lua_nil);
+					return {};
+				}
+				return get_associative(std::true_type(), L_, it);
+			}
+
+			static detail::error_result get_associative_find(std::false_type, lua_State* L_, T& self, K& key) {
+				return get_it(is_linear_integral(), L_, self, key);
+			}
+
+			static detail::error_result get_start(lua_State* L_, T& self, K& key) {
+				return get_associative_find(std::integral_constant < bool, is_associative::value&& has_find<T>::value > (), L_, self, key);
+			}
+
+			static detail::error_result set_start(lua_State* L_, T& self, stack_object key, stack_object value) {
+				return set_it(is_linear_integral(), L_, self, std::move(key), std::move(value));
+			}
+
+			static std::size_t size_start(lua_State* L_, T& self) {
+				return static_cast<std::size_t>(size_has(meta::has_size<T>(), L_, self));
+			}
+
+			static void clear_start(lua_State* L_, T& self) {
+				clear_has(has_clear<T>(), L_, self);
+			}
+
+			static bool empty_start(lua_State* L_, T& self) {
+				return empty_has(has_empty<T>(), L_, self);
+			}
+
+			static detail::error_result erase_start(lua_State* L_, T& self, K& key) {
+				return erase_has(has_erase<T>(), L_, self, key);
+			}
+
+			template <bool ip>
+			static int next_associative(std::true_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (ip) {
+					++i.index;
+					p = stack::push_reference(L_, i.index);
+				}
+				else {
+					p = stack::push_reference(L_, it->first);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(it->second));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool>
+			static int next_associative(std::false_type, lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				next_K k = stack::unqualified_get<next_K>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return stack::push(L_, lua_nil);
+				}
+				int p;
+				if constexpr (std::is_integral_v<next_K>) {
+					p = stack::push_reference(L_, k + 1);
+				}
+				else {
+					p = stack::stack_detail::push_reference(L_, k + 1);
+				}
+				p += stack::stack_detail::push_reference<push_type>(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+			template <bool ip>
+			static int next_iter(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return next_associative<ip>(is_assoc(), L_);
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::true_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, lua_nil);
+				return 3;
+			}
+
+			template <bool ip>
+			static int pairs_associative(std::false_type, lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter<ip>);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+		public:
+			static int at(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					std::ptrdiff_t pos = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+					er = at_start(L_, self, pos);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int get(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_);
+					er = get_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				stack_object value = stack_object(L_, raw_index(3));
+				if constexpr (is_linear_integral::value) {
+					// for non-associative containers,
+					// erasure only happens if it is the
+					// last index in the container
+					auto key = stack::get<K>(L_, 2);
+					auto self_size = deferred_uc::size(L_);
+					if (key == static_cast<K>(self_size)) {
+						if (type_of(L_, 3) == type::lua_nil) {
+							return erase(L_);
+						}
+					}
+				}
+				else {
+					if (type_of(L_, 3) == type::lua_nil) {
+						return erase(L_);
+					}
+				}
+				auto& self = get_src(L_);
+				detail::error_result er = set_start(L_, self, stack_object(L_, raw_index(2)), std::move(value));
+				return handle_errors(L_, er);
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int add(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = add_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)));
+				return handle_errors(L_, er);
+			}
+
+			static int insert(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = insert_copyable(is_copyable(), L_, self, stack_object(L_, raw_index(2)), stack_object(L_, raw_index(3)));
+				return handle_errors(L_, er);
+			}
+
+			static int find(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static int index_of(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er = find_has<true>(has_find<T>(), L_, self);
+				return handle_errors(L_, er);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.begin();
+				}
+				else {
+					using std::begin;
+					return begin(self);
+				}
+			}
+
+			static iterator end(lua_State*, T& self) {
+				if constexpr (meta::has_begin_end_v<T>) {
+					return self.end();
+				}
+				else {
+					using std::end;
+					return end(self);
+				}
+			}
+
+			static int size(lua_State* L_) {
+				auto& self = get_src(L_);
+				std::size_t r = size_start(L_, self);
+				return stack::push(L_, r);
+			}
+
+			static int clear(lua_State* L_) {
+				auto& self = get_src(L_);
+				clear_start(L_, self);
+				return 0;
+			}
+
+			static int erase(lua_State* L_) {
+				auto& self = get_src(L_);
+				detail::error_result er;
+				{
+					decltype(auto) key = stack::unqualified_get<K>(L_, 2);
+					er = erase_start(L_, self, key);
+				}
+				return handle_errors(L_, er);
+			}
+
+			static int empty(lua_State* L_) {
+				auto& self = get_src(L_);
+				return stack::push(L_, empty_start(L_, self));
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return static_cast<std::ptrdiff_t>((SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_));
+			}
+
+			static int pairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<false>(is_assoc(), L_);
+			}
+
+			static int ipairs(lua_State* L_) {
+				typedef meta::any<is_associative, meta::all<is_lookup, meta::neg<is_matched_lookup>>> is_assoc;
+				return pairs_associative<true>(is_assoc(), L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter<false>);
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<X, std::enable_if_t<std::is_array<std::remove_pointer_t<meta::unwrap_unqualified_t<X>>>::value>> {
+		private:
+			typedef std::remove_pointer_t<meta::unwrap_unqualified_t<X>> T;
+			typedef usertype_container<X> deferred_uc;
+
+		public:
+			typedef std::remove_extent_t<T> value_type;
+			typedef value_type* iterator;
+
+		private:
+			struct iter {
+				reference keep_alive;
+				T& source;
+				iterator it;
+
+				iter(lua_State* L_, int stack_index, T& source, iterator it) noexcept
+				: keep_alive(sol::main_thread(L_, L_), stack_index), source(source), it(std::move(it)) {
+				}
+
+				~iter() {
+
+				}
+			};
+
+			static auto& get_src(lua_State* L_) {
+				auto p = stack::unqualified_check_get<T*>(L_, 1);
+#if SOL_IS_ON(SOL_SAFE_USERTYPE)
+				if (!p) {
+					luaL_error(L_,
+					     "sol: 'self' is not of type '%s' (pass 'self' as first argument with ':' or call on proper type)",
+					     detail::demangle<T>().c_str());
+				}
+				if (p.value() == nullptr) {
+					luaL_error(
+					     L_, "sol: 'self' argument is nil (pass 'self' as first argument with ':' or call on a '%s' type)", detail::demangle<T>().c_str());
+				}
+#endif // Safe getting with error
+				return *p.value();
+			}
+
+			static int find(std::true_type, lua_State* L_) {
+				T& self = get_src(L_);
+				decltype(auto) value = stack::unqualified_get<value_type>(L_, 2);
+				std::size_t N = std::extent<T>::value;
+				for (std::size_t idx = 0; idx < N; ++idx) {
+					using v_t = std::add_const_t<decltype(self[idx])>;
+					v_t v = self[idx];
+					if (v == value) {
+						idx = static_cast<std::size_t>(static_cast<std::ptrdiff_t>(idx) - deferred_uc::index_adjustment(L_, self));
+						return stack::push(L_, idx);
+					}
+				}
+				return stack::push(L_, lua_nil);
+			}
+
+			static int find(std::false_type, lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'find' on '%s': no supported comparison operator for the value type", detail::demangle<T>().c_str());
+			}
+
+			static int next_iter(lua_State* L_) {
+				iter& i = stack::unqualified_get<user<iter>>(L_, 1);
+				auto& source = i.source;
+				auto& it = i.it;
+				std::size_t k = stack::unqualified_get<std::size_t>(L_, 2);
+				if (it == deferred_uc::end(L_, source)) {
+					return 0;
+				}
+				int p;
+				p = stack::push(L_, k + 1);
+				p += stack::push_reference(L_, detail::deref_move_only(*it));
+				std::advance(it, 1);
+				return p;
+			}
+
+		public:
+			static int clear(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'clear' on type '%s': cannot remove all items from a fixed array", detail::demangle<T>().c_str());
+			}
+
+			static int erase(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'erase' on type '%s': cannot remove an item from fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int add(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'add' on type '%s': cannot add to fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int insert(lua_State* L_) {
+				return luaL_error(L_, "sol: cannot call 'insert' on type '%s': cannot insert new entries into fixed arrays", detail::demangle<T>().c_str());
+			}
+
+			static int at(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int get(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value) || idx < 0) {
+					return stack::push(L_, lua_nil);
+				}
+				return stack::push_reference(L_, detail::deref_move_only(self[idx]));
+			}
+
+			static int index_get(lua_State* L_) {
+				return get(L_);
+			}
+
+			static int set(lua_State* L_) {
+				T& self = get_src(L_);
+				std::ptrdiff_t idx = stack::unqualified_get<std::ptrdiff_t>(L_, 2);
+				idx += deferred_uc::index_adjustment(L_, self);
+				if (idx >= static_cast<std::ptrdiff_t>(std::extent<T>::value)) {
+					return luaL_error(L_, "sol: index out of bounds (too big) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				if (idx < 0) {
+					return luaL_error(L_, "sol: index out of bounds (too small) for set on '%s'", detail::demangle<T>().c_str());
+				}
+				self[idx] = stack::unqualified_get<value_type>(L_, 3);
+				return 0;
+			}
+
+			static int index_set(lua_State* L_) {
+				return set(L_);
+			}
+
+			static int index_of(lua_State* L_) {
+				return find(L_);
+			}
+
+			static int find(lua_State* L_) {
+				return find(meta::supports_op_equal<value_type, value_type>(), L_);
+			}
+
+			static int size(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value);
+			}
+
+			static int empty(lua_State* L_) {
+				return stack::push(L_, std::extent<T>::value > 0);
+			}
+
+			static int pairs(lua_State* L_) {
+				auto& src = get_src(L_);
+				stack::push(L_, next_iter);
+				stack::push<user<iter>>(L_, L_, 1, src, deferred_uc::begin(L_, src));
+				stack::push(L_, 0);
+				return 3;
+			}
+
+			static int ipairs(lua_State* L_) {
+				return pairs(L_);
+			}
+
+			static int next(lua_State* L_) {
+				return stack::push(L_, next_iter);
+			}
+
+			static std::ptrdiff_t index_adjustment(lua_State*, T&) {
+				return (SOL_CONTAINER_START_INDEX_I_) == 0 ? 0 : -(SOL_CONTAINER_START_INDEX_I_);
+			}
+
+			static iterator begin(lua_State*, T& self) {
+				return std::addressof(self[0]);
+			}
+
+			static iterator end(lua_State*, T& self) {
+				return std::addressof(self[0]) + std::extent<T>::value;
+			}
+		};
+
+		template <typename X>
+		struct usertype_container_default<usertype_container<X>> : usertype_container_default<X> { };
+	} // namespace container_detail
+
+	template <typename T>
+	struct usertype_container : container_detail::usertype_container_default<T> { };
+
+} // namespace sol
+
+// end of sol/usertype_container.hpp
+
+#include <unordered_map>
+
+namespace sol {
+
+	namespace container_detail {
+		template <typename X>
+		struct u_c_launch {
+			using T = std::remove_pointer_t<meta::unqualified_t<X>>;
+			using uc = usertype_container<T>;
+			using default_uc = usertype_container_default<T>;
+
+			static inline int real_index_get_traits(std::true_type, lua_State* L) {
+				return uc::index_get(L);
+			}
+
+			static inline int real_index_get_traits(std::false_type, lua_State* L) {
+				return default_uc::index_get(L);
+			}
+
+			static inline int real_index_call(lua_State* L) {
+				static const std::unordered_map<string_view, lua_CFunction> calls {
+					{ "at", &real_at_call },
+					{ "get", &real_get_call },
+					{ "set", &real_set_call },
+					{ "size", &real_length_call },
+					{ "add", &real_add_call },
+					{ "empty", &real_empty_call },
+					{ "insert", &real_insert_call },
+					{ "clear", &real_clear_call },
+					{ "find", &real_find_call },
+					{ "index_of", &real_index_of_call },
+					{ "erase", &real_erase_call },
+					{ "pairs", &pairs_call },
+					{ "next", &next_call },
+				};
+				auto maybenameview = stack::unqualified_check_get<string_view>(L, 2);
+				if (maybenameview) {
+					const string_view& name = *maybenameview;
+					auto it = calls.find(name);
+					if (it != calls.cend()) {
+						return stack::push(L, it->second);
+					}
+				}
+				return real_index_get_traits(container_detail::has_traits_index_get<uc>(), L);
+			}
+
+			static inline int real_at_traits(std::true_type, lua_State* L) {
+				return uc::at(L);
+			}
+
+			static inline int real_at_traits(std::false_type, lua_State* L) {
+				return default_uc::at(L);
+			}
+
+			static inline int real_at_call(lua_State* L) {
+				return real_at_traits(container_detail::has_traits_at<uc>(), L);
+			}
+
+			static inline int real_get_traits(std::true_type, lua_State* L) {
+				return uc::get(L);
+			}
+
+			static inline int real_get_traits(std::false_type, lua_State* L) {
+				return default_uc::get(L);
+			}
+
+			static inline int real_get_call(lua_State* L) {
+				return real_get_traits(container_detail::has_traits_get<uc>(), L);
+			}
+
+			static inline int real_set_traits(std::true_type, lua_State* L) {
+				return uc::set(L);
+			}
+
+			static inline int real_set_traits(std::false_type, lua_State* L) {
+				return default_uc::set(L);
+			}
+
+			static inline int real_set_call(lua_State* L) {
+				return real_set_traits(container_detail::has_traits_set<uc>(), L);
+			}
+
+			static inline int real_index_set_traits(std::true_type, lua_State* L) {
+				return uc::index_set(L);
+			}
+
+			static inline int real_index_set_traits(std::false_type, lua_State* L) {
+				return default_uc::index_set(L);
+			}
+
+			static inline int real_new_index_call(lua_State* L) {
+				return real_index_set_traits(container_detail::has_traits_index_set<uc>(), L);
+			}
+
+			static inline int real_pairs_traits(std::true_type, lua_State* L) {
+				return uc::pairs(L);
+			}
+
+			static inline int real_pairs_traits(std::false_type, lua_State* L) {
+				return default_uc::pairs(L);
+			}
+
+			static inline int real_pairs_call(lua_State* L) {
+				return real_pairs_traits(container_detail::has_traits_pairs<uc>(), L);
+			}
+
+			static inline int real_ipairs_traits(std::true_type, lua_State* L) {
+				return uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_traits(std::false_type, lua_State* L) {
+				return default_uc::ipairs(L);
+			}
+
+			static inline int real_ipairs_call(lua_State* L) {
+				return real_ipairs_traits(container_detail::has_traits_ipairs<uc>(), L);
+			}
+
+			static inline int real_next_traits(std::true_type, lua_State* L) {
+				return uc::next(L);
+			}
+
+			static inline int real_next_traits(std::false_type, lua_State* L) {
+				return default_uc::next(L);
+			}
+
+			static inline int real_next_call(lua_State* L) {
+				return real_next_traits(container_detail::has_traits_next<uc>(), L);
+			}
+
+			static inline int real_size_traits(std::true_type, lua_State* L) {
+				return uc::size(L);
+			}
+
+			static inline int real_size_traits(std::false_type, lua_State* L) {
+				return default_uc::size(L);
+			}
+
+			static inline int real_length_call(lua_State* L) {
+				return real_size_traits(container_detail::has_traits_size<uc>(), L);
+			}
+
+			static inline int real_add_traits(std::true_type, lua_State* L) {
+				return uc::add(L);
+			}
+
+			static inline int real_add_traits(std::false_type, lua_State* L) {
+				return default_uc::add(L);
+			}
+
+			static inline int real_add_call(lua_State* L) {
+				return real_add_traits(container_detail::has_traits_add<uc>(), L);
+			}
+
+			static inline int real_insert_traits(std::true_type, lua_State* L) {
+				return uc::insert(L);
+			}
+
+			static inline int real_insert_traits(std::false_type, lua_State* L) {
+				return default_uc::insert(L);
+			}
+
+			static inline int real_insert_call(lua_State* L) {
+				return real_insert_traits(container_detail::has_traits_insert<uc>(), L);
+			}
+
+			static inline int real_clear_traits(std::true_type, lua_State* L) {
+				return uc::clear(L);
+			}
+
+			static inline int real_clear_traits(std::false_type, lua_State* L) {
+				return default_uc::clear(L);
+			}
+
+			static inline int real_clear_call(lua_State* L) {
+				return real_clear_traits(container_detail::has_traits_clear<uc>(), L);
+			}
+
+			static inline int real_empty_traits(std::true_type, lua_State* L) {
+				return uc::empty(L);
+			}
+
+			static inline int real_empty_traits(std::false_type, lua_State* L) {
+				return default_uc::empty(L);
+			}
+
+			static inline int real_empty_call(lua_State* L) {
+				return real_empty_traits(container_detail::has_traits_empty<uc>(), L);
+			}
+
+			static inline int real_erase_traits(std::true_type, lua_State* L) {
+				return uc::erase(L);
+			}
+
+			static inline int real_erase_traits(std::false_type, lua_State* L) {
+				return default_uc::erase(L);
+			}
+
+			static inline int real_erase_call(lua_State* L) {
+				return real_erase_traits(container_detail::has_traits_erase<uc>(), L);
+			}
+
+			static inline int real_find_traits(std::true_type, lua_State* L) {
+				return uc::find(L);
+			}
+
+			static inline int real_find_traits(std::false_type, lua_State* L) {
+				return default_uc::find(L);
+			}
+
+			static inline int real_find_call(lua_State* L) {
+				return real_find_traits(container_detail::has_traits_find<uc>(), L);
+			}
+
+			static inline int real_index_of_call(lua_State* L) {
+				if constexpr (container_detail::has_traits_index_of<uc>()) {
+					return uc::index_of(L);
+				}
+				else {
+					return default_uc::index_of(L);
+				}
+			}
+
+			static inline int add_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_add_call), (&real_add_call)>(L);
+			}
+
+			static inline int erase_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_erase_call), (&real_erase_call)>(L);
+			}
+
+			static inline int insert_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_insert_call), (&real_insert_call)>(L);
+			}
+
+			static inline int clear_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_clear_call), (&real_clear_call)>(L);
+			}
+
+			static inline int empty_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_empty_call), (&real_empty_call)>(L);
+			}
+
+			static inline int find_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_find_call), (&real_find_call)>(L);
+			}
+
+			static inline int index_of_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_of_call), (&real_index_of_call)>(L);
+			}
+
+			static inline int length_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_length_call), (&real_length_call)>(L);
+			}
+
+			static inline int pairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_pairs_call), (&real_pairs_call)>(L);
+			}
+
+			static inline int ipairs_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_ipairs_call), (&real_ipairs_call)>(L);
+			}
+
+			static inline int next_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_next_call), (&real_next_call)>(L);
+			}
+
+			static inline int at_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_at_call), (&real_at_call)>(L);
+			}
+
+			static inline int get_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_get_call), (&real_get_call)>(L);
+			}
+
+			static inline int set_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_set_call), (&real_set_call)>(L);
+			}
+
+			static inline int index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_index_call), (&real_index_call)>(L);
+			}
+
+			static inline int new_index_call(lua_State* L) {
+				return detail::typed_static_trampoline<decltype(&real_new_index_call), (&real_new_index_call)>(L);
+			}
+		};
+	} // namespace container_detail
+
+	namespace stack {
+		namespace stack_detail {
+			template <typename T, bool is_shim = false>
+			struct metatable_setup {
+				lua_State* L;
+
+				metatable_setup(lua_State* L) : L(L) {
+				}
+
+				void operator()() {
+					using meta_usertype_container
+					     = container_detail::u_c_launch<meta::conditional_t<is_shim, as_container_t<std::remove_pointer_t<T>>, std::remove_pointer_t<T>>>;
+					static const char* metakey
+					     = is_shim ? &usertype_traits<as_container_t<std::remove_pointer_t<T>>>::metatable()[0] : &usertype_traits<T>::metatable()[0];
+					static const std::array<luaL_Reg, 20> reg = { {
+						// clang-format off
+						{ "__pairs", &meta_usertype_container::pairs_call },
+						{ "__ipairs", &meta_usertype_container::ipairs_call },
+						{ "__len", &meta_usertype_container::length_call },
+						{ "__index", &meta_usertype_container::index_call },
+						{ "__newindex", &meta_usertype_container::new_index_call },
+						{ "pairs", &meta_usertype_container::pairs_call },
+						{ "next", &meta_usertype_container::next_call },
+						{ "at", &meta_usertype_container::at_call },
+						{ "get", &meta_usertype_container::get_call },
+						{ "set", &meta_usertype_container::set_call },
+						{ "size", &meta_usertype_container::length_call },
+						{ "empty", &meta_usertype_container::empty_call },
+						{ "clear", &meta_usertype_container::clear_call },
+						{ "insert", &meta_usertype_container::insert_call },
+						{ "add", &meta_usertype_container::add_call },
+						{ "find", &meta_usertype_container::find_call },
+						{ "index_of", &meta_usertype_container::index_of_call },
+						{ "erase", &meta_usertype_container::erase_call },
+						std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destroy<T> },
+						{ nullptr, nullptr }
+						// clang-format on 
+					} };
+
+					if (luaL_newmetatable(L, metakey) == 1) {
+						luaL_setfuncs(L, reg.data(), 0);
+					}
+					lua_setmetatable(L, -2);
+				}
+			};
+		} // namespace stack_detail
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T>> {
+			using C = meta::unqualified_t<T>;
+
+			static int push_lvalue(std::true_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C*, true> fx(L);
+				return stack::push<detail::as_pointer_tag<const C>>(L, detail::with_function_tag(), fx, detail::ptr(cont));
+			}
+
+			static int push_lvalue(std::false_type, lua_State* L, const C& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, cont);
+			}
+
+			static int push_rvalue(std::true_type, lua_State* L, C&& cont) {
+				stack_detail::metatable_setup<C, true> fx(L);
+				return stack::push<detail::as_value_tag<C>>(L, detail::with_function_tag(), fx, std::move(cont));
+			}
+
+			static int push_rvalue(std::false_type, lua_State* L, const C& cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, cont);
+			}
+
+			static int push(lua_State* L, const as_container_t<T>& as_cont) {
+				return push_lvalue(std::is_lvalue_reference<T>(), L, as_cont.value());
+			}
+
+			static int push(lua_State* L, as_container_t<T>&& as_cont) {
+				return push_rvalue(meta::all<std::is_rvalue_reference<T>, meta::neg<std::is_lvalue_reference<T>>>(), L, std::forward<T>(as_cont.value()));
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<as_container_t<T*>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T, std::enable_if_t<is_container_v<T>>> {
+			using C = T;
+
+			template <typename... Args>
+			static int push(lua_State* L, Args&&... args) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_value_tag<T>>(L, detail::with_function_tag(), fx, std::forward<Args>(args)...);
+			}
+		};
+
+		template <typename T>
+		struct unqualified_pusher<T*, std::enable_if_t<is_container_v<T>>> {
+			using C = std::add_pointer_t<meta::unqualified_t<std::remove_pointer_t<T>>>;
+
+			static int push(lua_State* L, T* cont) {
+				stack_detail::metatable_setup<C> fx(L);
+				return stack::push<detail::as_pointer_tag<T>>(L, detail::with_function_tag(), fx, cont);
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/usertype_container_launch.hpp
+
+#include <sstream>
+#include <type_traits>
+
+namespace sol {
+	namespace u_detail {
+		constexpr const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
+
+		constexpr const int environment_index = 1;
+		constexpr const int usertype_storage_index = 2;
+		constexpr const int usertype_storage_base_index = 3;
+		constexpr const int exact_function_index = 4;
+		constexpr const int magic_index = 5;
+
+		constexpr const int simple_usertype_storage_index = 2;
+		constexpr const int index_function_index = 3;
+		constexpr const int new_index_function_index = 4;
+
+		constexpr const int base_walking_failed_index = -32467;
+		constexpr const int lookup_failed_index = -42469;
+
+		enum class submetatable_type {
+			// must be sequential
+			value,
+			reference,
+			unique,
+			const_reference,
+			const_value,
+			// must be LAST!
+			named
+		};
+
+		inline auto make_string_view(string_view s) {
+			return s;
+		}
+
+#if SOL_IS_ON(SOL_CHAR8_T)
+		inline auto make_string_view(const char8_t* s) {
+			return string_view(reinterpret_cast<const char*>(s));
+		}
+#endif
+
+		inline auto make_string_view(call_construction) {
+			return string_view(to_string(meta_function::call_function));
+		}
+
+		inline auto make_string_view(meta_function mf) {
+			return string_view(to_string(mf));
+		}
+
+		inline auto make_string_view(base_classes_tag) {
+			return string_view(detail::base_class_cast_key());
+		}
+
+		template <typename Arg>
+		inline std::string make_string(Arg&& arg) {
+			string_view s = make_string_view(arg);
+			return std::string(s.data(), s.size());
+		}
+
+		inline int is_indexer(string_view s) {
+			if (s == to_string(meta_function::index)) {
+				return 1;
+			}
+			else if (s == to_string(meta_function::new_index)) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(meta_function mf) {
+			if (mf == meta_function::index) {
+				return 1;
+			}
+			else if (mf == meta_function::new_index) {
+				return 2;
+			}
+			return 0;
+		}
+
+		inline int is_indexer(call_construction) {
+			return 0;
+		}
+	} // namespace u_detail
+
+	namespace detail {
+
+		template <typename T, typename IFx, typename Fx>
+		inline void insert_default_registrations(IFx&& ifx, Fx&& fx) {
+			(void)ifx;
+			(void)fx;
+			if constexpr (is_automagical<T>::value) {
+				if (fx(meta_function::less_than)) {
+					if constexpr (meta::supports_op_less<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less<>>;
+						ifx(meta_function::less_than, f);
+					}
+				}
+				if (fx(meta_function::less_than_or_equal_to)) {
+					if constexpr (meta::supports_op_less_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::less_equal<>>;
+						ifx(meta_function::less_than_or_equal_to, f);
+					}
+				}
+				if (fx(meta_function::equal_to)) {
+					if constexpr (meta::supports_op_equal<T>::value) {
+						lua_CFunction f = &comparsion_operator_wrap<T, std::equal_to<>>;
+						ifx(meta_function::equal_to, f);
+					}
+					else {
+						lua_CFunction f = &comparsion_operator_wrap<T, no_comp>;
+						ifx(meta_function::equal_to, f);
+					}
+				}
+				if (fx(meta_function::pairs)) {
+					ifx(meta_function::pairs, &container_detail::u_c_launch<as_container_t<T>>::pairs_call);
+				}
+				if (fx(meta_function::length)) {
+					if constexpr (meta::has_size<const T>::value || meta::has_size<T>::value) {
+						auto f = &default_size<T>;
+						ifx(meta_function::length, f);
+					}
+				}
+				if (fx(meta_function::to_string)) {
+					if constexpr (is_to_stringable_v<T>) {
+						if constexpr (!meta::is_probably_stateless_lambda_v<T> && !std::is_member_pointer_v<T>) {
+							auto f = &detail::static_trampoline<&default_to_string<T>>;
+							ifx(meta_function::to_string, f);
+						}
+					}
+				}
+				if (fx(meta_function::call_function)) {
+					if constexpr (is_callable_v<T>) {
+						if constexpr (meta::call_operator_deducible_v<T>) {
+							auto f = &c_call<decltype(&T::operator()), &T::operator()>;
+							ifx(meta_function::call_function, f);
+						}
+					}
+				}
+			}
+		}
+	} // namespace detail
+
+	namespace stack { namespace stack_detail {
+		template <typename X>
+		void set_undefined_methods_on(stack_reference t) {
+			using T = std::remove_pointer_t<X>;
+
+			lua_State* L = t.lua_state();
+
+			t.push();
+
+			detail::lua_reg_table l {};
+			int index = 0;
+			detail::indexed_insert insert_fx(l, index);
+			detail::insert_default_registrations<T>(insert_fx, detail::property_always_true);
+			if constexpr (!std::is_pointer_v<X>) {
+				l[index] = luaL_Reg { to_string(meta_function::garbage_collect).c_str(), detail::make_destructor<T>() };
+			}
+			luaL_setfuncs(L, l, 0);
+
+			// __type table
+			lua_createtable(L, 0, 2);
+			const std::string& name = detail::demangle<T>();
+			lua_pushlstring(L, name.c_str(), name.size());
+			lua_setfield(L, -2, "name");
+			lua_CFunction is_func = &detail::is_check<T>;
+			lua_pushcclosure(L, is_func, 0);
+			lua_setfield(L, -2, "is");
+			lua_setfield(L, t.stack_index(), to_string(meta_function::type).c_str());
+
+			t.pop();
+		}
+	}} // namespace stack::stack_detail
+} // namespace sol
+
+// end of sol/usertype_core.hpp
+
+// beginning of sol/usertype_storage.hpp
+
+#include <bitset>
+#include <unordered_map>
+#include <memory>
+
+namespace sol { namespace u_detail {
+
+	struct usertype_storage_base;
+	template <typename T>
+	struct usertype_storage;
+
+	optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L_, int index);
+	usertype_storage_base& get_usertype_storage_base(lua_State* L_, const char* gcmetakey);
+	template <typename T>
+	optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L_);
+	template <typename T>
+	usertype_storage<T>& get_usertype_storage(lua_State* L_);
+
+	using index_call_function = int(lua_State*, void*);
+	using change_indexing_mem_func = void (usertype_storage_base::*)(
+		lua_State*, submetatable_type, void*, stateless_stack_reference&, lua_CFunction, lua_CFunction, lua_CFunction, lua_CFunction);
+
+	struct index_call_storage {
+		index_call_function* index;
+		index_call_function* new_index;
+		void* binding_data;
+	};
+
+	struct new_index_call_storage : index_call_storage {
+		void* new_binding_data;
+	};
+
+	struct binding_base {
+		virtual void* data() = 0;
+		virtual ~binding_base() {
+		}
+	};
+
+	template <typename K, typename Fq, typename T = void>
+	struct binding : binding_base {
+		using uF = meta::unqualified_t<Fq>;
+		using F = meta::conditional_t<meta::is_c_str_of_v<uF, char>
+#if SOL_IS_ON(SOL_CHAR8_T)
+			     || meta::is_c_str_of_v<uF, char8_t>
+#endif
+			     || meta::is_c_str_of_v<uF, char16_t> || meta::is_c_str_of_v<uF, char32_t> || meta::is_c_str_of_v<uF, wchar_t>,
+			std::add_pointer_t<std::add_const_t<std::remove_all_extents_t<Fq>>>, std::decay_t<Fq>>;
+		F data_;
+
+		template <typename... Args>
+		binding(Args&&... args) : data_(std::forward<Args>(args)...) {
+		}
+
+		virtual void* data() override {
+			return static_cast<void*>(std::addressof(data_));
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_with_(lua_State* L_, void* target) {
+			constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+			auto& f = *static_cast<F*>(target);
+			return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&call_<is_index, is_variable>), (&call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_with_(lua_State* L_, void* target) {
+			if constexpr (!is_variable) {
+				if constexpr (is_lua_c_function_v<std::decay_t<F>>) {
+					auto& f = *static_cast<std::decay_t<F>*>(target);
+					return stack::push(L_, f);
+				}
+				else {
+					// set up upvalues
+					// for a chained call
+					int upvalues = 0;
+					upvalues += stack::push(L_, nullptr);
+					upvalues += stack::push(L_, target);
+					auto cfunc = &call<is_index, is_variable>;
+					return stack::push(L_, c_closure(cfunc, upvalues));
+				}
+			}
+			else {
+				constexpr int boost = !detail::is_non_factory_constructor<F>::value && std::is_same<K, call_construction>::value ? 1 : 0;
+				auto& f = *static_cast<F*>(target);
+				return call_detail::call_wrapped<T, is_index, is_variable, boost>(L_, f);
+			}
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call_(lua_State* L_) {
+			void* f = stack::get<void*>(L_, upvalue_index(usertype_storage_index));
+			return index_call_with_<is_index, is_variable>(L_, f);
+		}
+
+		template <bool is_index = true, bool is_variable = false>
+		static inline int index_call(lua_State* L_) {
+			int r = detail::typed_static_trampoline<decltype(&index_call_<is_index, is_variable>), (&index_call_<is_index, is_variable>)>(L_);
+			if constexpr (meta::is_specialization_of_v<uF, yielding_t>) {
+				return lua_yield(L_, r);
+			}
+			else {
+				return r;
+			}
+		}
+	};
+
+	inline int index_fail(lua_State* L_) {
+		if (lua_getmetatable(L_, 1) == 1) {
+			int metatarget = lua_gettop(L_);
+			stack::get_field<false, true>(L_, stack_reference(L_, raw_index(2)), metatarget);
+			return 1;
+		}
+		// With runtime extensibility, we can't
+		// hard-error things. They have to
+		// return nil, like regular table types
+		return stack::push(L_, lua_nil);
+	}
+
+	inline int index_target_fail(lua_State* L_, void*) {
+		return index_fail(L_);
+	}
+
+	inline int new_index_fail(lua_State* L_) {
+		return luaL_error(L_, "sol: cannot set (new_index) into this object: no defined new_index operation on usertype");
+	}
+
+	inline int new_index_target_fail(lua_State* L_, void*) {
+		return new_index_fail(L_);
+	}
+
+	struct string_for_each_metatable_func {
+		bool is_destruction = false;
+		bool is_index = false;
+		bool is_new_index = false;
+		bool is_static_index = false;
+		bool is_static_new_index = false;
+		bool poison_indexing = false;
+		bool is_unqualified_lua_CFunction = false;
+		bool is_unqualified_lua_reference = false;
+		std::string* p_key = nullptr;
+		reference* p_binding_ref = nullptr;
+		lua_CFunction call_func = nullptr;
+		index_call_storage* p_ics = nullptr;
+		usertype_storage_base* p_usb = nullptr;
+		void* p_derived_usb = nullptr;
+		lua_CFunction idx_call = nullptr, new_idx_call = nullptr, meta_idx_call = nullptr, meta_new_idx_call = nullptr;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			std::string& key = *p_key;
+			usertype_storage_base& usb = *p_usb;
+			index_call_storage& ics = *p_ics;
+
+			if (smt_ == submetatable_type::named) {
+				// do not override __call or
+				// other specific meta functions on named metatable:
+				// we need that for call construction
+				// and other amenities
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			if (poison_indexing) {
+				(usb.*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			}
+			if (is_destruction
+				&& (smt_ == submetatable_type::reference || smt_ == submetatable_type::const_reference || smt_ == submetatable_type::named
+				     || smt_ == submetatable_type::unique)) {
+				// gc does not apply to us here
+				// for reference types (raw T*, std::ref)
+				// for the named metatable itself,
+				// or for unique_usertypes, which do their own custom destroyion
+				t.pop(L_);
+				return;
+			}
+			if (is_index || is_new_index || is_static_index || is_static_new_index) {
+				// do not serialize the new_index and index functions here directly
+				// we control those...
+				t.pop(L_);
+				return;
+			}
+			if (is_unqualified_lua_CFunction) {
+				stack::set_field<false, true>(L_, key, call_func, t.stack_index());
+			}
+			else if (is_unqualified_lua_reference) {
+				reference& binding_ref = *p_binding_ref;
+				stack::set_field<false, true>(L_, key, binding_ref, t.stack_index());
+			}
+			else {
+				stack::set_field<false, true>(L_, key, make_closure(call_func, nullptr, ics.binding_data), t.stack_index());
+			}
+			t.pop(L_);
+		}
+	};
+
+	struct lua_reference_func {
+		reference key;
+		reference value;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			if (smt_ == submetatable_type::named) {
+				return;
+			}
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field<false, true>(L_, key, value, t.stack_index());
+			t.pop(L_);
+		}
+	};
+
+	struct update_bases_func {
+		detail::inheritance_check_function base_class_check_func;
+		detail::inheritance_cast_function base_class_cast_func;
+		lua_CFunction idx_call, new_idx_call, meta_idx_call, meta_new_idx_call;
+		usertype_storage_base* p_usb;
+		void* p_derived_usb;
+		change_indexing_mem_func change_indexing;
+
+		void operator()(lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			int fast_index_table_push = fast_index_table_.push(L_);
+			stateless_stack_reference t(L_, -fast_index_table_push);
+			stack::set_field(L_, detail::base_class_check_key(), reinterpret_cast<void*>(base_class_check_func), t.stack_index());
+			stack::set_field(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(base_class_cast_func), t.stack_index());
+			// change indexing, forcefully
+			(p_usb->*change_indexing)(L_, smt_, p_derived_usb, t, idx_call, new_idx_call, meta_idx_call, meta_new_idx_call);
+			t.pop(L_);
+		}
+	};
+
+	struct binding_data_equals {
+		void* binding_data;
+
+		binding_data_equals(void* b) : binding_data(b) {
+		}
+
+		bool operator()(const std::unique_ptr<binding_base>& ptr) const {
+			return binding_data == ptr->data();
+		}
+	};
+
+	struct usertype_storage_base {
+	public:
+		lua_State* m_L;
+		std::vector<std::unique_ptr<binding_base>> storage;
+		std::vector<std::unique_ptr<char[]>> string_keys_storage;
+		std::unordered_map<string_view, index_call_storage> string_keys;
+		std::unordered_map<stateless_reference, stateless_reference, stateless_reference_hash, stateless_reference_equals> auxiliary_keys;
+		stateless_reference value_index_table;
+		stateless_reference reference_index_table;
+		stateless_reference unique_index_table;
+		stateless_reference const_reference_index_table;
+		stateless_reference const_value_index_table;
+		stateless_reference named_index_table;
+		stateless_reference type_table;
+		stateless_reference gc_names_table;
+		stateless_reference named_metatable;
+		new_index_call_storage base_index;
+		new_index_call_storage static_base_index;
+		bool is_using_index;
+		bool is_using_new_index;
+		std::bitset<64> properties;
+
+		usertype_storage_base(lua_State* L_)
+		: m_L(L_)
+		, storage()
+		, string_keys_storage()
+		, string_keys()
+		, auxiliary_keys(0, stateless_reference_hash(L_), stateless_reference_equals(L_))
+		, value_index_table()
+		, reference_index_table()
+		, unique_index_table()
+		, const_reference_index_table()
+		, const_value_index_table()
+		, named_index_table()
+		, type_table(make_reference<stateless_reference>(L_, create))
+		, gc_names_table(make_reference<stateless_reference>(L_, create))
+		, named_metatable(make_reference<stateless_reference>(L_, create))
+		, base_index()
+		, static_base_index()
+		, is_using_index(false)
+		, is_using_new_index(false)
+		, properties() {
+			base_index.binding_data = nullptr;
+			base_index.index = index_target_fail;
+			base_index.new_index = new_index_target_fail;
+			base_index.new_binding_data = nullptr;
+			static_base_index.binding_data = nullptr;
+			static_base_index.index = index_target_fail;
+			static_base_index.new_binding_data = this;
+			static_base_index.new_index = new_index_target_set;
+		}
+
+		template <typename Fx>
+		void for_each_table(lua_State* L_, Fx&& fx) {
+			for (int i = 0; i < 6; ++i) {
+				submetatable_type smt = static_cast<submetatable_type>(i);
+				stateless_reference* p_fast_index_table = nullptr;
+				switch (smt) {
+				case submetatable_type::const_value:
+					p_fast_index_table = &this->const_value_index_table;
+					break;
+				case submetatable_type::reference:
+					p_fast_index_table = &this->reference_index_table;
+					break;
+				case submetatable_type::unique:
+					p_fast_index_table = &this->unique_index_table;
+					break;
+				case submetatable_type::const_reference:
+					p_fast_index_table = &this->const_reference_index_table;
+					break;
+				case submetatable_type::named:
+					p_fast_index_table = &this->named_index_table;
+					break;
+				case submetatable_type::value:
+				default:
+					p_fast_index_table = &this->value_index_table;
+					break;
+				}
+				fx(L_, smt, *p_fast_index_table);
+			}
+		}
+
+		void add_entry(string_view sv, index_call_storage ics) {
+			string_keys_storage.emplace_back(new char[sv.size()]);
+			std::unique_ptr<char[]>& sv_storage = string_keys_storage.back();
+			std::memcpy(sv_storage.get(), sv.data(), sv.size());
+			string_view stored_sv(sv_storage.get(), sv.size());
+			string_keys.insert_or_assign(std::move(stored_sv), std::move(ics));
+		}
+
+		template <typename T, typename... Bases>
+		void update_bases(lua_State* L_, bases<Bases...>) {
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: Please file "
+				"a bug report.");
+			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
+			if constexpr (sizeof...(Bases) > 0) {
+				(void)detail::swallow { 0, ((weak_derive<Bases>::value = true), 0)... };
+
+				void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+
+				update_bases_func for_each_fx;
+				for_each_fx.base_class_check_func = &detail::inheritance<T>::template type_check_with<Bases...>;
+				for_each_fx.base_class_cast_func = &detail::inheritance<T>::template type_cast_with<Bases...>;
+				for_each_fx.idx_call = &usertype_storage<T>::template index_call_with_bases<false, Bases...>;
+				for_each_fx.new_idx_call = &usertype_storage<T>::template index_call_with_bases<true, Bases...>;
+				for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<false, Bases...>;
+				for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call_with_bases<true, Bases...>;
+				for_each_fx.p_usb = this;
+				for_each_fx.p_derived_usb = derived_this;
+				for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+				for_each_fx.p_derived_usb = derived_this;
+				this->for_each_table(L_, for_each_fx);
+			}
+			else {
+				(void)L_;
+			}
+		}
+
+		void clear() {
+			if (value_index_table.valid(m_L)) {
+				stack::clear(m_L, value_index_table);
+			}
+			if (reference_index_table.valid(m_L)) {
+				stack::clear(m_L, reference_index_table);
+			}
+			if (unique_index_table.valid(m_L)) {
+				stack::clear(m_L, unique_index_table);
+			}
+			if (const_reference_index_table.valid(m_L)) {
+				stack::clear(m_L, const_reference_index_table);
+			}
+			if (const_value_index_table.valid(m_L)) {
+				stack::clear(m_L, const_value_index_table);
+			}
+			if (named_index_table.valid(m_L)) {
+				stack::clear(m_L, named_index_table);
+			}
+			if (type_table.valid(m_L)) {
+				stack::clear(m_L, type_table);
+			}
+			if (gc_names_table.valid(m_L)) {
+				stack::clear(m_L, gc_names_table);
+			}
+			if (named_metatable.valid(m_L)) {
+				auto pp = stack::push_pop(m_L, named_metatable);
+				int named_metatable_index = pp.index_of(named_metatable);
+				if (lua_getmetatable(m_L, named_metatable_index) == 1) {
+					stack::clear(m_L, absolute_index(m_L, -1));
+				}
+				stack::clear(m_L, named_metatable);
+			}
+
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			storage.clear();
+			string_keys.clear();
+			auxiliary_keys.clear();
+			string_keys_storage.clear();
+		}
+
+		template <bool is_new_index, typename Base>
+		static void base_walk_index(lua_State* L_, usertype_storage_base& self, bool& keep_going, int& base_result) {
+			using bases = typename base<Base>::type;
+			if (!keep_going) {
+				return;
+			}
+			(void)L_;
+			(void)self;
+#if SOL_IS_ON(SOL_USE_UNSAFE_BASE_LOOKUP)
+			usertype_storage_base& base_storage = get_usertype_storage<Base>(L_);
+			base_result = self_index_call<is_new_index, true>(bases(), L_, base_storage);
+#else
+			optional<usertype_storage<Base>&> maybe_base_storage = maybe_get_usertype_storage<Base>(L_);
+			if (static_cast<bool>(maybe_base_storage)) {
+				base_result = self_index_call<is_new_index, true>(bases(), L_, *maybe_base_storage);
+				keep_going = base_result == base_walking_failed_index;
+			}
+#endif // Fast versus slow, safe base lookup
+		}
+
+		template <bool is_new_index = false, bool base_walking = false, bool from_named_metatable = false, typename... Bases>
+		static inline int self_index_call(types<Bases...>, lua_State* L, usertype_storage_base& self) {
+			if constexpr (!from_named_metatable || !is_new_index) {
+				type k_type = stack::get<type>(L, 2);
+				if (k_type == type::string) {
+					index_call_storage* target = nullptr;
+					string_view k = stack::get<string_view>(L, 2);
+					{
+						auto it = self.string_keys.find(k);
+						if (it != self.string_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						// let the target decide what to do, unless it's named...
+						if constexpr (is_new_index) {
+							return (target->new_index)(L, target->binding_data);
+						}
+						else {
+							return (target->index)(L, target->binding_data);
+						}
+					}
+				}
+				else if (k_type != type::lua_nil && k_type != type::none) {
+					stateless_reference* target = nullptr;
+					{
+						stack_reference k = stack::get<stack_reference>(L, 2);
+						auto it = self.auxiliary_keys.find(k);
+						if (it != self.auxiliary_keys.cend()) {
+							target = &it->second;
+						}
+					}
+					if (target != nullptr) {
+						if constexpr (is_new_index) {
+							// set value and return
+							target->reset(L, 3);
+							return 0;
+						}
+						else {
+							// push target to return
+							// what we found
+							return stack::push(L, *target);
+						}
+					}
+				}
+			}
+
+			// retrieve bases and walk through them.
+			bool keep_going = true;
+			int base_result;
+			(void)keep_going;
+			(void)base_result;
+			(void)detail::swallow { 1, (base_walk_index<is_new_index, Bases>(L, self, keep_going, base_result), 1)... };
+			if constexpr (sizeof...(Bases) > 0) {
+				if (!keep_going) {
+					return base_result;
+				}
+			}
+			if constexpr (base_walking) {
+				// if we're JUST base-walking then don't index-fail, just
+				// return the false bits
+				return base_walking_failed_index;
+			}
+			else if constexpr (from_named_metatable) {
+				if constexpr (is_new_index) {
+					return self.static_base_index.new_index(L, self.static_base_index.new_binding_data);
+				}
+				else {
+					return self.static_base_index.index(L, self.static_base_index.binding_data);
+				}
+			}
+			else {
+				if constexpr (is_new_index) {
+					return self.base_index.new_index(L, self.base_index.new_binding_data);
+				}
+				else {
+					return self.base_index.index(L, self.base_index.binding_data);
+				}
+			}
+		}
+
+		void change_indexing(lua_State* L_, submetatable_type submetatable_, void* derived_this_, stateless_stack_reference& t_, lua_CFunction index_,
+			lua_CFunction new_index_, lua_CFunction meta_index_, lua_CFunction meta_new_index_) {
+			usertype_storage_base& this_base = *this;
+			void* base_this = static_cast<void*>(&this_base);
+
+			this->is_using_index |= true;
+			this->is_using_new_index |= true;
+			if (submetatable_ == submetatable_type::named) {
+				stack::set_field(L_, metatable_key, named_index_table, t_.stack_index());
+				stateless_stack_reference stack_metametatable(L_, -named_metatable.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(meta_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(meta_new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop(L_);
+			}
+			else {
+				stack::set_field<false, true>(
+					L_, meta_function::index, make_closure(index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+				stack::set_field<false, true>(
+					L_, meta_function::new_index, make_closure(new_index_, nullptr, derived_this_, base_this, nullptr, toplevel_magic), t_.stack_index());
+			}
+		}
+
+		template <typename T = void, typename Key, typename Value>
+		void set(lua_State* L, Key&& key, Value&& value);
+
+		static int new_index_target_set(lua_State* L, void* target) {
+			usertype_storage_base& self = *static_cast<usertype_storage_base*>(target);
+			self.set(L, reference(L, raw_index(2)), reference(L, raw_index(3)));
+			return 0;
+		}
+
+		~usertype_storage_base() {
+			value_index_table.reset(m_L);
+			reference_index_table.reset(m_L);
+			unique_index_table.reset(m_L);
+			const_reference_index_table.reset(m_L);
+			const_value_index_table.reset(m_L);
+			named_index_table.reset(m_L);
+			type_table.reset(m_L);
+			gc_names_table.reset(m_L);
+			named_metatable.reset(m_L);
+
+			auto auxiliary_first = auxiliary_keys.cbegin();
+			auto auxiliary_last = auxiliary_keys.cend();
+			while (auxiliary_first != auxiliary_last) {
+				// save a copy to what we're going to destroy
+				auto auxiliary_target = auxiliary_first;
+				// move the iterator up by 1
+				++auxiliary_first;
+				// extract the node and destroy the key
+				auto extracted_node = auxiliary_keys.extract(auxiliary_target);
+				extracted_node.key().reset(m_L);
+				extracted_node.mapped().reset(m_L);
+				// continue if auxiliary_first hasn't been exhausted
+			}
+		}
+	};
+
+	template <typename T>
+	struct usertype_storage : usertype_storage_base {
+
+		using usertype_storage_base::usertype_storage_base;
+
+		template <bool is_new_index, bool from_named_metatable>
+		static inline int index_call_(lua_State* L) {
+			using bases = typename base<T>::type;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index, bool from_named_metatable, typename... Bases>
+		static inline int index_call_with_bases_(lua_State* L) {
+			using bases = types<Bases...>;
+			usertype_storage_base& self = stack::get<light<usertype_storage_base>>(L, upvalue_index(usertype_storage_index));
+			return self_index_call<is_new_index, false, from_named_metatable>(bases(), L, self);
+		}
+
+		template <bool is_new_index>
+		static inline int index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, false>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, false, Bases...>>(L);
+		}
+
+		template <bool is_new_index>
+		static inline int meta_index_call(lua_State* L) {
+			return detail::static_trampoline<&index_call_<is_new_index, true>>(L);
+		}
+
+		template <bool is_new_index, typename... Bases>
+		static inline int meta_index_call_with_bases(lua_State* L) {
+			return detail::static_trampoline<&index_call_with_bases_<is_new_index, true, Bases...>>(L);
+		}
+
+		template <typename Key, typename Value>
+		inline void set(lua_State* L, Key&& key, Value&& value);
+	};
+
+	template <typename T, typename Key, typename Value>
+	void usertype_storage_base::set(lua_State* L, Key&& key, Value&& value) {
+		using ValueU = meta::unwrap_unqualified_t<Value>;
+		using KeyU = meta::unwrap_unqualified_t<Key>;
+		using Binding = binding<KeyU, ValueU, T>;
+		using is_var_bind = is_variable_binding<ValueU>;
+		if constexpr (std::is_same_v<KeyU, call_construction>) {
+			(void)key;
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			this->storage.push_back(std::move(p_binding));
+
+			this->named_index_table.push(L);
+			absolute_index metametatable_index(L, -1);
+			std::string_view call_metamethod_name = to_string(meta_function::call);
+			lua_pushlstring(L, call_metamethod_name.data(), call_metamethod_name.size());
+			stack::push(L, nullptr);
+			stack::push(L, b.data());
+			lua_CFunction target_func = &b.template call<false, false>;
+			lua_pushcclosure(L, target_func, 2);
+			lua_rawset(L, metametatable_index);
+			this->named_index_table.pop(L);
+		}
+		else if constexpr (std::is_same_v<KeyU, base_classes_tag>) {
+			(void)key;
+			this->update_bases<T>(L, std::forward<Value>(value));
+		}
+		else if constexpr ((meta::is_string_like_or_constructible<KeyU>::value || std::is_same_v<KeyU, meta_function>)) {
+			std::string s = u_detail::make_string(std::forward<Key>(key));
+			auto storage_it = this->storage.end();
+			auto string_it = this->string_keys.find(s);
+			if (string_it != this->string_keys.cend()) {
+				const auto& binding_data = string_it->second.binding_data;
+				storage_it = std::find_if(this->storage.begin(), this->storage.end(), binding_data_equals(binding_data));
+				this->string_keys.erase(string_it);
+			}
+
+			std::unique_ptr<Binding> p_binding = std::make_unique<Binding>(std::forward<Value>(value));
+			Binding& b = *p_binding;
+			if (storage_it != this->storage.cend()) {
+				*storage_it = std::move(p_binding);
+			}
+			else {
+				this->storage.push_back(std::move(p_binding));
+			}
+
+			bool is_index = (s == to_string(meta_function::index));
+			bool is_new_index = (s == to_string(meta_function::new_index));
+			bool is_static_index = (s == to_string(meta_function::static_index));
+			bool is_static_new_index = (s == to_string(meta_function::static_new_index));
+			bool is_destruction = s == to_string(meta_function::garbage_collect);
+			bool poison_indexing = (!is_using_index || !is_using_new_index) && (is_var_bind::value || is_index || is_new_index);
+			void* derived_this = static_cast<void*>(static_cast<usertype_storage<T>*>(this));
+			index_call_storage ics;
+			ics.binding_data = b.data();
+			ics.index = is_index || is_static_index ? &Binding::template call_with_<true, is_var_bind::value>
+				                                   : &Binding::template index_call_with_<true, is_var_bind::value>;
+			ics.new_index = is_new_index || is_static_new_index ? &Binding::template call_with_<false, is_var_bind::value>
+				                                               : &Binding::template index_call_with_<false, is_var_bind::value>;
+
+			string_for_each_metatable_func for_each_fx;
+			for_each_fx.is_destruction = is_destruction;
+			for_each_fx.is_index = is_index;
+			for_each_fx.is_new_index = is_new_index;
+			for_each_fx.is_static_index = is_static_index;
+			for_each_fx.is_static_new_index = is_static_new_index;
+			for_each_fx.poison_indexing = poison_indexing;
+			for_each_fx.p_key = &s;
+			for_each_fx.p_ics = &ics;
+			if constexpr (is_lua_c_function_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_CFunction = true;
+				for_each_fx.call_func = *static_cast<lua_CFunction*>(ics.binding_data);
+			}
+			else if constexpr (is_lua_reference_or_proxy_v<ValueU>) {
+				for_each_fx.is_unqualified_lua_reference = true;
+				for_each_fx.p_binding_ref = static_cast<reference*>(ics.binding_data);
+			}
+			else {
+				for_each_fx.call_func = &b.template call<false, is_var_bind::value>;
+			}
+			for_each_fx.p_usb = this;
+			for_each_fx.p_derived_usb = derived_this;
+			for_each_fx.idx_call = &usertype_storage<T>::template index_call<false>;
+			for_each_fx.new_idx_call = &usertype_storage<T>::template index_call<true>;
+			for_each_fx.meta_idx_call = &usertype_storage<T>::template meta_index_call<false>;
+			for_each_fx.meta_new_idx_call = &usertype_storage<T>::template meta_index_call<true>;
+			for_each_fx.change_indexing = &usertype_storage_base::change_indexing;
+			// set base index and base new_index
+			// functions here
+			if (is_index) {
+				this->base_index.index = ics.index;
+				this->base_index.binding_data = ics.binding_data;
+			}
+			if (is_new_index) {
+				this->base_index.new_index = ics.new_index;
+				this->base_index.new_binding_data = ics.binding_data;
+			}
+			if (is_static_index) {
+				this->static_base_index.index = ics.index;
+				this->static_base_index.binding_data = ics.binding_data;
+			}
+			if (is_static_new_index) {
+				this->static_base_index.new_index = ics.new_index;
+				this->static_base_index.new_binding_data = ics.binding_data;
+			}
+			this->for_each_table(L, for_each_fx);
+			this->add_entry(s, std::move(ics));
+		}
+		else {
+			// the reference-based implementation might compare poorly and hash
+			// poorly in some cases...
+			if constexpr (is_lua_reference_v<KeyU> && is_lua_reference_v<ValueU>) {
+				if (key.get_type() == type::string) {
+					stack::push(L, key);
+					std::string string_key = stack::pop<std::string>(L);
+					this->set<T>(L, string_key, std::forward<Value>(value));
+				}
+				else {
+					lua_reference_func ref_additions_fx { key, value };
+
+					this->for_each_table(L, ref_additions_fx);
+					this->auxiliary_keys.insert_or_assign(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			else {
+				reference ref_key = make_reference(L, std::forward<Key>(key));
+				reference ref_value = make_reference(L, std::forward<Value>(value));
+				lua_reference_func ref_additions_fx { ref_key, ref_value };
+
+				this->for_each_table(L, ref_additions_fx);
+				this->auxiliary_keys.insert_or_assign(std::move(ref_key), std::move(ref_value));
+			}
+		}
+	}
+
+	template <typename T>
+	template <typename Key, typename Value>
+	void usertype_storage<T>::set(lua_State* L, Key&& key, Value&& value) {
+		static_cast<usertype_storage_base&>(*this).set<T>(L, std::forward<Key>(key), std::forward<Value>(value));
+	}
+
+	template <typename T>
+	inline void clear_usertype_registry_names(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+
+		stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+		registry.push();
+		// eliminate all named entries for this usertype
+		// in the registry (luaL_newmetatable does
+		// [name] = new table
+		// in registry upon creation
+		stack::set_field(L, &u_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_const_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_ref_traits::metatable()[0], lua_nil, registry.stack_index());
+		stack::set_field(L, &u_unique_traits::metatable()[0], lua_nil, registry.stack_index());
+		registry.pop();
+	}
+
+	template <typename T>
+	inline int destroy_usertype_storage(lua_State* L) noexcept {
+		clear_usertype_registry_names<T>(L);
+		return detail::user_alloc_destroy<usertype_storage<T>>(L);
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& create_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+
+		// Make sure userdata's memory is properly in lua first,
+		// otherwise all the light userdata we make later will become invalid
+		int usertype_storage_push_count = stack::push<user<usertype_storage<T>>>(L, no_metatable, L);
+		stack_reference usertype_storage_ref(L, -usertype_storage_push_count);
+
+		// create and push onto the stack a table to use as metatable for this GC
+		// we create a metatable to attach to the regular gc_table
+		// so that the destructor is called for the usertype storage
+		int usertype_storage_metatabe_count = stack::push(L, new_table(0, 1));
+		stack_reference usertype_storage_metatable(L, -usertype_storage_metatabe_count);
+		// set the destroyion routine on the metatable
+		stack::set_field(L, meta_function::garbage_collect, &destroy_usertype_storage<T>, usertype_storage_metatable.stack_index());
+		// set the metatable on the usertype storage userdata
+		stack::set_field(L, metatable_key, usertype_storage_metatable, usertype_storage_ref.stack_index());
+		usertype_storage_metatable.pop();
+
+		// set the usertype storage and its metatable
+		// into the global table...
+		stack::set_field<true>(L, gcmetakey, usertype_storage_ref);
+		usertype_storage_ref.pop();
+
+		// then retrieve the lua-stored version so we have a well-pinned
+		// reference that does not die
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	inline optional<usertype_storage_base&> maybe_as_usertype_storage_base(lua_State* L, int index) {
+		if (type_of(L, index) != type::lightuserdata) {
+			return nullopt;
+		}
+		usertype_storage_base& base_storage = *static_cast<usertype_storage_base*>(stack::get<void*>(L, index));
+		return base_storage;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base_inside(lua_State* L, int index) {
+		// okay, maybe we're looking at a table that is nested?
+		if (type_of(L, index) != type::table) {
+			return nullopt;
+		}
+		stack::get_field(L, meta_function::storage, index);
+		auto maybe_storage_base = maybe_as_usertype_storage_base(L, -1);
+		lua_pop(L, 1);
+		return maybe_storage_base;
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, int index) {
+		// If we can get the index directly as this type, go for it
+		auto maybe_already_is_usertype_storage_base = maybe_as_usertype_storage_base(L, index);
+		if (maybe_already_is_usertype_storage_base) {
+			return maybe_already_is_usertype_storage_base;
+		}
+		return maybe_get_usertype_storage_base_inside(L, index);
+	}
+
+	inline optional<usertype_storage_base&> maybe_get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		auto maybe_storage = maybe_as_usertype_storage_base(L, lua_gettop(L));
+		lua_pop(L, 1);
+		return maybe_storage;
+	}
+
+	inline usertype_storage_base& get_usertype_storage_base(lua_State* L, const char* gcmetakey) {
+		stack::get_field<true>(L, gcmetakey);
+		stack::record tracking;
+		usertype_storage_base& target_umt = stack::stack_detail::unchecked_unqualified_get<user<usertype_storage_base>>(L, -1, tracking);
+		lua_pop(L, 1);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline optional<usertype_storage<T>&> maybe_get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		int target = lua_gettop(L);
+		if (!stack::check<user<usertype_storage<T>>>(L, target)) {
+			return nullopt;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline usertype_storage<T>& get_usertype_storage(lua_State* L) {
+		const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		return target_umt;
+	}
+
+	template <typename T>
+	inline void clear_usertype_storage(lua_State* L) {
+		using u_traits = usertype_traits<T>;
+
+		const char* gcmetakey = &u_traits::gc_table()[0];
+		stack::get_field<true>(L, gcmetakey);
+		if (!stack::check<user<usertype_storage<T>>>(L)) {
+			lua_pop(L, 1);
+			return;
+		}
+		usertype_storage<T>& target_umt = stack::pop<user<usertype_storage<T>>>(L);
+		target_umt.clear();
+
+		clear_usertype_registry_names<T>(L);
+
+		stack::set_field<true>(L, gcmetakey, lua_nil);
+	}
+
+	template <typename T, automagic_flags enrollment_flags>
+	inline int register_usertype(lua_State* L_, automagic_enrollments enrollments_ = {}) {
+		using u_traits = usertype_traits<T>;
+		using u_const_traits = usertype_traits<const T>;
+		using u_unique_traits = usertype_traits<d::u<T>>;
+		using u_ref_traits = usertype_traits<T*>;
+		using u_const_ref_traits = usertype_traits<T const*>;
+		using uts = usertype_storage<T>;
+
+		// always have __new_index point to usertype_storage method
+		// have __index always point to regular fast-lookup
+		// meta_method table
+		// if __new_index is invoked, runtime-swap
+		// to slow __index if necessary
+		// (no speed penalty because function calls
+		// are all read-only -- only depend on __index
+		// to retrieve function and then call happens VIA Lua)
+
+		// __type entry:
+		// table contains key -> value lookup,
+		// where key is entry in metatable
+		// and value is type information as a string as
+		// best as we can give it
+
+		// name entry:
+		// string that contains raw class name,
+		// as defined from C++
+
+		// is entry:
+		// checks if argument supplied is of type T
+
+		// __storage entry:
+		// a light userdata pointing to the storage
+		// mostly to enable this new abstraction
+		// to not require the type name `T`
+		// to get at the C++ usertype storage within
+
+		// we then let typical definitions potentially override these intrinsics
+		// it's the user's fault if they override things or screw them up:
+		// these names have been reserved and documented since sol2
+
+		// STEP 0: tell the old usertype (if it exists)
+		// to fuck off
+		clear_usertype_storage<T>(L_);
+
+		// STEP 1: Create backing store for usertype storage
+		// Pretty much the most important step.
+		// STEP 2: Create Lua tables used for fast method indexing.
+		// This is done inside of the storage table's constructor
+		usertype_storage<T>& storage = create_usertype_storage<T>(L_);
+		usertype_storage_base& base_storage = storage;
+		void* light_storage = static_cast<void*>(&storage);
+		void* light_base_storage = static_cast<void*>(&base_storage);
+
+		// STEP 3: set up GC escape hatch table entirely
+		storage.gc_names_table.push(L_);
+		stateless_stack_reference gnt(L_, -1);
+		stack::set_field(L_, submetatable_type::named, &u_traits::gc_table()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_value, &u_const_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::const_reference, &u_const_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::reference, &u_ref_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::unique, &u_unique_traits::metatable()[0], gnt.stack_index());
+		stack::set_field(L_, submetatable_type::value, &u_traits::metatable()[0], gnt.stack_index());
+		gnt.pop(L_);
+
+		// STEP 4: add some useful information to the type table
+		stateless_stack_reference stacked_type_table(L_, -storage.type_table.push(L_));
+		stack::set_field(L_, "name", detail::demangle<T>(), stacked_type_table.stack_index());
+		stack::set_field(L_, "is", &detail::is_check<T>, stacked_type_table.stack_index());
+		stacked_type_table.pop(L_);
+
+		// STEP 5: create and hook up metatable,
+		// add intrinsics
+		// this one is the actual meta-handling table,
+		// the next one will be the one for
+		int for_each_backing_metatable_calls = 0;
+		auto for_each_backing_metatable = [&](lua_State* L_, submetatable_type smt_, stateless_reference& fast_index_table_) {
+			// Pointer types, AKA "references" from C++
+			const char* metakey = nullptr;
+			switch (smt_) {
+			case submetatable_type::const_value:
+				metakey = &u_const_traits::metatable()[0];
+				break;
+			case submetatable_type::reference:
+				metakey = &u_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::unique:
+				metakey = &u_unique_traits::metatable()[0];
+				break;
+			case submetatable_type::const_reference:
+				metakey = &u_const_ref_traits::metatable()[0];
+				break;
+			case submetatable_type::named:
+				metakey = &u_traits::user_metatable()[0];
+				break;
+			case submetatable_type::value:
+			default:
+				metakey = &u_traits::metatable()[0];
+				break;
+			}
+
+			luaL_newmetatable(L_, metakey);
+			if (smt_ == submetatable_type::named) {
+				// the named table itself
+				// gets the associated name value
+				storage.named_metatable.reset(L_, -1);
+				lua_pop(L_, 1);
+				// but the thing we perform the methods on
+				// is still the metatable of the named
+				// table
+				lua_createtable(L_, 0, 6);
+			}
+			stateless_stack_reference t(L_, -1);
+			fast_index_table_.reset(L_, t.stack_index());
+			stack::set_field<false, true>(L_, meta_function::type, storage.type_table, t.stack_index());
+			// destructible? serialize default destructor here
+			// otherwise, not destructible: serialize a "hey you messed up"
+			switch (smt_) {
+			case submetatable_type::const_reference:
+			case submetatable_type::reference:
+			case submetatable_type::named:
+				break;
+			case submetatable_type::unique:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::unique_destroy<T>, t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			case submetatable_type::value:
+			case submetatable_type::const_value:
+			default:
+				if constexpr (std::is_destructible_v<T>) {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, detail::make_destructor<T>(), t.stack_index());
+				}
+				else {
+					stack::set_field<false, true>(L_, meta_function::garbage_collect, &detail::cannot_destroy<T>, t.stack_index());
+				}
+				break;
+			}
+
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function),
+				"The size of this data pointer is too small to fit the inheritance checking function: file a bug "
+				"report.");
+			stack::set_field<false, true>(L_, detail::base_class_check_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_check), t.stack_index());
+			stack::set_field<false, true>(L_, detail::base_class_cast_key(), reinterpret_cast<void*>(&detail::inheritance<T>::type_cast), t.stack_index());
+
+			auto prop_fx = detail::properties_enrollment_allowed(for_each_backing_metatable_calls, storage.properties, enrollments_);
+			auto insert_fx = [&L_, &t, &storage](meta_function mf, lua_CFunction reg) {
+				stack::set_field<false, true>(L_, mf, reg, t.stack_index());
+				storage.properties[static_cast<std::size_t>(mf)] = true;
+			};
+			detail::insert_default_registrations<T>(insert_fx, prop_fx);
+
+			// There are no variables, so serialize the fast function stuff
+			// be sure to reset the index stuff to the non-fast version
+			// if the user ever adds something later!
+			if (smt_ == submetatable_type::named) {
+				// add escape hatch storage pointer and gc names
+				stack::set_field<false, true>(L_, meta_function::storage, light_base_storage, t.stack_index());
+				stack::set_field<false, true>(L_, meta_function::gc_names, storage.gc_names_table, t.stack_index());
+
+				// fancy new_indexing when using the named table
+				{
+					absolute_index named_metatable_index(L_, -storage.named_metatable.push(L_));
+					stack::set_field<false, true>(L_, metatable_key, t, named_metatable_index);
+					storage.named_metatable.pop(L_);
+				}
+				stack_reference stack_metametatable(L_, -storage.named_index_table.push(L_));
+				stack::set_field<false, true>(L_,
+					meta_function::index,
+					make_closure(uts::template meta_index_call<false>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template meta_index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					stack_metametatable.stack_index());
+				stack_metametatable.pop();
+			}
+			else {
+				// otherwise just plain for index,
+				// and elaborated for new_index
+				stack::set_field<false, true>(L_, meta_function::index, t, t.stack_index());
+				stack::set_field<false, true>(L_,
+					meta_function::new_index,
+					make_closure(uts::template index_call<true>, nullptr, light_storage, light_base_storage, nullptr, toplevel_magic),
+					t.stack_index());
+				storage.is_using_new_index = true;
+			}
+
+			++for_each_backing_metatable_calls;
+			fast_index_table_.reset(L_, t.stack_index());
+			t.pop(L_);
+		};
+
+		storage.for_each_table(L_, for_each_backing_metatable);
+
+		// can only use set AFTER we initialize all the metatables
+		if constexpr (std::is_default_constructible_v<T> && has_flag(enrollment_flags, automagic_flags::default_constructor)) {
+			if (enrollments_.default_constructor) {
+				storage.set(L_, meta_function::construct, constructors<T()>());
+			}
+		}
+
+		// return the named metatable we want names linked into
+		storage.named_metatable.push(L_);
+		return 1;
+	}
+}} // namespace sol::u_detail
+
+// end of sol/usertype_storage.hpp
+
+// beginning of sol/usertype_proxy.hpp
+
+namespace sol {
+	template <typename Table, typename Key>
+	struct usertype_proxy : public proxy_base<usertype_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(key)..., std::forward<T>(value));
+			}
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			if constexpr (sizeof...(I) > 1) {
+				tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+			else {
+				tbl.set(std::get<I>(std::move(key))..., std::forward<T>(value));
+			}
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		usertype_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		usertype_proxy& set(T&& item) & {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			tuple_set(idx_seq(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		usertype_proxy&& set(T&& item) && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			std::move(*this).tuple_set(idx_seq(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(T&& other) & {
+			return set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(T&& other) && {
+			return std::move(*this).set(std::forward<T>(other));
+		}
+
+		template <typename T>
+		usertype_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		usertype_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return usertype_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+#if !defined(__clang__) && defined(_MSC_FULL_VER) && _MSC_FULL_VER >= 191200000
+			// MSVC is ass sometimes
+			return get<function>().call<Ret...>(std::forward<Args>(args)...);
+#else
+			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
+#endif
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			return get<reference>().push(L);
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+	};
+} // namespace sol
+
+// end of sol/usertype_proxy.hpp
+
+// beginning of sol/metatable.hpp
+
+// beginning of sol/table_core.hpp
+
+// beginning of sol/table_proxy.hpp
+
+namespace sol {
+
+	template <typename Table, typename Key>
+	struct table_proxy : public proxy_base<table_proxy<Table, Key>> {
+	private:
+		using key_type = detail::proxy_key_t<Key>;
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) const& {
+			return tbl.template traverse_get<T>(std::get<I>(key)...);
+		}
+
+		template <typename T, std::size_t... I>
+		decltype(auto) tuple_get(std::index_sequence<I...>) && {
+			return tbl.template traverse_get<T>(std::get<I>(std::move(key))...);
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) & {
+			tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
+		}
+
+		template <std::size_t... I, typename T>
+		void tuple_set(std::index_sequence<I...>, T&& value) && {
+			tbl.traverse_set(std::get<I>(std::move(key))..., std::forward<T>(value));
+		}
+
+		auto setup_table(std::true_type) {
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, tbl.stack_index());
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		bool is_valid(std::false_type) {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same_v<meta::unqualified_t<Table>, global_table>>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+	public:
+		Table tbl;
+		key_type key;
+
+		template <typename T>
+		table_proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {
+		}
+
+		template <typename T>
+		table_proxy& set(T&& item) & {
+			tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return *this;
+		}
+
+		template <typename T>
+		table_proxy&& set(T&& item) && {
+			std::move(*this).tuple_set(std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>(), std::forward<T>(item));
+			return std::move(*this);
+		}
+
+		template <typename... Args>
+		table_proxy& set_function(Args&&... args) & {
+			tbl.set_function(key, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		table_proxy&& set_function(Args&&... args) && {
+			tbl.set_function(std::move(key), std::forward<Args>(args)...);
+			return std::move(*this);
+		}
+
+		template <typename T>
+		table_proxy& operator=(T&& other) & {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu>) {
+				return set_function(std::forward<T>(other));
+			}
+			else {
+				return set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy&& operator=(T&& other) && {
+			using Tu = meta::unwrap_unqualified_t<T>;
+			if constexpr (!is_lua_reference_or_proxy_v<Tu> && meta::is_invocable_v<Tu> && !detail::is_msvc_callable_rigged_v<T>) {
+				return std::move(*this).set_function(std::forward<T>(other));
+			}
+			else {
+				return std::move(*this).set(std::forward<T>(other));
+			}
+		}
+
+		template <typename T>
+		table_proxy& operator=(std::initializer_list<T> other) & {
+			return set(std::move(other));
+		}
+
+		template <typename T>
+		table_proxy&& operator=(std::initializer_list<T> other) && {
+			return std::move(*this).set(std::move(other));
+		}
+
+		template <typename T>
+		bool is() const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = this->get<optional<U>>();
+			return option.has_value();
+		}
+
+		template <typename T>
+		decltype(auto) get() const& {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get() && {
+			using idx_seq = std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<key_type>>>;
+			return std::move(*this).template tuple_get<T>(idx_seq());
+		}
+
+		template <typename T>
+		decltype(auto) get_or(T&& otherwise) const {
+			typedef decltype(get<T>()) U;
+			optional<U> option = get<optional<U>>();
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename D>
+		decltype(auto) get_or(D&& otherwise) const {
+			optional<T> option = get<optional<T>>();
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T>
+		decltype(auto) get_or_create() {
+			return get_or_create<T>(new_table());
+		}
+
+		template <typename T, typename Otherwise>
+		decltype(auto) get_or_create(Otherwise&& other) {
+			if (!this->valid()) {
+				this->set(std::forward<Otherwise>(other));
+			}
+			return get<T>();
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) const& {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) & {
+			auto keys = meta::tuplefy(key, std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename K>
+		decltype(auto) operator[](K&& k) && {
+			auto keys = meta::tuplefy(std::move(key), std::forward<K>(k));
+			return table_proxy<Table, decltype(keys)>(tbl, std::move(keys));
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			lua_State* L = this->lua_state();
+			push(L);
+			int idx = lua_gettop(L);
+			stack_aligned_function func(L, idx);
+			return func.call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		bool valid() const {
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			lua_pop(lua_state(), p.levels);
+			return p;
+		}
+
+		int push() const noexcept {
+			return push(this->lua_state());
+		}
+
+		int push(lua_State* L) const noexcept {
+			if constexpr (std::is_same_v<meta::unqualified_t<Table>, global_table> || is_stack_table_v<meta::unqualified_t<Table>>) {
+				auto pp = stack::push_pop<true>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int top_index = lua_gettop(L);
+				stack::get_field<true>(lua_state(), key, tableindex);
+				lua_replace(L, top_index + 1);
+				lua_settop(L, top_index + 1);
+			}
+			else {
+				auto pp = stack::push_pop<false>(tbl);
+				int tableindex = pp.index_of(tbl);
+				int aftertableindex = lua_gettop(L);
+				stack::get_field<false>(lua_state(), key, tableindex);
+				lua_replace(L, tableindex);
+				lua_settop(L, aftertableindex + 1);
+			}
+			return 1;
+		}
+
+		type get_type() const {
+			type t = type::none;
+			auto pp = stack::push_pop(tbl);
+			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(lua_state(), key, lua_gettop(lua_state()));
+			if (p) {
+				t = type_of(lua_state(), -1);
+			}
+			lua_pop(lua_state(), p.levels);
+			return t;
+		}
+
+		lua_State* lua_state() const {
+			return tbl.lua_state();
+		}
+
+		table_proxy& force() {
+			if (!this->valid()) {
+				this->set(new_table());
+			}
+			return *this;
+		}
+	};
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator==(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() == left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(T&& left, const table_proxy<Table, Key>& right) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key, typename T>
+	inline bool operator!=(const table_proxy<Table, Key>& right, T&& left) {
+		using G = decltype(stack::get<T>(nullptr, 0));
+		return right.template get<optional<G>>() != left;
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator==(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return !right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(lua_nil_t, const table_proxy<Table, Key>& right) {
+		return right.valid();
+	}
+
+	template <typename Table, typename Key>
+	inline bool operator!=(const table_proxy<Table, Key>& right, lua_nil_t) {
+		return right.valid();
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(proxy_base<Super>&& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	template <bool b>
+	template <typename Super>
+	basic_reference<b>& basic_reference<b>::operator=(const proxy_base<Super>& r) {
+		basic_reference<b> v = r;
+		this->operator=(std::move(v));
+		return *this;
+	}
+
+	namespace stack {
+		template <typename Table, typename Key>
+		struct unqualified_pusher<table_proxy<Table, Key>> {
+			static int push(lua_State* L, const table_proxy<Table, Key>& p) {
+				return p.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table_proxy.hpp
+
+// beginning of sol/table_iterator.hpp
+
+#include <iterator>
+
+namespace sol {
+
+	template <typename reference_type>
+	class basic_table_iterator {
+	public:
+		typedef object key_type;
+		typedef object mapped_type;
+		typedef std::pair<object, object> value_type;
+		typedef std::input_iterator_tag iterator_category;
+		typedef std::ptrdiff_t difference_type;
+		typedef value_type* pointer;
+		typedef value_type& reference;
+		typedef const value_type& const_reference;
+
+	private:
+		std::pair<object, object> kvp;
+		reference_type ref;
+		int tableidx = 0;
+		int keyidx = 0;
+		std::ptrdiff_t idx = 0;
+
+	public:
+		basic_table_iterator() noexcept : keyidx(-1), idx(-1) {
+		}
+
+		basic_table_iterator(reference_type x) noexcept : ref(std::move(x)) {
+			ref.push();
+			tableidx = lua_gettop(ref.lua_state());
+			stack::push(ref.lua_state(), lua_nil);
+			this->operator++();
+			if (idx == -1) {
+				return;
+			}
+			--idx;
+		}
+
+		basic_table_iterator& operator++() noexcept {
+			if (idx == -1)
+				return *this;
+
+			if (lua_next(ref.lua_state(), tableidx) == 0) {
+				idx = -1;
+				keyidx = -1;
+				return *this;
+			}
+			++idx;
+			kvp.first = object(ref.lua_state(), -2);
+			kvp.second = object(ref.lua_state(), -1);
+			lua_pop(ref.lua_state(), 1);
+			// leave key on the stack
+			keyidx = lua_gettop(ref.lua_state());
+			return *this;
+		}
+
+		basic_table_iterator operator++(int) noexcept {
+			auto saved = *this;
+			this->operator++();
+			return saved;
+		}
+
+		reference operator*() const noexcept {
+			return const_cast<reference>(kvp);
+		}
+
+		bool operator==(const basic_table_iterator& right) const noexcept {
+			return idx == right.idx;
+		}
+
+		bool operator!=(const basic_table_iterator& right) const noexcept {
+			return idx != right.idx;
+		}
+
+		~basic_table_iterator() {
+			if (keyidx != -1) {
+				stack::remove(ref.lua_state(), keyidx, 1);
+			}
+			if (ref.lua_state() != nullptr && ref.valid()) {
+				stack::remove(ref.lua_state(), tableidx, 1);
+			}
+		}
+	};
+
+} // namespace sol
+
+// end of sol/table_iterator.hpp
+
+// beginning of sol/pairs_iterator.hpp
+
+// beginning of sol/stack/detail/pairs.hpp
+
+#include <optional>
+
+namespace sol { namespace stack { namespace stack_detail {
+
+	inline bool maybe_push_lua_next_function(lua_State* L_) {
+		stack::get_field<true, false>(L_, "next");
+		bool is_next = stack::check<protected_function>(L_);
+		if (is_next) {
+			return true;
+		}
+		stack::get_field<true, false>(L_, "table");
+		stack::record tracking{};
+		if (!stack::loose_table_check(L_, -1, &no_panic, tracking)) {
+			return false;
+		}
+		lua_getfield(L_, -1, "next");
+		bool is_table_next_func = stack::check<protected_function>(L_, -1);
+		if (is_table_next_func) {
+			return true;
+		}
+		lua_pop(L_, 1);
+		return false;
+	}
+
+	inline std::optional<protected_function> find_lua_next_function(lua_State* L_) {
+		if (maybe_push_lua_next_function(L_)) {
+			return stack::pop<protected_function>(L_);
+		}
+		return std::nullopt;
+	}
+
+	inline int c_lua_next(lua_State* L_) noexcept {
+		stack_reference table_stack_ref(L_, raw_index(1));
+		stateless_stack_reference key_stack_ref(L_, raw_index(2));
+		int result = lua_next(table_stack_ref.lua_state(), table_stack_ref.stack_index());
+		if (result == 0) {
+			stack::push(L_, lua_nil);
+			return 1;
+		}
+		return 2;
+	}
+
+	inline int readonly_pairs(lua_State* L_) noexcept {
+		int pushed = 0;
+		if (!maybe_push_lua_next_function(L_)) {
+			// we do not have the "next" function in the global namespace
+			// from the "table" global entiry, use our own
+			pushed += stack::push(L_, &c_lua_next);
+		}
+		else {
+			pushed += 1;
+		}
+		int metatable_exists = lua_getmetatable(L_, 1);
+		sol_c_assert(metatable_exists == 1);
+		const auto& index_key = to_string(sol::meta_function::index);
+		lua_getfield(L_, lua_gettop(L_), index_key.c_str());
+		lua_remove(L_, -2);
+		pushed += 1;
+		pushed += stack::push(L_, lua_nil);
+		return pushed;
+	}
+
+}}} // sol::stack::stack_detail
+
+// end of sol/stack/detail/pairs.hpp
+
+namespace sol {
+
+	struct pairs_sentinel { };
+
+	class pairs_iterator {
+	private:
+		inline static constexpr int empty_key_index = -1;
+
+	public:
+		using key_type = object;
+		using mapped_type = object;
+		using value_type = std::pair<object, object>;
+		using iterator_category = std::input_iterator_tag;
+		using difference_type = std::ptrdiff_t;
+		using pointer = value_type*;
+		using const_pointer = value_type const*;
+		using reference = value_type&;
+		using const_reference = const value_type&;
+
+		pairs_iterator() noexcept
+		: m_L(nullptr)
+		, m_next_function_ref(lua_nil)
+		, m_table_ref(lua_nil)
+		, m_cached_key_value_pair({ lua_nil, lua_nil })
+		, m_key_index(empty_key_index)
+		, m_iteration_index(0) {
+		}
+
+		pairs_iterator(const pairs_iterator&) = delete;
+		pairs_iterator& operator=(const pairs_iterator&) = delete;
+
+		pairs_iterator(pairs_iterator&& right) noexcept
+		: m_L(right.m_L)
+		, m_next_function_ref(std::move(right.m_next_function_ref))
+		, m_table_ref(std::move(right.m_table_ref))
+		, m_cached_key_value_pair(std::move(right.m_cached_key_value_pair))
+		, m_key_index(right.m_key_index)
+		, m_iteration_index(right.m_iteration_index) {
+			right.m_key_index = empty_key_index;
+		}
+
+		pairs_iterator& operator=(pairs_iterator&& right) noexcept {
+			m_L = right.m_L;
+			m_next_function_ref = std::move(right.m_next_function_ref);
+			m_table_ref = std::move(right.m_table_ref);
+			m_cached_key_value_pair = std::move(right.m_cached_key_value_pair);
+			m_key_index = right.m_key_index;
+			m_iteration_index = right.m_iteration_index;
+			right.m_key_index = empty_key_index;
+			return *this;
+		}
+
+		template <typename Source>
+		pairs_iterator(const Source& source_) noexcept : m_L(source_.lua_state()), m_key_index(empty_key_index), m_iteration_index(0) {
+			if (m_L == nullptr || !source_.valid()) {
+				m_key_index = empty_key_index;
+				return;
+			}
+			int source_index = -source_.push(m_L);
+			int abs_source_index = lua_absindex(m_L, source_index);
+			int metatable_exists = lua_getmetatable(m_L, abs_source_index);
+			lua_remove(m_L, abs_source_index);
+			if (metatable_exists == 1) {
+				// just has a metatable, but does it have __pairs ?
+				stack_reference metatable(m_L, raw_index(abs_source_index));
+				stack::get_field<is_global_table_v<Source>, true>(m_L, meta_function::pairs, metatable.stack_index());
+				optional<protected_function> maybe_pairs_function = stack::pop<optional<protected_function>>(m_L);
+				if (maybe_pairs_function.has_value()) {
+					protected_function& pairs_function = *maybe_pairs_function;
+					protected_function_result next_fn_and_table_and_first_key = pairs_function(source_);
+					if (next_fn_and_table_and_first_key.valid()) {
+						m_next_function_ref = next_fn_and_table_and_first_key.get<protected_function>(0);
+						m_table_ref = next_fn_and_table_and_first_key.get<sol::reference>(1);
+						m_key_index = next_fn_and_table_and_first_key.stack_index() - 1;
+						// remove next function and table
+						lua_remove(m_L, m_key_index);
+						lua_remove(m_L, m_key_index);
+						next_fn_and_table_and_first_key.abandon();
+						lua_remove(m_L, abs_source_index);
+						this->operator++();
+						m_iteration_index = 0;
+						return;
+					}
+				}
+			}
+
+			{
+				auto maybe_next = stack::stack_detail::find_lua_next_function(m_L);
+				if (maybe_next.has_value()) {
+					m_next_function_ref = std::move(*maybe_next);
+					m_table_ref = source_;
+
+					stack::push(m_L, lua_nil);
+					m_key_index = lua_gettop(m_L);
+					this->operator++();
+					m_iteration_index = 0;
+					return;
+				}
+			}
+
+			// okay, so none of the above worked and now we need to create
+			// a shim / polyfill instead
+			stack::push(m_L, &stack::stack_detail::c_lua_next);
+			m_next_function_ref = stack::pop<protected_function>(m_L);
+			m_table_ref = source_;
+			stack::push(m_L, lua_nil);
+			m_key_index = lua_gettop(m_L);
+			this->operator++();
+			m_iteration_index = 0;
+		}
+
+		pairs_iterator& operator++() {
+			if (m_key_index == empty_key_index) {
+				return *this;
+			}
+			{
+				sol::protected_function_result next_results = m_next_function_ref(m_table_ref, stack_reference(m_L, m_key_index));
+				if (!next_results.valid()) {
+					// TODO: abort, or throw an error?
+					m_clear();
+					m_key_index = empty_key_index;
+					return *this;
+				}
+				int next_results_count = next_results.return_count();
+				if (next_results_count < 2) {
+					// iteration is over!
+					next_results.abandon();
+					lua_settop(m_L, m_key_index - 1);
+					m_key_index = empty_key_index;
+					++m_iteration_index;
+					return *this;
+				}
+				else {
+					lua_remove(m_L, m_key_index);
+					m_key_index = next_results.stack_index() - 1;
+					m_cached_key_value_pair.first = stack::get<object>(m_L, m_key_index);
+					m_cached_key_value_pair.second = stack::get<object>(m_L, m_key_index + 1);
+					lua_settop(m_L, m_key_index);
+					next_results.abandon();
+				}
+			}
+			++m_iteration_index;
+			return *this;
+		}
+
+		std::ptrdiff_t index() const {
+			return static_cast<std::ptrdiff_t>(m_iteration_index);
+		}
+
+		const_reference operator*() const noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		reference operator*() noexcept {
+			return m_cached_key_value_pair;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref == right.m_table_ref && left.m_iteration_index == right.m_iteration_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_iterator& right) noexcept {
+			return left.m_table_ref != right.m_table_ref || left.m_iteration_index != right.m_iteration_index;
+		}
+
+		friend bool operator==(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_iterator& left, const pairs_sentinel&) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		friend bool operator==(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index == empty_key_index;
+		}
+
+		friend bool operator!=(const pairs_sentinel&, const pairs_iterator& left) noexcept {
+			return left.m_key_index != empty_key_index;
+		}
+
+		~pairs_iterator() {
+			if (m_key_index != empty_key_index) {
+				m_clear();
+			}
+		}
+
+	private:
+		void m_clear() noexcept {
+			lua_remove(m_L, m_key_index);
+		}
+
+		lua_State* m_L;
+		protected_function m_next_function_ref;
+		sol::reference m_table_ref;
+		std::pair<object, object> m_cached_key_value_pair;
+		int m_key_index;
+		int m_iteration_index;
+	};
+
+	template <typename Source>
+	class basic_pairs_range {
+	private:
+		using source_t = std::add_lvalue_reference_t<Source>;
+		source_t m_source;
+
+	public:
+		using iterator = pairs_iterator;
+		using const_iterator = pairs_iterator;
+
+		basic_pairs_range(source_t source_) noexcept : m_source(source_) {
+		}
+
+		iterator begin() noexcept {
+			return iterator(m_source);
+		}
+
+		iterator begin() const noexcept {
+			return iterator(m_source);
+		}
+
+		const_iterator cbegin() const noexcept {
+			return const_iterator(m_source);
+		}
+
+		pairs_sentinel end() noexcept {
+			return {};
+		}
+
+		pairs_sentinel end() const noexcept {
+			return {};
+		}
+
+		pairs_sentinel cend() const noexcept {
+			return {};
+		}
+	};
+} // namespace sol
+
+// end of sol/pairs_iterator.hpp
+
+namespace sol {
+	namespace detail {
+		template <std::size_t n>
+		struct clean {
+			lua_State* L;
+			clean(lua_State* luastate) : L(luastate) {
+			}
+			~clean() {
+				lua_pop(L, static_cast<int>(n));
+			}
+		};
+
+		struct ref_clean {
+			lua_State* L;
+			int& pop_count;
+
+			ref_clean(lua_State* L_, int& pop_count_) noexcept : L(L_), pop_count(pop_count_) {
+			}
+			~ref_clean() {
+				lua_pop(L, static_cast<int>(pop_count));
+			}
+		};
+
+		inline int fail_on_newindex(lua_State* L_) {
+			return luaL_error(L_, "sol: cannot modify the elements of an enumeration table");
+		}
+
+	} // namespace detail
+
+	template <bool top_level, typename ref_t>
+	class basic_table_core : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+		friend class state;
+		friend class state_view;
+		template <typename, typename>
+		friend class basic_usertype;
+		template <typename>
+		friend class basic_metatable;
+
+		template <typename T>
+		using is_get_direct_tableless = meta::boolean<stack::stack_detail::is_get_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_get_direct_tableless = std::false_type;
+
+		template <typename T>
+		using is_set_direct_tableless = meta::boolean<stack::stack_detail::is_set_direct_tableless_v<T, top_level, false>>;
+
+		template <typename T>
+		using is_raw_set_direct_tableless = std::false_type;
+
+		template <bool raw, typename... Ret, typename... Keys>
+		decltype(auto) tuple_get(int table_index, Keys&&... keys) const {
+			if constexpr (sizeof...(Ret) < 2) {
+				return traverse_get_single_maybe_tuple<raw, Ret...>(table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				using multi_ret = decltype(stack::pop<std::tuple<Ret...>>(nullptr));
+				return multi_ret(traverse_get_single_maybe_tuple<raw, Ret>(table_index, std::forward<Keys>(keys))...);
+			}
+		}
+
+		template <bool raw, typename Ret, size_t... I, typename Key>
+		decltype(auto) traverse_get_single_tuple(int table_index, std::index_sequence<I...>, Key&& key) const {
+			return traverse_get_single<raw, Ret>(table_index, std::get<I>(std::forward<Key>(key))...);
+		}
+
+		template <bool raw, typename Ret, typename Key>
+		decltype(auto) traverse_get_single_maybe_tuple(int table_index, Key&& key) const {
+			if constexpr (meta::is_tuple_v<meta::unqualified_t<Key>>) {
+				return traverse_get_single_tuple<raw, Ret>(
+				     table_index, std::make_index_sequence<std::tuple_size_v<meta::unqualified_t<Key>>>(), std::forward<Key>(key));
+			}
+			else {
+				return traverse_get_single<raw, Ret>(table_index, std::forward<Key>(key));
+			}
+		}
+
+		template <bool raw, typename Ret, typename... Keys>
+		decltype(auto) traverse_get_single(int table_index, Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			if constexpr (meta::is_optional_v<meta::unqualified_t<Ret>>) {
+				int popcount = 0;
+				detail::ref_clean c(base_t::lua_state(), popcount);
+				return traverse_get_deep_optional<global, raw, detail::insert_mode::none, Ret>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				detail::clean<sizeof...(Keys) - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>> c(base_t::lua_state());
+				return traverse_get_deep<global, raw, detail::insert_mode::none, Ret>(table_index, std::forward<Keys>(keys)...);
+			}
+		}
+
+		template <bool raw, typename Pairs, std::size_t... I>
+		void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
+			constexpr static bool global = (meta::count_even_for_pack_v < is_set_direct_tableless,
+			     meta::unqualified_t<decltype(std::get<I * 2>(std::forward<Pairs>(pairs)))>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)table_index;
+			(void)L;
+			void(detail::swallow { (stack::set_field<(top_level), raw>(
+			                             L, std::get<I * 2>(std::forward<Pairs>(pairs)), std::get<I * 2 + 1>(std::forward<Pairs>(pairs)), table_index),
+			     0)... });
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep(int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				(void)key;
+				return traverse_get_deep<false, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil), T>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+				if constexpr (sizeof...(Keys) > 0) {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if (t == type::lua_nil || t == type::none) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return traverse_get_deep<false, raw, mode, T>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+						type t = type_of(L, -1);
+						if ((t == type::lua_nil || t == type::none) && (is_table_like_v<T>)) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+						}
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename T, typename Key, typename... Keys>
+		decltype(auto) traverse_get_deep_optional(int& popcount, int table_index, Key&& key, Keys&&... keys) const {
+			if constexpr (std::is_same_v<meta::unqualified_t<Key>, create_if_nil_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, update_if_empty_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<meta::unqualified_t<Key>, override_value_t>) {
+				constexpr detail::insert_mode new_mode = static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value);
+				(void)key;
+				return traverse_get_deep_optional<global, raw, new_mode, T>(popcount, table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				if constexpr (sizeof...(Keys) > 0) {
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+							stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+						}
+						else {
+							return T(nullopt);
+						}
+					}
+					return traverse_get_deep_optional<false, raw, mode, T>(popcount, lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+				else {
+					using R = decltype(stack::get<T>(nullptr));
+					using value_type = typename meta::unqualified_t<R>::value_type;
+					lua_State* L = base_t::lua_state();
+					auto p = stack::probe_get_field<global, raw, value_type>(L, key, table_index);
+					popcount += p.levels;
+					if (!p.success) {
+						if constexpr ((mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							lua_pop(L, 1);
+							stack::push(L, new_table(0, 0));
+							stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							if (stack::check<value_type>(L, lua_gettop(L), &no_panic)) {
+								return stack::get<T>(L);
+							}
+						}
+						return R(nullopt);
+					}
+					return stack::get<T>(L);
+				}
+			}
+		}
+
+		template <bool global, bool raw, detail::insert_mode mode, typename Key, typename... Keys>
+		void traverse_set_deep(int table_index, Key&& key, Keys&&... keys) const {
+			using KeyU = meta::unqualified_t<Key>;
+			if constexpr (std::is_same_v<KeyU, update_if_empty_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::update_if_empty)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, create_if_nil_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::create_if_nil)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else if constexpr (std::is_same_v<KeyU, override_value_t>) {
+				(void)key;
+				traverse_set_deep<global, raw, static_cast<detail::insert_mode>(mode | detail::insert_mode::override_value)>(
+				     table_index, std::forward<Keys>(keys)...);
+			}
+			else {
+				lua_State* L = base_t::lua_state();
+				if constexpr (sizeof...(Keys) == 1) {
+					if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty) {
+						auto p = stack::probe_get_field<global, raw>(L, key, table_index);
+						lua_pop(L, p.levels);
+						if (!p.success) {
+							stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+						}
+					}
+					else {
+						stack::set_field<global, raw>(L, std::forward<Key>(key), std::forward<Keys>(keys)..., table_index);
+					}
+				}
+				else {
+					if constexpr (mode != detail::insert_mode::none) {
+						stack::get_field<global, raw>(L, key, table_index);
+						type vt = type_of(L, -1);
+						if constexpr ((mode & detail::insert_mode::update_if_empty) == detail::insert_mode::update_if_empty
+						     || (mode & detail::insert_mode::create_if_nil) == detail::insert_mode::create_if_nil) {
+							if (vt == type::lua_nil || vt == type::none) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+						else {
+							if (vt != type::table) {
+								constexpr bool is_seq = meta::count_for_to_pack_v < 1, std::is_integral, Keys... >> 0;
+								lua_pop(L, 1);
+								stack::push(L, new_table(static_cast<int>(is_seq), static_cast<int>(!is_seq)));
+								stack::set_field<global, raw>(L, std::forward<Key>(key), stack_reference(L, -1), table_index);
+							}
+						}
+					}
+					else {
+						stack::get_field<global, raw>(L, std::forward<Key>(key), table_index);
+					}
+					traverse_set_deep<false, raw, mode>(lua_gettop(L), std::forward<Keys>(keys)...);
+				}
+			}
+		}
+
+	protected:
+		basic_table_core(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+	public:
+		using iterator = basic_table_iterator<ref_t>;
+		using const_iterator = iterator;
+
+		using base_t::lua_state;
+
+		basic_table_core() noexcept = default;
+		basic_table_core(const basic_table_core&) = default;
+		basic_table_core(basic_table_core&&) = default;
+		basic_table_core& operator=(const basic_table_core&) = default;
+		basic_table_core& operator=(basic_table_core&&) = default;
+
+		basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {
+		}
+
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, const new_table& nt) : base_t(L, -stack::push(L, nt)) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+
+		basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_table_core>(L, index, handler);
+#endif // Safety
+		}
+
+		basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			constructor_handler handler {};
+			stack::check<basic_table_core>(lua_state(), table_index, handler);
+#endif // Safety
+		}
+
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				constructor_handler handler {};
+				stack::check<basic_table_core>(lua_state(), table_index, handler);
+			}
+#endif // Safety
+		}
+
+		basic_table_core(lua_nil_t r) noexcept : basic_table_core(detail::no_safety, r) {
+		}
+
+		basic_table_core(lua_State* L, global_tag_t t) noexcept : base_t(L, t) {
+		}
+
+		iterator begin() const {
+			if (this->get_type() == type::table) {
+				return iterator(*this);
+			}
+			return iterator();
+		}
+
+		iterator end() const {
+			return iterator();
+		}
+
+		const_iterator cbegin() const {
+			return begin();
+		}
+
+		const_iterator cend() const {
+			return end();
+		}
+
+		basic_pairs_range<basic_table_core> pairs() noexcept {
+			return basic_pairs_range<basic_table_core>(*this);
+		}
+
+		basic_pairs_range<const basic_table_core> pairs() const noexcept {
+			return basic_pairs_range<const basic_table_core>(*this);
+		}
+
+		void clear() {
+			auto pp = stack::push_pop<false>(*this);
+			int table_index = pp.index_of(*this);
+			stack::clear(lua_state(), table_index);
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = meta::all<meta::boolean<top_level>, is_get_direct_tableless<meta::unqualified_t<Keys>>...>::value;
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<false, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(get<T>("")) U;
+			optional<U> option = get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) > 0, "must pass at least 1 key to get");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<false, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_set(Keys&&... keys) {
+			static_assert(sizeof...(Keys) > 1, "must pass at least 1 key and 1 value to set");
+			constexpr static bool global
+			     = (meta::count_when_for_to_pack_v < detail::is_not_insert_mode, 1, is_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, false, detail::insert_mode::none>(table_index, std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& set(Args&&... args) {
+			if constexpr (sizeof...(Args) == 2) {
+				traverse_set(std::forward<Args>(args)...);
+			}
+			else {
+				tuple_set<false>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			}
+			return *this;
+		}
+
+		template <typename... Ret, typename... Keys>
+		decltype(auto) raw_get(Keys&&... keys) const {
+			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return tuple_get<true, Ret...>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) raw_get_or(Key&& key, T&& otherwise) const {
+			typedef decltype(raw_get<T>("")) U;
+			optional<U> option = raw_get<optional<U>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<U>(option.value());
+			}
+			return static_cast<U>(std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) raw_get_or(Key&& key, D&& otherwise) const {
+			optional<T> option = raw_get<optional<T>>(std::forward<Key>(key));
+			if (option) {
+				return static_cast<T>(option.value());
+			}
+			return static_cast<T>(std::forward<D>(otherwise));
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_raw_get(Keys&&... keys) const {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_get_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			int table_index = pp.index_of(*this);
+			return traverse_get_single<true, T>(table_index, std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Keys>
+		basic_table_core& traverse_raw_set(Keys&&... keys) {
+			constexpr static bool global = (meta::count_for_to_pack_v < 1, is_raw_set_direct_tableless, meta::unqualified_t<Keys>... >> 0);
+			auto pp = stack::push_pop<global>(*this);
+			lua_State* L = base_t::lua_state();
+			auto pn = stack::pop_n(L, static_cast<int>(sizeof...(Keys) - 2 - meta::count_for_pack_v<detail::is_insert_mode, meta::unqualified_t<Keys>...>));
+			traverse_set_deep<top_level, true, false>(std::forward<Keys>(keys)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& raw_set(Args&&... args) {
+			tuple_set<true>(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+			return *this;
+		}
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key);
+
+		template <typename Class, typename Key, automagic_flags enrollment_flags>
+		usertype<Class> new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollment);
+
+		template <typename Class, typename Key>
+		usertype<Class> new_usertype(Key&& key, automagic_enrollments enrollment);
+
+		template <typename Class, typename Key, typename Arg, typename... Args,
+		     typename = std::enable_if_t<!std::is_base_of_v<automagic_enrollments, meta::unqualified_t<Arg>>>>
+		usertype<Class> new_usertype(Key&& key, Arg&& arg, Args&&... args);
+
+		template <bool read_only = true, typename... Args>
+		table new_enum(const string_view& name, Args&&... args) {
+			table target = create_with(std::forward<Args>(args)...);
+			if constexpr (read_only) {
+				// Need to create a special iterator to handle this
+				table x
+				     = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target, meta_function::pairs, stack::stack_detail::readonly_pairs);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename T, bool read_only = true>
+		table new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			table target = create(static_cast<int>(items.size()), static_cast<int>(0));
+			for (const auto& kvp : items) {
+				target.set(kvp.first, kvp.second);
+			}
+			if constexpr (read_only) {
+				table x = create_with(meta_function::new_index, detail::fail_on_newindex, meta_function::index, target);
+				table shim = create_named(name, metatable_key, x);
+				return shim;
+			}
+			else {
+				set(name, target);
+				return target;
+			}
+		}
+
+		template <typename Key = object, typename Value = object, typename Fx>
+		void for_each(Fx&& fx) const {
+			lua_State* L = base_t::lua_state();
+			if constexpr (std::is_invocable_v<Fx, Key, Value>) {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					fx(key, value);
+				}
+			}
+			else {
+				auto pp = stack::push_pop(*this);
+				int table_index = pp.index_of(*this);
+				stack::push(L, lua_nil);
+				while (lua_next(L, table_index)) {
+					Key key(L, -2);
+					Value value(L, -1);
+					auto pn = stack::pop_n(L, 1);
+					std::pair<Key&, Value&> keyvalue(key, value);
+					fx(keyvalue);
+				}
+			}
+		}
+
+		size_t size() const {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			lua_len(L, table_index);
+			return stack::pop<size_t>(L);
+		}
+
+		bool empty() const {
+			return cbegin() == cend();
+		}
+
+		template <typename T>
+		auto operator[](T&& key) & {
+			return table_proxy<basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) const& {
+			return table_proxy<const basic_table_core&, detail::proxy_key_t<T>>(*this, std::forward<T>(key));
+		}
+
+		template <typename T>
+		auto operator[](T&& key) && {
+			return table_proxy<basic_table_core, detail::proxy_key_t<T>>(std::move(*this), std::forward<T>(key));
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_table_core& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args>
+		basic_table_core& add(Args&&... args) {
+			auto pp = stack::push_pop(*this);
+			int table_index = pp.index_of(*this);
+			lua_State* L = base_t::lua_state();
+			(void)detail::swallow { 0, (stack::stack_detail::raw_table_set(L, std::forward<Args>(args), table_index), 0)... };
+			return *this;
+		}
+
+	private:
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			lua_createtable(L, narr, nrec);
+			table result(L);
+			result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			lua_pop(L, 1);
+			return result;
+		}
+
+		template <typename... Args>
+		static inline table create_with(lua_State* L, Args&&... args) {
+			static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
+			constexpr int narr = static_cast<int>(meta::count_odd_for_pack_v<std::is_integral, Args...>);
+			return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
+		}
+
+		table create(int narr = 0, int nrec = 0) {
+			return create(base_t::lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name>
+		table create(Name&& name, int narr = 0, int nrec = 0) {
+			table x = create(base_t::lua_state(), narr, nrec);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+			this->set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		template <typename... Args>
+		table create_with(Args&&... args) {
+			return create_with(base_t::lua_state(), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named(Name&& name, Args&&... args) {
+			static const int narr = static_cast<int>(meta::count_even_for_pack_v<std::is_integral, Args...>);
+			return create(std::forward<Name>(name), narr, (sizeof...(Args) / 2) - narr, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/table_core.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	class basic_metatable : public basic_table<base_type> {
+		typedef basic_table<base_type> base_t;
+		friend class state;
+		friend class state_view;
+
+	protected:
+		basic_metatable(detail::no_safety_tag, lua_nil_t n) : base_t(n) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {
+		}
+		basic_metatable(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(detail::no_safety_tag, lua_State* L, T&& r) noexcept : base_t(L, std::forward<T>(r)) {
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_metatable() noexcept = default;
+		basic_metatable(const basic_metatable&) = default;
+		basic_metatable(basic_metatable&&) = default;
+		basic_metatable& operator=(const basic_metatable&) = default;
+		basic_metatable& operator=(basic_metatable&&) = default;
+		basic_metatable(const stack_reference& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		basic_metatable(stack_reference&& r) : basic_metatable(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, int index = -1) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_metatable>(L, index, handler);
+#endif // Safety
+		}
+		basic_metatable(lua_State* L, ref_index index) : basic_metatable(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_metatable>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_metatable>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_metatable(T&& r) noexcept : basic_metatable(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_metatable>(base_t::lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_metatable(lua_nil_t r) noexcept : basic_metatable(detail::no_safety, r) {
+		}
+
+		template <typename Key, typename Value>
+		basic_metatable<base_type>& set(Key&& key, Value&& value);
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_metatable& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		void unregister() {
+			using ustorage_base = u_detail::usertype_storage_base;
+
+			lua_State* L = this->lua_state();
+
+			auto pp = stack::push_pop(*this);
+			int top = lua_gettop(L);
+
+			stack_reference mt(L, -1);
+			stack::get_field(L, meta_function::gc_names, mt.stack_index());
+			if (type_of(L, -1) != type::table) {
+				lua_settop(L, top);
+				return;
+			}
+			stack_reference gc_names_table(L, -1);
+			stack::get_field(L, meta_function::storage, mt.stack_index());
+			if (type_of(L, -1) != type::lightuserdata) {
+				lua_settop(L, top);
+				return;
+			}
+			ustorage_base& base_storage = *static_cast<ustorage_base*>(stack::get<void*>(L, -1));
+			std::array<string_view, 6> registry_traits;
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				stack::get_field<false, true>(L, smt, gc_names_table.stack_index());
+				registry_traits[i] = stack::get<string_view>(L, -1);
+			}
+
+			// get the registry
+			stack_reference registry(L, raw_index(LUA_REGISTRYINDEX));
+			registry.push();
+			// eliminate all named entries for this usertype
+			// in the registry (luaL_newmetatable does
+			// [name] = new table
+			// in registry upon creation)
+			for (std::size_t i = 0; i < registry_traits.size(); ++i) {
+				u_detail::submetatable_type smt = static_cast<u_detail::submetatable_type>(i);
+				const string_view& gcmetakey = registry_traits[i];
+				if (smt == u_detail::submetatable_type::named) {
+					// use .data() to make it treat it like a c string,
+					// which it is...
+					stack::set_field<true>(L, gcmetakey.data(), lua_nil);
+				}
+				else {
+					// do not change the values in the registry: they need to be present
+					// no matter what, for safety's sake
+					// stack::set_field(L, gcmetakey, lua_nil, registry.stack_index());
+				}
+			}
+
+			// destroy all storage and tables
+			base_storage.clear();
+
+			// 6 strings from gc_names table,
+			// + 1 registry,
+			// + 1 gc_names table
+			// + 1 light userdata of storage
+			// + 1 registry
+			// 10 total, 4 left since popping off 6 gc_names tables
+			lua_settop(L, top);
+		}
+	};
+
+} // namespace sol
+
+// end of sol/metatable.hpp
+
+namespace sol {
+
+	template <typename T, typename base_type>
+	class basic_usertype : private basic_metatable<base_type> {
+	private:
+		using base_t = basic_metatable<base_type>;
+		using table_base_t = basic_table<base_type>;
+
+		template <typename>
+		friend class basic_metatable;
+
+		template <bool, typename>
+		friend class basic_table_core;
+
+		template <std::size_t... I, typename... Args>
+		void tuple_set(std::index_sequence<I...>, std::tuple<Args...>&& args) {
+			(void)args;
+			(void)detail::swallow { 0, (this->set(std::get<I * 2>(std::move(args)), std::get<I * 2 + 1>(std::move(args))), 0)... };
+		}
+
+		template <typename R, typename... Args, typename Fx, typename Key, typename = std::invoke_result_t<Fx, Args...>>
+		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
+			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, meta::enable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx) {
+			set(std::forward<Key>(key), std::forward<Fx>(fx));
+		}
+
+		template <typename Fx, typename Key, typename... Args,
+		     meta::disable<meta::is_specialization_of<meta::unqualified_t<Fx>, overload_set>> = meta::enabler>
+		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
+		}
+
+		template <typename... Sig, typename... Args, typename Key>
+		void set_resolved_function(Key&& key, Args&&... args) {
+			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
+		}
+
+	public:
+		using base_t::base_t;
+
+		using base_t::get;
+		using base_t::lua_state;
+		using base_t::pop;
+		using base_t::push;
+		using base_t::traverse_get;
+		using base_t::traverse_set;
+		using base_t::unregister;
+
+		template <typename Key, typename Value>
+		basic_usertype& set(Key&& key, Value&& value) {
+			optional<u_detail::usertype_storage<T>&> maybe_uts = u_detail::maybe_get_usertype_storage<T>(this->lua_state());
+			if (maybe_uts) {
+				u_detail::usertype_storage<T>& uts = *maybe_uts;
+				uts.set(this->lua_state(), std::forward<Key>(key), std::forward<Value>(value));
+			}
+			else {
+				using ValueU = meta::unqualified_t<Value>;
+				// cannot get metatable: try regular table set?
+				if constexpr (detail::is_non_factory_constructor_v<ValueU> || detail::is_policy_v<ValueU>) {
+					// tag constructors so we don't get destroyed by lack of info
+					table_base_t::set(std::forward<Key>(key), detail::tagged<T, Value>(std::forward<Value>(value)));
+				}
+				else {
+					table_base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+				}
+			}
+			return *this;
+		}
+
+		template <typename Sig, typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key, typename... Args>
+		basic_usertype& set_function(Key&& key, Args&&... args) {
+			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Key>
+		usertype_proxy<basic_usertype&, std::decay_t<Key>> operator[](Key&& key) {
+			return usertype_proxy<basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+
+		template <typename Key>
+		usertype_proxy<const basic_usertype&, std::decay_t<Key>> operator[](Key&& key) const {
+			return usertype_proxy<const basic_usertype&, std::decay_t<Key>>(*this, std::forward<Key>(key));
+		}
+	};
+
+} // namespace sol
+
+// end of sol/usertype.hpp
+
+// beginning of sol/table.hpp
+
+// beginning of sol/lua_table.hpp
+
+namespace sol {
+
+	template <typename ref_t>
+	struct basic_lua_table : basic_table_core<false, ref_t> {
+	private:
+		using base_t = basic_table_core<false, ref_t>;
+
+		friend class state;
+		friend class state_view;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lua_table() noexcept = default;
+		basic_lua_table(const basic_lua_table&) = default;
+		basic_lua_table(basic_lua_table&&) = default;
+		basic_lua_table& operator=(const basic_lua_table&) = default;
+		basic_lua_table& operator=(basic_lua_table&&) = default;
+		basic_lua_table(const stack_reference& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		basic_lua_table(stack_reference&& r) : basic_lua_table(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable_any<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, const new_table& nt) : base_t(L, nt) {
+			if (!is_stack_based<meta::unqualified_t<ref_t>>::value) {
+				lua_pop(L, 1);
+			}
+		}
+		basic_lua_table(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(L, index, handler);
+#endif // Safety
+		}
+		basic_lua_table(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lua_table>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_lua_table>>, meta::neg<std::is_same<ref_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lua_table(T&& r) noexcept : basic_lua_table(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_table<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_lua_table>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_lua_table(lua_nil_t r) noexcept : basic_lua_table(detail::no_safety, r) {
+		}
+	};
+
+} // namespace sol
+
+// end of sol/lua_table.hpp
+
+namespace sol {
+	typedef table_core<false> table;
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key) {
+		constant_automagic_enrollments<> enrollments {};
+		return this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, automagic_flags enrollment_flags>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, constant_automagic_enrollments<enrollment_flags> enrollments) {
+		int mt_index = u_detail::register_usertype<Class, enrollment_flags>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, automagic_enrollments enrollments) {
+		int mt_index = u_detail::register_usertype<Class, automagic_flags::all>(this->lua_state(), std::move(enrollments));
+		usertype<Class> mt(this->lua_state(), -mt_index);
+		lua_pop(this->lua_state(), 1);
+		set(std::forward<Key>(key), mt);
+		return mt;
+	}
+
+	template <bool is_global, typename base_type>
+	template <typename Class, typename Key, typename Arg, typename... Args, typename>
+	usertype<Class> basic_table_core<is_global, base_type>::new_usertype(Key&& key, Arg&& arg, Args&&... args) {
+		constexpr automagic_flags enrollment_flags = meta::any_same_v<no_construction, meta::unqualified_t<Arg>, meta::unqualified_t<Args>...>
+		     ? clear_flags(automagic_flags::all, automagic_flags::default_constructor)
+		     : automagic_flags::all;
+		constant_automagic_enrollments<enrollment_flags> enrollments;
+		enrollments.default_constructor = !detail::any_is_constructor_v<Arg, Args...>;
+		enrollments.destructor = !detail::any_is_destructor_v<Arg, Args...>;
+		usertype<Class> ut = this->new_usertype<Class>(std::forward<Key>(key), std::move(enrollments));
+		static_assert(sizeof...(Args) % 2 == static_cast<std::size_t>(!detail::any_is_constructor_v<Arg>),
+		     "you must pass an even number of arguments to new_usertype after first passing a constructor");
+		if constexpr (detail::any_is_constructor_v<Arg>) {
+			ut.set(meta_function::construct, std::forward<Arg>(arg));
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args)) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
+		}
+		else {
+			ut.tuple_set(std::make_index_sequence<(sizeof...(Args) + 1) / 2>(), std::forward_as_tuple(std::forward<Arg>(arg), std::forward<Args>(args)...));
+		}
+		return ut;
+	}
+
+	template <typename base_type>
+	template <typename Key, typename Value>
+	basic_metatable<base_type>& basic_metatable<base_type>::set(Key&& key, Value&& value) {
+		this->push();
+		lua_State* L = this->lua_state();
+		int target = lua_gettop(L);
+		optional<u_detail::usertype_storage_base&> maybe_uts = nullopt;
+		maybe_uts = u_detail::maybe_get_usertype_storage_base(L, target);
+		if (maybe_uts) {
+			u_detail::usertype_storage_base& uts = *maybe_uts;
+			uts.set(L, std::forward<Key>(key), std::forward<Value>(value));
+			return *this;
+		}
+		else {
+			base_t::set(std::forward<Key>(key), std::forward<Value>(value));
+		}
+		this->pop();
+		return *this;
+	}
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<metatable_key_t> {
+			static metatable get(lua_State* L, int index = -1) {
+				if (lua_getmetatable(L, index) == 0) {
+					return metatable(L, ref_index(LUA_REFNIL));
+				}
+				return metatable(L, -1);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/table.hpp
+
+// beginning of sol/state.hpp
+
+// beginning of sol/state_view.hpp
+
+// beginning of sol/environment.hpp
+
+namespace sol {
+
+	template <typename base_type>
+	struct basic_environment : basic_table<base_type> {
+	private:
+		typedef basic_table<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_environment() noexcept = default;
+		basic_environment(const basic_environment&) = default;
+		basic_environment(basic_environment&&) = default;
+		basic_environment& operator=(const basic_environment&) = default;
+		basic_environment& operator=(basic_environment&&) = default;
+		basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+		basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {
+		}
+
+		basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {
+		}
+		template <bool b>
+		basic_environment(lua_State* L, new_table t, const basic_reference<b>& fallback) : basic_environment(L, std::move(t)) {
+			stack_table mt(L, new_table(0, 1));
+			mt.set(meta_function::index, fallback);
+			this->set(metatable_key, mt);
+			mt.pop();
+		}
+
+		basic_environment(env_key_t, const stack_reference& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		template <bool b>
+		basic_environment(env_key_t, const basic_reference<b>& extraction_target)
+		: base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<env_key_t>(this->lua_state(), -1, handler);
+#endif // Safety
+			lua_pop(this->lua_state(), 1);
+		}
+		basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, index, handler);
+#endif // Safety
+		}
+		basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_environment>(L, -1, handler);
+#endif // Safety
+		}
+		template <typename T,
+		     meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+		basic_environment(lua_nil_t r) noexcept : base_t(detail::no_safety, r) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_environment(lua_State* L, T&& r) noexcept : base_t(detail::no_safety, L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_environment<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_environment>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		template <typename T>
+		bool set_on(const T& target) const {
+			lua_State* L = target.lua_state();
+			auto pp = stack::push_pop(target);
+			int target_index = pp.index_of(target);
+#if SOL_LUA_VERSION_I_ < 502
+			// Use lua_setfenv
+			this->push();
+			int success_result = lua_setfenv(L, target_index);
+			return success_result != 0;
+#else
+			// If this is a C function, the environment is always placed in
+			// the first value, as is expected of sol2 (all upvalues have an empty name, "")
+			if (lua_iscfunction(L, target_index) != 0) {
+				const char* maybe_upvalue_name = lua_getupvalue(L, target_index, 1);
+				if (maybe_upvalue_name == nullptr) {
+					return false;
+				}
+				string_view upvalue_name(maybe_upvalue_name);
+				if (upvalue_name == "") {
+					this->push();
+					const char* success = lua_setupvalue(L, target_index, 1);
+					if (success == nullptr) {
+						// left things alone on the stack, pop them off
+						lua_pop(L, 2);
+						return false;
+					}
+					lua_pop(L, 1);
+					return true;
+				}
+				lua_pop(L, 1);
+				return false;
+			}
+			else {
+				// Must search for the right upvalue target on index
+				for (int upvalue_index = 1;; ++upvalue_index) {
+					const char* maybe_upvalue_name = lua_getupvalue(L, target_index, upvalue_index);
+					if (maybe_upvalue_name == nullptr) {
+						break;
+					}
+					string_view upvalue_name(maybe_upvalue_name);
+					if (upvalue_name == "_ENV") {
+						lua_pop(L, 1);
+						this->push();
+						const char* success = lua_setupvalue(L, target_index, upvalue_index);
+						if (success == nullptr) {
+							// left things alone on the stack, pop them off
+							lua_pop(L, 1);
+							break;
+						}
+						// whether or not we succeeded, we found _ENV
+						// so we need to break
+						return true;
+					}
+					lua_pop(L, 1);
+				}
+				// if we get here,
+				// we did not find an _ENV here...
+				return false;
+			}
+#endif
+		}
+	};
+
+	template <typename T, typename E>
+	bool set_environment(const basic_environment<E>& env, const T& target) {
+		return env.set_on(target);
+	}
+
+	template <typename E = reference, typename T>
+	basic_environment<E> get_environment(const T& target) {
+		lua_State* L = target.lua_state();
+		auto pp = stack::pop_n(L, stack::push_environment_of(target));
+		return basic_environment<E>(L, -1);
+	}
+
+	struct this_environment {
+		optional<environment> env;
+
+		this_environment() : env(nullopt) {
+		}
+		this_environment(environment e) : env(std::move(e)) {
+		}
+		this_environment(const this_environment&) = default;
+		this_environment(this_environment&&) = default;
+		this_environment& operator=(const this_environment&) = default;
+		this_environment& operator=(this_environment&&) = default;
+
+		explicit operator bool() const {
+			return static_cast<bool>(env);
+		}
+
+		operator optional<environment>&() {
+			return env;
+		}
+
+		operator const optional<environment>&() const {
+			return env;
+		}
+
+		operator environment&() {
+			return env.value();
+		}
+
+		operator const environment&() const {
+			return env.value();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<env_key_t> {
+			static environment get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				return get_environment(stack_reference(L, raw_index(index)));
+			}
+		};
+
+		template <>
+		struct unqualified_getter<this_environment> {
+			static this_environment get(lua_State* L, int, record& tracking) {
+				tracking.use(0);
+				lua_Debug info;
+				// Level 0 means current function (this C function, which may or may not be useful for us?)
+				// Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
+				int pre_stack_size = lua_gettop(L);
+				if (lua_getstack(L, 1, &info) != 1) {
+					if (lua_getstack(L, 0, &info) != 1) {
+						lua_settop(L, pre_stack_size);
+						return this_environment();
+					}
+				}
+				if (lua_getinfo(L, "f", &info) == 0) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+
+				stack_reference f(L, -1);
+				environment env(env_key, f);
+				if (!env.valid()) {
+					lua_settop(L, pre_stack_size);
+					return this_environment();
+				}
+				return this_environment(std::move(env));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/environment.hpp
+
+// beginning of sol/load_result.hpp
+
+#include <cstdint>
+
+namespace sol {
+	struct load_result : public proxy_base<load_result> {
+	private:
+		lua_State* L;
+		int index;
+		int returncount;
+		int popcount;
+		load_status err;
+
+	public:
+		load_result() noexcept : load_result(nullptr) {}
+		load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept
+		: L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
+		}
+
+		// We do not want anyone to copy these around willy-nilly
+		// Will likely break people, but also will probably get rid of quiet bugs that have
+		// been lurking. (E.g., Vanilla Lua will just quietly discard over-pops and under-pops:
+		// LuaJIT and other Lua engines will implode and segfault at random later times.)
+		load_result(const load_result&) = delete;
+		load_result& operator=(const load_result&) = delete;
+
+		load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+		}
+		load_result& operator=(load_result&& o) noexcept {
+			L = o.L;
+			index = o.index;
+			returncount = o.returncount;
+			popcount = o.popcount;
+			err = o.err;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but we will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.returncount = 0;
+			o.popcount = 0;
+			o.err = load_status::syntax;
+			return *this;
+		}
+
+		load_status status() const noexcept {
+			return err;
+		}
+
+		bool valid() const noexcept {
+			return status() == load_status::ok;
+		}
+
+		template <typename T>
+		T get() const {
+			using UT = meta::unqualified_t<T>;
+			if constexpr (meta::is_optional_v<UT>) {
+				using ValueType = typename UT::value_type;
+				if constexpr (std::is_same_v<ValueType, error>) {
+					if (valid()) {
+						return UT(nullopt);
+					}
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+					if (!valid()) {
+						return UT(nullopt);
+					}
+					return stack::get<UT>(L, index);
+				}
+			}
+			else {
+				if constexpr (std::is_same_v<T, error>) {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none, "expecting an error type (a string, from Lua)");
+					}
+#endif // Check proxy type's safety
+					return error(detail::direct_error, stack::get<std::string>(L, index));
+				}
+				else {
+#if SOL_IS_ON(SOL_SAFE_PROXIES)
+					if (!valid()) {
+						type_panic_c_str(L, index, type_of(L, index), type::none);
+					}
+#endif // Check proxy type's safety
+					return stack::get<T>(L, index);
+				}
+			}
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		decltype(auto) operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		};
+		int stack_index() const noexcept {
+			return index;
+		};
+
+		~load_result() {
+			if (L != nullptr) {
+				stack::remove(L, index, popcount);
+			}
+		}
+	};
+} // namespace sol
+
+// end of sol/load_result.hpp
+
+// beginning of sol/state_handling.hpp
+
+// beginning of sol/lua_value.hpp
+
+namespace sol {
+	struct lua_value {
+	public:
+		struct arr : detail::ebco<std::initializer_list<lua_value>> {
+		private:
+			using base_t = detail::ebco<std::initializer_list<lua_value>>;
+
+		public:
+			using base_t::base_t;
+		};
+
+	private:
+		template <typename T>
+		using is_reference_or_lua_value_init_list
+		     = meta::any<meta::is_specialization_of<T, std::initializer_list>, std::is_same<T, reference>, std::is_same<T, arr>>;
+
+		template <typename T>
+		using is_lua_value_single_constructible = meta::any<std::is_same<T, lua_value>, is_reference_or_lua_value_init_list<T>>;
+
+		static lua_State*& thread_local_lua_state() {
+#if SOL_IS_ON(SOL_USE_THREAD_LOCAL)
+			static thread_local lua_State* L = nullptr;
+#else
+			static lua_State* L = nullptr;
+#endif
+			return L;
+		}
+
+		reference ref_value;
+
+	public:
+		static void set_lua_state(lua_State* L) {
+			thread_local_lua_state() = L;
+		}
+
+		template <typename T, meta::disable<is_reference_or_lua_value_init_list<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(lua_State* L_, T&& value) : lua_value(((set_lua_state(L_)), std::forward<T>(value))) {
+		}
+
+		template <typename T, meta::disable<is_lua_value_single_constructible<meta::unqualified_t<T>>> = meta::enabler>
+		lua_value(T&& value) : ref_value(make_reference(thread_local_lua_state(), std::forward<T>(value))) {
+		}
+
+		lua_value(lua_State* L_, std::initializer_list<std::pair<lua_value, lua_value>> il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(std::initializer_list<std::pair<lua_value, lua_value>> il) : ref_value(make_reference(thread_local_lua_state(), std::move(il))) {
+		}
+
+		lua_value(lua_State* L_, arr il)
+		: lua_value([&L_, &il]() {
+			set_lua_state(L_);
+			return std::move(il);
+		}()) {
+		}
+
+		lua_value(arr il) : ref_value(make_reference(thread_local_lua_state(), std::move(il.value()))) {
+		}
+
+		lua_value(lua_State* L_, reference r)
+		: lua_value([&L_, &r]() {
+			set_lua_state(L_);
+			return std::move(r);
+		}()) {
+		}
+
+		lua_value(reference r) : ref_value(std::move(r)) {
+		}
+
+		lua_value(const lua_value&) noexcept = default;
+		lua_value(lua_value&&) = default;
+		lua_value& operator=(const lua_value&) = default;
+		lua_value& operator=(lua_value&&) = default;
+
+		const reference& value() const& {
+			return ref_value;
+		}
+
+		reference& value() & {
+			return ref_value;
+		}
+
+		reference&& value() && {
+			return std::move(ref_value);
+		}
+
+		template <typename T>
+		decltype(auto) as() const {
+			ref_value.push();
+			return stack::pop<T>(ref_value.lua_state());
+		}
+
+		template <typename T>
+		bool is() const {
+			int r = ref_value.registry_index();
+			if (r == LUA_REFNIL)
+				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
+			if (r == LUA_NOREF)
+				return false;
+			auto pp = stack::push_pop(ref_value);
+			return stack::check<T>(ref_value.lua_state(), -1, &no_panic);
+		}
+	};
+
+	using array_value = typename lua_value::arr;
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_value> {
+			static int push(lua_State* L, const lua_value& lv) {
+				return stack::push(L, lv.value());
+			}
+
+			static int push(lua_State* L, lua_value&& lv) {
+				return stack::push(L, std::move(lv).value());
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_value> {
+			static lua_value get(lua_State* L, int index, record& tracking) {
+				return lua_value(L, stack::get<reference>(L, index, tracking));
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/lua_value.hpp
+
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+#include <iostream>
+#endif
+
+namespace sol {
+	inline void register_main_thread(lua_State* L) {
+#if SOL_LUA_VERSION_I_ < 502
+		if (L == nullptr) {
+			lua_pushnil(L);
+			lua_setglobal(L, detail::default_main_thread_name());
+			return;
+		}
+		lua_pushthread(L);
+		lua_setglobal(L, detail::default_main_thread_name());
+#else
+		(void)L;
+#endif
+	}
+
+	inline int default_at_panic(lua_State* L) {
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		(void)L;
+		return -1;
+#else
+		size_t messagesize;
+		const char* message = lua_tolstring(L, -1, &messagesize);
+		if (message) {
+			std::string err(message, messagesize);
+			lua_settop(L, 0);
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+			std::cerr << "[sol2] An error occurred and panic has been invoked: ";
+			std::cerr << err;
+			std::cerr << std::endl;
+#endif
+			throw error(err);
+		}
+		lua_settop(L, 0);
+		throw error(std::string("An unexpected error occurred and panic has been invoked"));
+#endif // Printing Errors
+	}
+
+	inline int default_traceback_error_handler(lua_State* L) {
+		std::string msg = "An unknown error has triggered the default error handler";
+		optional<string_view> maybetopmsg = stack::unqualified_check_get<string_view>(L, 1, &no_panic);
+		if (maybetopmsg) {
+			const string_view& topmsg = maybetopmsg.value();
+			msg.assign(topmsg.data(), topmsg.size());
+		}
+		luaL_traceback(L, L, msg.c_str(), 1);
+		optional<string_view> maybetraceback = stack::unqualified_check_get<string_view>(L, -1, &no_panic);
+		if (maybetraceback) {
+			const string_view& traceback = maybetraceback.value();
+			msg.assign(traceback.data(), traceback.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		// std::cerr << "[sol2] An error occurred and was caught in traceback: ";
+		// std::cerr << msg;
+		// std::cerr << std::endl;
+#endif // Printing
+		return stack::push(L, msg);
+	}
+
+	inline void set_default_state(lua_State* L, lua_CFunction panic_function = &default_at_panic,
+	     lua_CFunction traceback_function = c_call<decltype(&default_traceback_error_handler), &default_traceback_error_handler>,
+	     exception_handler_function exf = detail::default_exception_handler) {
+		lua_atpanic(L, panic_function);
+		protected_function::set_default_handler(object(L, in_place, traceback_function));
+		set_default_exception_handler(L, exf);
+		register_main_thread(L);
+		stack::luajit_exception_handler(L);
+		lua_value::set_lua_state(L);
+	}
+
+	inline std::size_t total_memory_used(lua_State* L) {
+		std::size_t kb = static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNT, 0));
+		kb *= 1024;
+		kb += static_cast<std::size_t>(lua_gc(L, LUA_GCCOUNTB, 0));
+		return kb;
+	}
+
+	inline protected_function_result script_pass_on_error(lua_State*, protected_function_result result) {
+		return result;
+	}
+
+	inline protected_function_result script_throw_on_error(lua_State* L, protected_function_result result) {
+		type t = type_of(L, result.stack_index());
+		std::string err = "sol: ";
+		err += to_string(result.status());
+		err += " error";
+#if SOL_IS_ON(SOL_EXCEPTIONS)
+		std::exception_ptr eptr = std::current_exception();
+		if (eptr) {
+			err += " with a ";
+			try {
+				std::rethrow_exception(eptr);
+			}
+			catch (const std::exception& ex) {
+				err += "std::exception -- ";
+				err.append(ex.what());
+			}
+			catch (const std::string& message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (const char* message) {
+				err += "thrown message -- ";
+				err.append(message);
+			}
+			catch (...) {
+				err.append("thrown but unknown type, cannot serialize into error message");
+			}
+		}
+#endif // serialize exception information if possible
+		if (t == type::string) {
+			err += ": ";
+			string_view serr = stack::unqualified_get<string_view>(L, result.stack_index());
+			err.append(serr.data(), serr.size());
+		}
+#if SOL_IS_ON(SOL_PRINT_ERRORS)
+		std::cerr << "[sol2] An error occurred and has been passed to an error handler: ";
+		std::cerr << err;
+		std::cerr << std::endl;
+#endif
+		// replacing information of stack error into pfr
+		int target = result.stack_index();
+		if (result.pop_count() > 0) {
+			stack::remove(L, target, result.pop_count());
+		}
+		stack::push(L, err);
+		int top = lua_gettop(L);
+		int towards = top - target;
+		if (towards != 0) {
+			lua_rotate(L, top, towards);
+		}
+#if SOL_IS_OFF(SOL_EXCEPTIONS)
+		return result;
+#else
+		// just throw our error
+		throw error(detail::direct_error, err);
+#endif // If exceptions are allowed
+	}
+
+	inline protected_function_result script_default_on_error(lua_State* L, protected_function_result pfr) {
+#if SOL_IS_ON(SOL_DEFAULT_PASS_ON_ERROR)
+		return script_pass_on_error(L, std::move(pfr));
+#else
+		return script_throw_on_error(L, std::move(pfr));
+#endif
+	}
+
+	namespace stack {
+		inline error get_traceback_or_errors(lua_State* L) {
+			int p = default_traceback_error_handler(L);
+			sol::error err = stack::get<sol::error>(L, -p);
+			lua_pop(L, p);
+			return err;
+		}
+	} // namespace stack
+} // namespace sol
+
+// end of sol/state_handling.hpp
+
+#include <memory>
+#include <cstddef>
+
+namespace sol {
+
+	class state_view {
+	private:
+		lua_State* L;
+		table reg;
+		global_table global;
+
+		optional<object> is_loaded_package(const std::string& key) {
+			auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
+			bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
+			if (is53mod)
+				return loaded;
+#if SOL_LUA_VERSION_I_ <= 501
+			auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
+			bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
+			if (is51mod)
+				return loaded51;
+#endif
+			return nullopt;
+		}
+
+		template <typename T>
+		void ensure_package(const std::string& key, T&& sr) {
+#if SOL_LUA_VERSION_I_ <= 501
+			auto pkg = global["package"];
+			if (!pkg.valid()) {
+				pkg = create_table_with("loaded", create_table_with(key, sr));
+			}
+			else {
+				auto ld = pkg["loaded"];
+				if (!ld.valid()) {
+					ld = create_table_with(key, sr);
+				}
+				else {
+					ld[key] = sr;
+				}
+			}
+#endif
+			auto loaded = reg["_LOADED"];
+			if (!loaded.valid()) {
+				loaded = create_table_with(key, sr);
+			}
+			else {
+				loaded[key] = sr;
+			}
+		}
+
+		template <typename Fx>
+		object require_core(const std::string& key, Fx&& action, bool create_global = true) {
+			optional<object> loaded = is_loaded_package(key);
+			if (loaded && loaded->valid())
+				return std::move(*loaded);
+			int before = lua_gettop(L);
+			action();
+			int after = lua_gettop(L);
+			if (before == after) {
+				// I mean, you were supposed to return
+				// something, ANYTHING, from your requires script. I guess I'll just
+				// but some trash in here, it's on you after that?
+				ensure_package(key, static_cast<void*>(L));
+				return object(L, lua_nil);
+			}
+			stack_reference sr(L, -1);
+			if (create_global)
+				set(key, sr);
+			ensure_package(key, sr);
+			return stack::pop<object>(L);
+		}
+
+	public:
+		using iterator = typename global_table::iterator;
+		using const_iterator = typename global_table::const_iterator;
+
+		state_view(lua_State* Ls) : L(Ls), reg(Ls, LUA_REGISTRYINDEX), global(Ls, global_tag) {
+		}
+
+		state_view(this_state Ls) : state_view(Ls.L) {
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		}
+
+		template <typename... Args>
+		void open_libraries(Args&&... args) {
+			static_assert(meta::all_same<lib, meta::unqualified_t<Args>...>::value, "all types must be libraries");
+			if constexpr (sizeof...(args) == 0) {
+				luaL_openlibs(L);
+				return;
+			}
+			else {
+				lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
+
+				for (auto&& library : libraries) {
+					switch (library) {
+#if SOL_LUA_VERSION_I_ <= 501 && SOL_IS_ON(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#endif // luajit opens coroutine base stuff
+					case lib::base:
+						luaL_requiref(L, "base", luaopen_base, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::package:
+						luaL_requiref(L, "package", luaopen_package, 1);
+						lua_pop(L, 1);
+						break;
+#if SOL_IS_OFF(SOL_USE_LUAJIT)
+					case lib::coroutine:
+#if SOL_LUA_VERSION_I_ > 501
+						luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.2+ only
+						break;
+#endif // Not LuaJIT - comes builtin
+					case lib::string:
+						luaL_requiref(L, "string", luaopen_string, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::table:
+						luaL_requiref(L, "table", luaopen_table, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::math:
+						luaL_requiref(L, "math", luaopen_math, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::bit32:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "bit32", luaopen_bit, 1);
+						lua_pop(L, 1);
+#elif SOL_IS_ON(SOL_LUA_BIT32_LIB)
+						luaL_requiref(L, "bit32", luaopen_bit32, 1);
+						lua_pop(L, 1);
+#else
+#endif
+						break;
+					case lib::io:
+						luaL_requiref(L, "io", luaopen_io, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::os:
+						luaL_requiref(L, "os", luaopen_os, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::debug:
+						luaL_requiref(L, "debug", luaopen_debug, 1);
+						lua_pop(L, 1);
+						break;
+					case lib::utf8:
+#if SOL_LUA_VERSION_I_ > 502 && SOL_IS_OFF(SOL_USE_LUAJIT)
+						luaL_requiref(L, "utf8", luaopen_utf8, 1);
+						lua_pop(L, 1);
+#endif // Lua 5.3+ only
+						break;
+					case lib::ffi:
+#if SOL_IS_ON(SOL_USE_LUAJIT) && SOL_IS_OFF(SOL_LUAJIT_FFI_DISABLED)
+						luaL_requiref(L, "ffi", luaopen_ffi, 1);
+						lua_pop(L, 1);
+#endif // LuaJIT only
+						break;
+					case lib::jit:
+#if SOL_IS_ON(SOL_USE_LUAJIT)
+						luaL_requiref(L, "jit", luaopen_jit, 0);
+						lua_pop(L, 1);
+#endif // LuaJIT Only
+						break;
+					case lib::count:
+					default:
+						break;
+					}
+				}
+			}
+		}
+
+		object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
+			luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
+			return stack::pop<object>(L);
+		}
+
+		object require_script(const std::string& key, const string_view& code, bool create_global = true,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			auto action = [this, &code, &chunkname, &mode]() { stack::script(L, code, chunkname, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		object require_file(const std::string& key, const std::string& filename, bool create_global = true, load_mode mode = load_mode::any) {
+			auto action = [this, &filename, &mode]() { stack::script_file(L, filename, mode); };
+			return require_core(key, action, create_global);
+		}
+
+		void clear_package_loaders() {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			if (!loaders_proxy.valid()) {
+				// nothing to clear
+				return;
+			}
+			// we need to create the table for loaders
+			// table does not exist, so create and move forward
+			loaders_proxy = new_table(1, 0);
+		}
+
+		template <typename Fx>
+		void add_package_loader(Fx&& fx, bool clear_all_package_loaders = false) {
+			optional<table> maybe_package = this->global["package"];
+			if (!maybe_package) {
+				// package lib wasn't opened
+				// open package lib
+				return;
+			}
+			table& package = *maybe_package;
+			// yay for version differences...
+			// one day Lua 5.1 will die a peaceful death
+			// and its old bones will find blissful rest
+			auto loaders_proxy = package
+#if SOL_LUA_VERSION_I_ < 502
+			     ["loaders"]
+#else
+			     ["searchers"]
+#endif
+			     ;
+			bool make_new_table = clear_all_package_loaders || !loaders_proxy.valid();
+			if (make_new_table) {
+				// we need to create the table for loaders
+				// table does not exist, so create and move forward
+				loaders_proxy = new_table(1, 0);
+			}
+			optional<table> maybe_loaders = loaders_proxy;
+			if (!maybe_loaders) {
+				// loaders/searches
+				// thing exists in package, but it
+				// ain't a table or a table-alike...!
+				return;
+			}
+			table loaders = loaders_proxy;
+			loaders.add(std::forward<Fx>(fx));
+		}
+
+		template <typename E>
+		protected_function_result do_reader(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_reader(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_string(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_string(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename E>
+		protected_function_result do_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			set_environment(env, pf);
+			return pf();
+		}
+
+		protected_function_result do_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			if (x != load_status::ok) {
+				return protected_function_result(L, absolute_index(L, -1), 0, 1, static_cast<call_status>(x));
+			}
+			stack_aligned_protected_function pf(L, -1);
+			return pf();
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_reader(reader, data, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		protected_function_result safe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_string(code, env, chunkname, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result safe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, script_default_on_error, chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result safe_script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result safe_script_file(
+		     const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			protected_function_result pfr = do_file(filename, env, mode);
+			if (!pfr.valid()) {
+				return on_error(L, std::move(pfr));
+			}
+			return pfr;
+		}
+
+		template <typename E>
+		protected_function_result safe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+		protected_function_result safe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, script_default_on_error, mode);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(lua_Reader reader, void* data, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (lua_load(L, reader, data, chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, reader, data, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script(const string_view& code, const basic_environment<E>& env,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			int index = lua_gettop(L);
+			if (luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script(L, code, chunkname, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename E>
+		unsafe_function_result unsafe_script_file(const std::string& filename, const basic_environment<E>& env, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			if (luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str())) {
+				lua_error(L);
+			}
+			set_environment(env, stack_reference(L, raw_index(index + 1)));
+			if (lua_pcall(L, 0, LUA_MULTRET, 0)) {
+				lua_error(L);
+			}
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		unsafe_function_result unsafe_script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			int index = lua_gettop(L);
+			stack::script_file(L, filename, mode);
+			int postindex = lua_gettop(L);
+			int returns = postindex - index;
+			return unsafe_function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script(
+		     const string_view& code, Fx&& on_error, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx,
+		     meta::disable_any<meta::is_string_constructible<meta::unqualified_t<Fx>>,
+		          meta::is_specialization_of<meta::unqualified_t<Fx>, basic_environment>> = meta::enabler>
+		protected_function_result script_file(const std::string& filename, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, std::forward<Fx>(on_error), mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script(const string_view& code, const basic_environment<E>& env, Fx&& on_error,
+		     const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, std::forward<Fx>(on_error), chunkname, mode);
+		}
+
+		template <typename Fx, typename E>
+		protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, std::forward<Fx>(on_error), mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const environment& env, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, env, script_default_on_error, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, const environment& env, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, env, script_default_on_error, mode);
+		}
+
+#if SOL_IS_ON(SOL_SAFE_FUNCTION_OBJECTS)
+		protected_function_result script(
+		     lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(reader, data, chunkname, mode);
+		}
+
+		protected_function_result script(
+		     const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return safe_script(code, chunkname, mode);
+		}
+
+		protected_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return safe_script_file(filename, mode);
+		}
+#else
+		unsafe_function_result script(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return unsafe_script(code, chunkname, mode);
+		}
+
+		unsafe_function_result script_file(const std::string& filename, load_mode mode = load_mode::any) {
+			return unsafe_script_file(filename, mode);
+		}
+#endif
+		load_result load(const string_view& code, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name(code, chunkname, basechunkname);
+			load_status x = static_cast<load_status>(luaL_loadbufferx(L, code.data(), code.size(), chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load_buffer(const char* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(buff, size), chunkname, mode);
+		}
+
+		load_result load_buffer(
+		     const std::byte* buff, size_t size, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			return load(string_view(reinterpret_cast<const char*>(buff), size), chunkname, mode);
+		}
+
+		load_result load_file(const std::string& filename, load_mode mode = load_mode::any) {
+			load_status x = static_cast<load_status>(luaL_loadfilex(L, filename.c_str(), to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		load_result load(lua_Reader reader, void* data, const std::string& chunkname = detail::default_chunk_name(), load_mode mode = load_mode::any) {
+			detail::typical_chunk_name_t basechunkname = {};
+			const char* chunknametarget = detail::make_chunk_name("lua_Reader", chunkname, basechunkname);
+			load_status x = static_cast<load_status>(lua_load(L, reader, data, chunknametarget, to_string(mode).c_str()));
+			return load_result(L, absolute_index(L, -1), 1, 1, x);
+		}
+
+		iterator begin() const {
+			return global.begin();
+		}
+
+		iterator end() const {
+			return global.end();
+		}
+
+		const_iterator cbegin() const {
+			return global.cbegin();
+		}
+
+		const_iterator cend() const {
+			return global.cend();
+		}
+
+		global_table globals() const {
+			// if we return a reference
+			// we'll be screwed a bit
+			return global;
+		}
+
+		global_table& globals() {
+			return global;
+		}
+
+		table registry() const {
+			return reg;
+		}
+
+		std::size_t memory_used() const {
+			return total_memory_used(lua_state());
+		}
+
+		int stack_top() const {
+			return stack::top(L);
+		}
+
+		int stack_clear() {
+			int s = stack_top();
+			lua_pop(L, s);
+			return s;
+		}
+
+		bool supports_gc_mode(gc_mode mode) const noexcept {
+#if SOL_LUA_VERSION_I_ >= 504
+			// supports all modes
+			(void)mode;
+			return true;
+#endif
+			return mode == gc_mode::default_value;
+		}
+
+		bool is_gc_on() const {
+#if SOL_LUA_VERSION_I_ >= 502
+			return lua_gc(lua_state(), LUA_GCISRUNNING, 0) == 1;
+#else
+			// You cannot turn it off in Lua 5.1
+			return true;
+#endif
+		}
+
+		void collect_garbage() {
+			lua_gc(lua_state(), LUA_GCCOLLECT, 0);
+		}
+
+		void collect_gc() {
+			collect_garbage();
+		}
+
+		bool step_gc(int step_size_kilobytes) {
+			// THOUGHT: std::chrono-alikes to map "kilobyte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			// The manual implies that this function is almost always successful...
+			// is it?? It could depend on the GC mode...
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) != 0;
+#else
+			return lua_gc(lua_state(), LUA_GCSTEP, step_size_kilobytes) == 1;
+#endif
+		}
+
+		void restart_gc() {
+			lua_gc(lua_state(), LUA_GCRESTART, 0);
+		}
+
+		void stop_gc() {
+			lua_gc(lua_state(), LUA_GCSTOP, 0);
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_incremental(int pause, int step_multiplier, int step_byte_size) {
+			// "What the fuck does any of this mean??"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.1
+
+			// THOUGHT: std::chrono-alikes to map "byte size" here...?
+			// Make it harder to give MB or KB to a B parameter...?
+			// Probably overkill for now.
+#if SOL_LUA_VERSION_I_ >= 504
+			int old_mode = lua_gc(lua_state(), LUA_GCINC, pause, step_multiplier, step_byte_size);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			lua_gc(lua_state(), LUA_GCSETPAUSE, pause);
+			lua_gc(lua_state(), LUA_GCSETSTEPMUL, step_multiplier);
+			(void)step_byte_size; // means nothing in older versions
+#endif
+			return gc_mode::default_value;
+		}
+
+		// Returns the old GC mode. Check support using the supports_gc_mode function.
+		gc_mode change_gc_mode_generational(int minor_multiplier, int major_multiplier) {
+#if SOL_LUA_VERSION_I_ >= 504
+			// "What does this shit mean?"
+			// http://www.lua.org/manual/5.4/manual.html#2.5.2
+			int old_mode = lua_gc(lua_state(), LUA_GCGEN, minor_multiplier, major_multiplier);
+			if (old_mode == LUA_GCGEN) {
+				return gc_mode::generational;
+			}
+			else if (old_mode == LUA_GCINC) {
+				return gc_mode::incremental;
+			}
+#else
+			(void)minor_multiplier;
+			(void)major_multiplier;
+#endif
+			return gc_mode::default_value;
+		}
+
+		operator lua_State*() const {
+			return lua_state();
+		}
+
+		void set_panic(lua_CFunction panic) {
+			lua_atpanic(lua_state(), panic);
+		}
+
+		void set_exception_handler(exception_handler_function handler) {
+			set_default_exception_handler(lua_state(), handler);
+		}
+
+		template <typename... Args, typename... Keys>
+		decltype(auto) get(Keys&&... keys) const {
+			return global.get<Args...>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename T, typename Key>
+		decltype(auto) get_or(Key&& key, T&& otherwise) const {
+			return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
+		}
+
+		template <typename T, typename Key, typename D>
+		decltype(auto) get_or(Key&& key, D&& otherwise) const {
+			return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
+		}
+
+		template <typename... Args>
+		state_view& set(Args&&... args) {
+			global.set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, typename... Keys>
+		decltype(auto) traverse_get(Keys&&... keys) const {
+			return global.traverse_get<T>(std::forward<Keys>(keys)...);
+		}
+
+		template <typename... Args>
+		state_view& traverse_set(Args&&... args) {
+			global.traverse_set(std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Class, typename... Args>
+		usertype<Class> new_usertype(Args&&... args) {
+			return global.new_usertype<Class>(std::forward<Args>(args)...);
+		}
+
+		template <bool read_only = true, typename... Args>
+		state_view& new_enum(const string_view& name, Args&&... args) {
+			global.new_enum<read_only>(name, std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename T, bool read_only = true>
+		state_view& new_enum(const string_view& name, std::initializer_list<std::pair<string_view, T>> items) {
+			global.new_enum<T, read_only>(name, std::move(items));
+			return *this;
+		}
+
+		template <typename Fx>
+		void for_each(Fx&& fx) {
+			global.for_each(std::forward<Fx>(fx));
+		}
+
+		template <typename T>
+		table_proxy<global_table&, detail::proxy_key_t<T>> operator[](T&& key) {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename T>
+		table_proxy<const global_table&, detail::proxy_key_t<T>> operator[](T&& key) const {
+			return global[std::forward<T>(key)];
+		}
+
+		template <typename Sig, typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename... Args, typename Key>
+		state_view& set_function(Key&& key, Args&&... args) {
+			global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
+			return *this;
+		}
+
+		template <typename Name>
+		table create_table(Name&& name, int narr = 0, int nrec = 0) {
+			return global.create(std::forward<Name>(name), narr, nrec);
+		}
+
+		template <typename Name, typename Key, typename Value, typename... Args>
+		table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename Name, typename... Args>
+		table create_named_table(Name&& name, Args&&... args) {
+			table x = global.create_with(std::forward<Args>(args)...);
+			global.set(std::forward<Name>(name), x);
+			return x;
+		}
+
+		table create_table(int narr = 0, int nrec = 0) {
+			return create_table(lua_state(), narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		table create_table_with(Args&&... args) {
+			return create_table_with(lua_state(), std::forward<Args>(args)...);
+		}
+
+		static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
+			return global_table::create(L, narr, nrec);
+		}
+
+		template <typename Key, typename Value, typename... Args>
+		static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
+			return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
+		}
+
+		template <typename... Args>
+		static inline table create_table_with(lua_State* L, Args&&... args) {
+			return global_table::create_with(L, std::forward<Args>(args)...);
+		}
+	};
+} // namespace sol
+
+// end of sol/state_view.hpp
+
+// beginning of sol/thread.hpp
+
+namespace sol {
+	struct lua_thread_state {
+		lua_State* L;
+
+		lua_thread_state(lua_State* Ls) : L(Ls) {
+		}
+
+		lua_State* lua_state() const noexcept {
+			return L;
+		}
+		operator lua_State*() const noexcept {
+			return lua_state();
+		}
+		lua_State* operator->() const noexcept {
+			return lua_state();
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_pusher<lua_thread_state> {
+			int push(lua_State*, lua_thread_state lts) {
+				lua_pushthread(lts.L);
+				return 1;
+			}
+		};
+
+		template <>
+		struct unqualified_getter<lua_thread_state> {
+			lua_thread_state get(lua_State* L, int index, record& tracking) {
+				tracking.use(1);
+				lua_thread_state lts(lua_tothread(L, index));
+				return lts;
+			}
+		};
+
+		template <>
+		struct unqualified_check_getter<lua_thread_state> {
+			template <typename Handler>
+			optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
+				lua_thread_state lts(lua_tothread(L, index));
+				if (lts.lua_state() == nullptr) {
+					handler(L, index, type::thread, type_of(L, index), "value is not a valid thread type");
+					return nullopt;
+				}
+				tracking.use(1);
+				return lts;
+			}
+		};
+	} // namespace stack
+
+	template <typename ref_t>
+	class basic_thread : public basic_object<ref_t> {
+	private:
+		using base_t = basic_object<ref_t>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_thread() noexcept = default;
+		basic_thread(const basic_thread&) = default;
+		basic_thread(basic_thread&&) = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_thread>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(T&& r) : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(const stack_reference& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread(stack_reference&& r) : basic_thread(r.lua_state(), r.stack_index()) {};
+		basic_thread& operator=(const basic_thread&) = default;
+		basic_thread& operator=(basic_thread&&) = default;
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_thread(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(L, index, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_thread(lua_State* L, lua_State* actualthread) : basic_thread(L, lua_thread_state { actualthread }) {
+		}
+		basic_thread(lua_State* L, this_state actualthread) : basic_thread(L, lua_thread_state { actualthread.L }) {
+		}
+		basic_thread(lua_State* L, lua_thread_state actualthread) : base_t(L, -stack::push(L, actualthread)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_thread>(lua_state(), -1, handler);
+#endif // Safety
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(lua_state(), 1);
+			}
+		}
+
+		state_view state() const {
+			return state_view(this->thread_state());
+		}
+
+		bool is_main_thread() const {
+			return stack::is_main_thread(this->thread_state());
+		}
+
+		lua_State* thread_state() const {
+			auto pp = stack::push_pop(*this);
+			lua_State* lthread = lua_tothread(lua_state(), -1);
+			return lthread;
+		}
+
+		thread_status status() const {
+			lua_State* lthread = thread_state();
+			auto lstat = static_cast<thread_status>(lua_status(lthread));
+			if (lstat == thread_status::ok) {
+				lua_Debug ar;
+				if (lua_getstack(lthread, 0, &ar) > 0)
+					return thread_status::ok;
+				else if (lua_gettop(lthread) == 0)
+					return thread_status::dead;
+				else
+					return thread_status::yielded;
+			}
+			return lstat;
+		}
+
+		basic_thread create() {
+			return create(lua_state());
+		}
+
+		static basic_thread create(lua_State* L) {
+			lua_newthread(L);
+			basic_thread result(L);
+			if (!is_stack_based<base_t>::value) {
+				lua_pop(L, 1);
+			}
+			return result;
+		}
+	};
+
+	typedef basic_thread<reference> thread;
+	typedef basic_thread<stack_reference> stack_thread;
+} // namespace sol
+
+// end of sol/thread.hpp
+
+namespace sol {
+
+	class state : private std::unique_ptr<lua_State, detail::state_deleter>, public state_view {
+	private:
+		typedef std::unique_ptr<lua_State, detail::state_deleter> unique_base;
+
+	public:
+		state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate()), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr)
+		: unique_base(lua_newstate(alfunc, alpointer)), state_view(unique_base::get()) {
+			set_default_state(unique_base::get(), panic);
+		}
+
+		state(const state&) = delete;
+		state(state&&) = default;
+		state& operator=(const state&) = delete;
+		state& operator=(state&& that) {
+			state_view::operator=(std::move(that));
+			unique_base::operator=(std::move(that));
+			return *this;
+		}
+
+		using state_view::get;
+
+		~state() {
+		}
+	};
+} // namespace sol
+
+// end of sol/state.hpp
+
+// beginning of sol/coroutine.hpp
+
+namespace sol {
+	template <typename Reference>
+	class basic_coroutine : public basic_object<Reference> {
+	private:
+		using base_t = basic_object<Reference>;
+		using handler_t = reference;
+
+	private:
+		call_status stats = call_status::yielded;
+
+		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
+#if SOL_LUA_VERSION_I_ >= 504
+			int nresults;
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nresults));
+#else
+			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
+#endif
+		}
+
+		template <std::size_t... I, typename... Ret>
+		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
+			luacall(n, sizeof...(Ret));
+			return stack::pop<std::tuple<Ret...>>(lua_state());
+		}
+
+		template <std::size_t I, typename Ret>
+		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 1);
+			return stack::pop<Ret>(lua_state());
+		}
+
+		template <std::size_t I>
+		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
+			luacall(n, 0);
+		}
+
+		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
+			int firstreturn = 1;
+			luacall(n, LUA_MULTRET);
+			int poststacksize = lua_gettop(this->lua_state());
+			int returncount = poststacksize - (firstreturn - 1);
+			if (error()) {
+				if (m_error_handler.valid()) {
+					string_view err = stack::get<string_view>(this->lua_state(), poststacksize);
+					m_error_handler.push();
+					stack::push(this->lua_state(), err);
+					lua_call(lua_state(), 1, 1);
+				}
+				return protected_function_result(this->lua_state(), lua_absindex(this->lua_state(), -1), 1, returncount, status());
+			}
+			return protected_function_result(this->lua_state(), firstreturn, returncount, returncount, status());
+		}
+
+	public:
+		using base_t::lua_state;
+
+		basic_coroutine() = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_coroutine>>,
+		          meta::neg<std::is_base_of<proxy_base_tag, meta::unqualified_t<T>>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          meta::neg<std::is_same<lua_nil_t, meta::unqualified_t<T>>>, is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(T&& r) noexcept
+		: base_t(std::forward<T>(r)), m_error_handler(detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_function<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				constructor_handler handler {};
+				stack::check<basic_coroutine>(lua_state(), -1, handler);
+			}
+#endif // Safety
+		}
+
+		basic_coroutine(const basic_coroutine& other) = default;
+		basic_coroutine& operator=(const basic_coroutine&) = default;
+
+		basic_coroutine(basic_coroutine&& other) noexcept : base_t(std::move(other)), m_error_handler(this->lua_state(), std::move(other.m_error_handler)) {
+		}
+
+		basic_coroutine& operator=(basic_coroutine&& other) noexcept {
+			base_t::operator=(std::move(other));
+			// must change the state, since it could change on the coroutine type
+			m_error_handler = handler_t(this->lua_state(), std::move(other.m_error_handler));
+			return *this;
+		}
+
+		basic_coroutine(const basic_function<base_t>& b) noexcept
+		: basic_coroutine(b, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(basic_function<base_t>&& b) noexcept
+		: basic_coroutine(std::move(b), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(b.lua_state())) {
+		}
+		basic_coroutine(const basic_function<base_t>& b, handler_t eh) noexcept : base_t(b), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(basic_function<base_t>&& b, handler_t eh) noexcept : base_t(std::move(b)), m_error_handler(std::move(eh)) {
+		}
+		basic_coroutine(const stack_reference& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(stack_reference&& r) noexcept
+		: basic_coroutine(r.lua_state(), r.stack_index(), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(r.lua_state())) {
+		}
+		basic_coroutine(const stack_reference& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+		basic_coroutine(stack_reference&& r, handler_t eh) noexcept : basic_coroutine(r.lua_state(), r.stack_index(), std::move(eh)) {
+		}
+
+		template <typename Super>
+		basic_coroutine(const proxy_base<Super>& p)
+		: basic_coroutine(p, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Super>
+		basic_coroutine(proxy_base<Super>&& p)
+		: basic_coroutine(std::move(p), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(p.lua_state())) {
+		}
+		template <typename Proxy, typename HandlerReference,
+		     meta::enable<std::is_base_of<proxy_base_tag, meta::unqualified_t<Proxy>>,
+		          meta::neg<is_lua_index<meta::unqualified_t<HandlerReference>>>> = meta::enabler>
+		basic_coroutine(Proxy&& p, HandlerReference&& eh) : basic_coroutine(detail::force_cast<base_t>(p), std::forward<HandlerReference>(eh)) {
+		}
+
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r) noexcept
+		: basic_coroutine(L, std::forward<T>(r), detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_coroutine(lua_State* L, T&& r, handler_t eh) : base_t(L, std::forward<T>(r)), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		basic_coroutine(lua_nil_t n) : base_t(n), m_error_handler(n) {
+		}
+
+		basic_coroutine(lua_State* L, int index = -1)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, int index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#ifdef SOL_SAFE_REFERENCES
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, absolute_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, absolute_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, raw_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, raw_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(L, index, handler);
+#endif // Safety
+		}
+		basic_coroutine(lua_State* L, ref_index index)
+		: basic_coroutine(L, index, detail::get_default_handler<reference, is_main_threaded<base_t>::value>(L)) {
+		}
+		basic_coroutine(lua_State* L, ref_index index, handler_t eh) : base_t(L, index), m_error_handler(std::move(eh)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_coroutine>(lua_state(), -1, handler);
+#endif // Safety
+		}
+
+		call_status status() const noexcept {
+			return stats;
+		}
+
+		bool error() const noexcept {
+			call_status cs = status();
+			return cs != call_status::ok && cs != call_status::yielded;
+		}
+
+		bool runnable() const noexcept {
+			return base_t::valid() && (status() == call_status::yielded);
+		}
+
+		explicit operator bool() const noexcept {
+			return runnable();
+		}
+
+		template <typename... Args>
+		protected_function_result operator()(Args&&... args) {
+			return call<>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) operator()(types<Ret...>, Args&&... args) {
+			return call<Ret...>(std::forward<Args>(args)...);
+		}
+
+		template <typename... Ret, typename... Args>
+		decltype(auto) call(Args&&... args) {
+			// some users screw up coroutine.create
+			// and try to use it with sol::coroutine without ever calling the first resume in Lua
+			// this makes the stack incompatible with other kinds of stacks: protect against this
+			// make sure coroutines don't screw us over
+			base_t::push();
+			int pushcount = stack::multi_push_reference(lua_state(), std::forward<Args>(args)...);
+			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
+		}
+
+	private:
+		handler_t m_error_handler;
+	};
+} // namespace sol
+
+// end of sol/coroutine.hpp
+
+// beginning of sol/userdata.hpp
+
+namespace sol {
+	template <typename base_type>
+	class basic_userdata : public basic_table<base_type> {
+	private:
+		using base_t = basic_table<base_type>;
+
+	public:
+		using base_t::lua_state;
+
+		basic_userdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_userdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::userdata);
+			}
+#endif // Safety
+		}
+		basic_userdata(const basic_userdata&) = default;
+		basic_userdata(basic_userdata&&) = default;
+		basic_userdata& operator=(const basic_userdata&) = default;
+		basic_userdata& operator=(basic_userdata&&) = default;
+		basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_userdata(lua_State* L, T&& r) : base_t(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_userdata(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_userdata>(L, -1, handler);
+#endif // Safety
+		}
+	};
+
+	template <typename base_type>
+	class basic_lightuserdata : public basic_object_base<base_type> {
+		typedef basic_object_base<base_type> base_t;
+
+	public:
+		using base_t::lua_state;
+
+		basic_lightuserdata() noexcept = default;
+		template <typename T,
+		     meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>,
+		          is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
+				auto pp = stack::push_pop(*this);
+				type_assert(lua_state(), -1, type::lightuserdata);
+			}
+#endif // Safety
+		}
+		basic_lightuserdata(const basic_lightuserdata&) = default;
+		basic_lightuserdata(basic_lightuserdata&&) = default;
+		basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
+		basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
+		basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {
+		}
+		template <typename T, meta::enable<is_lua_reference<meta::unqualified_t<T>>> = meta::enabler>
+		basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, std::forward<T>(r)) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), -1, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(L, index, handler);
+#endif // Safety
+		}
+		basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
+#if SOL_IS_ON(SOL_SAFE_REFERENCES)
+			auto pp = stack::push_pop(*this);
+			constructor_handler handler {};
+			stack::check<basic_lightuserdata>(lua_state(), index, handler);
+#endif // Safety
+		}
+	};
+
+} // namespace sol
+
+// end of sol/userdata.hpp
+
+// beginning of sol/as_args.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_args_t {
+		T src;
+	};
+
+	template <typename Source>
+	auto as_args(Source&& source) {
+		return as_args_t<Source> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_args_t<T>> {
+			int push(lua_State* L, const as_args_t<T>& e) {
+				int p = 0;
+				for (const auto& i : e.src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_args.hpp
+
+// beginning of sol/variadic_args.hpp
+
+#include <limits>
+#include <iterator>
+
+namespace sol {
+	struct variadic_args {
+	private:
+		lua_State* L;
+		int index;
+		int stacktop;
+
+	public:
+		typedef stack_proxy reference_type;
+		typedef stack_proxy value_type;
+		typedef stack_proxy* pointer;
+		typedef std::ptrdiff_t difference_type;
+		typedef std::size_t size_type;
+		typedef stack_iterator<stack_proxy, false> iterator;
+		typedef stack_iterator<stack_proxy, true> const_iterator;
+		typedef std::reverse_iterator<iterator> reverse_iterator;
+		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+
+		variadic_args() = default;
+		variadic_args(lua_State* luastate, int stackindex = -1) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {
+		}
+		variadic_args(lua_State* luastate, int stackindex, int lastindex) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lastindex) {
+		}
+		variadic_args(const variadic_args&) = default;
+		variadic_args& operator=(const variadic_args&) = default;
+		variadic_args(variadic_args&& o) : L(o.L), index(o.index), stacktop(o.stacktop) {
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+		}
+		variadic_args& operator=(variadic_args&& o) {
+			L = o.L;
+			index = o.index;
+			stacktop = o.stacktop;
+			// Must be manual, otherwise destructor will screw us
+			// return count being 0 is enough to keep things clean
+			// but will be thorough
+			o.L = nullptr;
+			o.index = 0;
+			o.stacktop = 0;
+			return *this;
+		}
+
+		iterator begin() {
+			return iterator(L, index, stacktop + 1);
+		}
+		iterator end() {
+			return iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator begin() const {
+			return const_iterator(L, index, stacktop + 1);
+		}
+		const_iterator end() const {
+			return const_iterator(L, stacktop + 1, stacktop + 1);
+		}
+		const_iterator cbegin() const {
+			return begin();
+		}
+		const_iterator cend() const {
+			return end();
+		}
+
+		reverse_iterator rbegin() {
+			return std::reverse_iterator<iterator>(begin());
+		}
+		reverse_iterator rend() {
+			return std::reverse_iterator<iterator>(end());
+		}
+		const_reverse_iterator rbegin() const {
+			return std::reverse_iterator<const_iterator>(begin());
+		}
+		const_reverse_iterator rend() const {
+			return std::reverse_iterator<const_iterator>(end());
+		}
+		const_reverse_iterator crbegin() const {
+			return std::reverse_iterator<const_iterator>(cbegin());
+		}
+		const_reverse_iterator crend() const {
+			return std::reverse_iterator<const_iterator>(cend());
+		}
+
+		int push() const {
+			return push(L);
+		}
+
+		int push(lua_State* target) const {
+			int pushcount = 0;
+			for (int i = index; i <= stacktop; ++i) {
+				lua_pushvalue(L, i);
+				pushcount += 1;
+			}
+			if (target != L) {
+				lua_xmove(L, target, pushcount);
+			}
+			return pushcount;
+		}
+
+		template <typename T>
+		decltype(auto) get(difference_type index_offset = 0) const {
+			return stack::get<T>(L, index + static_cast<int>(index_offset));
+		}
+
+		type get_type(difference_type index_offset = 0) const noexcept {
+			return type_of(L, index + static_cast<int>(index_offset));
+		}
+
+		stack_proxy operator[](difference_type index_offset) const {
+			return stack_proxy(L, index + static_cast<int>(index_offset));
+		}
+
+		lua_State* lua_state() const {
+			return L;
+		};
+		int stack_index() const {
+			return index;
+		};
+		int leftover_count() const {
+			return stacktop - (index - 1);
+		}
+		std::size_t size() const {
+			return static_cast<std::size_t>(leftover_count());
+		}
+		int top() const {
+			return stacktop;
+		}
+	};
+
+	namespace stack {
+		template <>
+		struct unqualified_getter<variadic_args> {
+			static variadic_args get(lua_State* L, int index, record& tracking) {
+				tracking.last = 0;
+				return variadic_args(L, index);
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_args> {
+			static int push(lua_State* L, const variadic_args& ref) {
+				return ref.push(L);
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/variadic_args.hpp
+
+// beginning of sol/variadic_results.hpp
+
+// beginning of sol/as_returns.hpp
+
+namespace sol {
+	template <typename T>
+	struct as_returns_t : private detail::ebco<T> {
+	private:
+		using base_t = detail::ebco<T>;
+
+	public:
+		using base_t::base_t;
+		using base_t::value;
+	};
+
+	template <typename Source>
+	auto as_returns(Source&& source) {
+		return as_returns_t<std::decay_t<Source>> { std::forward<Source>(source) };
+	}
+
+	namespace stack {
+		template <typename T>
+		struct unqualified_pusher<as_returns_t<T>> {
+			int push(lua_State* L, const as_returns_t<T>& e) {
+				auto& src = detail::unwrap(e.value());
+				int p = 0;
+				for (const auto& i : src) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+	} // namespace stack
+} // namespace sol
+
+// end of sol/as_returns.hpp
+
+#include <vector>
+
+namespace sol {
+
+	template <typename Al = typename std::allocator<object>>
+	struct basic_variadic_results : public std::vector<object, Al> {
+	private:
+		using base_t = std::vector<object, Al>;
+
+	public:
+		basic_variadic_results() : base_t() {
+		}
+
+		basic_variadic_results(unsafe_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		basic_variadic_results(protected_function_result fr) : base_t() {
+			this->reserve(fr.return_count());
+			this->insert(this->cend(), fr.begin(), fr.end());
+		}
+
+		template <typename Arg0, typename... Args,
+		     meta::disable_any<std::is_same<meta::unqualified_t<Arg0>, basic_variadic_results>, std::is_same<meta::unqualified_t<Arg0>, function_result>,
+		          std::is_same<meta::unqualified_t<Arg0>, protected_function_result>> = meta::enabler>
+		basic_variadic_results(Arg0&& arg0, Args&&... args) : base_t(std::forward<Arg0>(arg0), std::forward<Args>(args)...) {
+		}
+
+		basic_variadic_results(const basic_variadic_results&) = default;
+		basic_variadic_results(basic_variadic_results&&) = default;
+	};
+
+	struct variadic_results : public basic_variadic_results<> {
+	private:
+		using base_t = basic_variadic_results<>;
+
+	public:
+		using base_t::base_t;
+	};
+
+	template <typename Al>
+	struct is_container<basic_variadic_results<Al>> : std::false_type { };
+
+	template <>
+	struct is_container<variadic_results> : std::false_type { };
+
+	namespace stack {
+		template <typename Al>
+		struct unqualified_pusher<basic_variadic_results<Al>> {
+			int push(lua_State* L, const basic_variadic_results<Al>& e) {
+				int p = 0;
+				for (const auto& i : e) {
+					p += stack::push(L, i);
+				}
+				return p;
+			}
+		};
+
+		template <>
+		struct unqualified_pusher<variadic_results> {
+			int push(lua_State* L, const variadic_results& r) {
+				using base_t = basic_variadic_results<>;
+				return stack::push(L, static_cast<const base_t&>(r));
+			}
+		};
+	} // namespace stack
+
+} // namespace sol
+
+// end of sol/variadic_results.hpp
+
+#if SOL_IS_ON(SOL_COMPILER_GCC)
+#pragma GCC diagnostic pop
+#elif SOL_IS_ON(SOL_COMPILER_CLANG)
+#elif SOL_IS_ON(SOL_COMPILER_VCXX)
+#pragma warning(pop)
+#endif // g++
+
+#if SOL_IS_ON(SOL_INSIDE_UNREAL_ENGINE)
+#undef check
+#pragma pop_macro("check")
+#endif // Unreal Engine 4 Bullshit
+
+#endif // SOL_HPP
+// end of sol/sol.hpp
+
+#endif // SOL_SINGLE_INCLUDE_HPP
diff --git a/third_party/sol2/sol2/sol.hpp b/third_party/sol2/sol2/sol.hpp
deleted file mode 100644
index d48b67431..000000000
--- a/third_party/sol2/sol2/sol.hpp
+++ /dev/null
@@ -1,14507 +0,0 @@
-// The MIT License (MIT)
-
-// Copyright (c) 2013-2017 Rapptz, ThePhD and contributors
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of
-// this software and associated documentation files (the "Software"), to deal in
-// the Software without restriction, including without limitation the rights to
-// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-// the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-// This file was generated with a script.
-// Generated 2017-06-13 20:34:08.313723 UTC
-// This header was generated with sol v2.17.5 (revision 51a03b2)
-// https://github.com/ThePhD/sol2
-
-#ifndef SOL_SINGLE_INCLUDE_HPP
-#define SOL_SINGLE_INCLUDE_HPP
-
-// beginning of sol.hpp
-
-#ifndef SOL_HPP
-#define SOL_HPP
-
-#if defined(UE_BUILD_DEBUG) || defined(UE_BUILD_DEVELOPMENT) || defined(UE_BUILD_TEST) || defined(UE_BUILD_SHIPPING) || defined(UE_SERVER)
-#define SOL_INSIDE_UNREAL
-#endif // Unreal Engine 4 bullshit
-
-#ifdef SOL_INSIDE_UNREAL
-#ifdef check
-#define SOL_INSIDE_UNREAL_REMOVED_CHECK
-#undef check
-#endif 
-#endif // Unreal Engine 4 Bullshit
-
-#ifdef __GNUC__
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wshadow"
-#pragma GCC diagnostic ignored "-Wconversion"
-#if __GNUC__ > 6
-#pragma GCC diagnostic ignored "-Wnoexcept-type"
-#endif
-#elif defined _MSC_VER
-#pragma warning( push )
-#pragma warning( disable : 4324 ) // structure was padded due to alignment specifier
-#endif // g++
-
-// beginning of sol/state.hpp
-
-// beginning of sol/state_view.hpp
-
-// beginning of sol/error.hpp
-
-#include <stdexcept>
-#include <string>
-
-namespace sol {
-	namespace detail {
-		struct direct_error_tag {};
-		const auto direct_error = direct_error_tag{};
-	} // detail
-	
-	class error : public std::runtime_error {
-	private:
-		// Because VC++ is a fuccboi
-		std::string w;
-	public:
-		error(const std::string& str) : error(detail::direct_error, "lua: error: " + str) {}
-		error(std::string&& str) : error(detail::direct_error, "lua: error: " + std::move(str)) {}
-		error(detail::direct_error_tag, const std::string& str) : std::runtime_error(""), w(str) {}
-		error(detail::direct_error_tag, std::string&& str) : std::runtime_error(""), w(std::move(str)) {}
-
-		error(const error& e) = default;
-		error(error&& e) = default;
-		error& operator=(const error& e) = default;
-		error& operator=(error&& e) = default;
-
-		virtual const char* what() const noexcept override {
-			return w.c_str();
-		}
-	};
-
-} // sol
-
-// end of sol/error.hpp
-
-// beginning of sol/table.hpp
-
-// beginning of sol/table_core.hpp
-
-// beginning of sol/proxy.hpp
-
-// beginning of sol/traits.hpp
-
-// beginning of sol/tuple.hpp
-
-#include <tuple>
-#include <cstddef>
-
-namespace sol {
-	namespace detail {
-		using swallow = std::initializer_list<int>;
-	} // detail
-
-	template<typename... Args>
-	struct types { typedef std::make_index_sequence<sizeof...(Args)> indices; static constexpr std::size_t size() { return sizeof...(Args); } };
-	namespace meta {
-		namespace detail {
-			template<typename... Args>
-			struct tuple_types_ { typedef types<Args...> type; };
-
-			template<typename... Args>
-			struct tuple_types_<std::tuple<Args...>> { typedef types<Args...> type; };
-		} // detail
-
-		template<typename T>
-		using unqualified = std::remove_cv<std::remove_reference_t<T>>;
-
-		template<typename T>
-		using unqualified_t = typename unqualified<T>::type;
-
-		template<typename... Args>
-		using tuple_types = typename detail::tuple_types_<Args...>::type;
-
-		template<typename Arg>
-		struct pop_front_type;
-
-		template<typename Arg>
-		using pop_front_type_t = typename pop_front_type<Arg>::type;
-
-		template<typename... Args>
-		struct pop_front_type<types<Args...>> { typedef void front_type; typedef types<Args...> type; };
-
-		template<typename Arg, typename... Args>
-		struct pop_front_type<types<Arg, Args...>> { typedef Arg front_type; typedef types<Args...> type; };
-
-		template <std::size_t N, typename Tuple>
-		using tuple_element = std::tuple_element<N, unqualified_t<Tuple>>;
-
-		template <std::size_t N, typename Tuple>
-		using tuple_element_t = std::tuple_element_t<N, unqualified_t<Tuple>>;
-
-		template <std::size_t N, typename Tuple>
-		using unqualified_tuple_element = unqualified<tuple_element_t<N, Tuple>>;
-
-		template <std::size_t N, typename Tuple>
-		using unqualified_tuple_element_t = unqualified_t<tuple_element_t<N, Tuple>>;
-
-	} // meta
-} // sol
-
-// end of sol/tuple.hpp
-
-// beginning of sol/bind_traits.hpp
-
-namespace sol {
-	namespace meta {
-		namespace meta_detail {
-
-			template<class F>
-			struct check_deducible_signature {
-				struct nat {};
-				template<class G>
-				static auto test(int) -> decltype(&G::operator(), void());
-				template<class>
-				static auto test(...)->nat;
-
-				using type = std::is_void<decltype(test<F>(0))>;
-			};
-		} // meta_detail
-
-		template<class F>
-		struct has_deducible_signature : meta_detail::check_deducible_signature<F>::type { };
-
-		namespace meta_detail {
-
-			template <std::size_t I, typename T>
-			struct void_tuple_element : meta::tuple_element<I, T> {};
-
-			template <std::size_t I>
-			struct void_tuple_element<I, std::tuple<>> { typedef void type; };
-
-			template <std::size_t I, typename T>
-			using void_tuple_element_t = typename void_tuple_element<I, T>::type;
-
-			template <bool has_c_variadic, typename T, typename R, typename... Args>
-			struct basic_traits {
-			private:
-				typedef std::conditional_t<std::is_void<T>::value, int, T>& first_type;
-
-			public:
-				static const bool is_member_function = std::is_void<T>::value;
-				static const bool has_c_var_arg = has_c_variadic;
-				static const std::size_t arity = sizeof...(Args);
-				static const std::size_t free_arity = sizeof...(Args)+static_cast<std::size_t>(!std::is_void<T>::value);
-				typedef types<Args...> args_list;
-				typedef std::tuple<Args...> args_tuple;
-				typedef T object_type;
-				typedef R return_type;
-				typedef tuple_types<R> returns_list;
-				typedef R(function_type)(Args...);
-				typedef std::conditional_t<std::is_void<T>::value, args_list, types<first_type, Args...>> free_args_list;
-				typedef std::conditional_t<std::is_void<T>::value, R(Args...), R(first_type, Args...)> free_function_type;
-				typedef std::conditional_t<std::is_void<T>::value, R(*)(Args...), R(*)(first_type, Args...)> free_function_pointer_type;
-				typedef std::remove_pointer_t<free_function_pointer_type> signature_type;
-				template<std::size_t i>
-				using arg_at = void_tuple_element_t<i, args_tuple>;
-			};
-
-			template<typename Signature, bool b = has_deducible_signature<Signature>::value>
-			struct fx_traits : basic_traits<false, void, void> {};
-
-			// Free Functions
-			template<typename R, typename... Args>
-			struct fx_traits<R(Args...), false> : basic_traits<false, void, R, Args...> {
-				typedef R(*function_pointer_type)(Args...);
-			};
-
-			template<typename R, typename... Args>
-			struct fx_traits<R(*)(Args...), false> : basic_traits<false, void, R, Args...> {
-				typedef R(*function_pointer_type)(Args...);
-			};
-
-			template<typename R, typename... Args>
-			struct fx_traits<R(Args..., ...), false> : basic_traits<true, void, R, Args...> {
-				typedef R(*function_pointer_type)(Args..., ...);
-			};
-
-			template<typename R, typename... Args>
-			struct fx_traits<R(*)(Args..., ...), false> : basic_traits<true, void, R, Args...> {
-				typedef R(*function_pointer_type)(Args..., ...);
-			};
-
-			// Member Functions
-			/* C-Style Variadics */
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...), false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...);
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...), false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...);
-			};
-
-			/* Const Volatile */
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const volatile, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const volatile;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const volatile, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const volatile;
-			};
-
-			/* Member Function Qualifiers */
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) &, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) &, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const &, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const &, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const volatile &, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const volatile &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const volatile &, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const volatile &;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) && , false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) && ;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) && , false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) && ;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const &&, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const &&;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const &&, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const &&;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args...) const volatile &&, false> : basic_traits<false, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args...) const volatile &&;
-			};
-
-			template<typename T, typename R, typename... Args>
-			struct fx_traits<R(T::*)(Args..., ...) const volatile &&, false> : basic_traits<true, T, R, Args...> {
-				typedef R(T::* function_pointer_type)(Args..., ...) const volatile &&;
-			};
-
-			template<typename Signature>
-			struct fx_traits<Signature, true> : fx_traits<typename fx_traits<decltype(&Signature::operator())>::function_type, false> {};
-
-			template<typename Signature, bool b = std::is_member_object_pointer<Signature>::value>
-			struct callable_traits : fx_traits<std::decay_t<Signature>> {
-
-			};
-
-			template<typename R, typename T>
-			struct callable_traits<R(T::*), true> {
-				typedef R Arg;
-				typedef T object_type;
-				using signature_type = R(T::*);
-				static const bool is_member_function = false;
-				static const std::size_t arity = 1;
-				static const std::size_t free_arity = 2;
-				typedef std::tuple<Arg> args_tuple;
-				typedef R return_type;
-				typedef types<Arg> args_list;
-				typedef types<T, Arg> free_args_list;
-				typedef meta::tuple_types<R> returns_list;
-				typedef R(function_type)(T&, R);
-				typedef R(*function_pointer_type)(T&, R);
-				typedef R(*free_function_pointer_type)(T&, R);
-				template<std::size_t i>
-				using arg_at = void_tuple_element_t<i, args_tuple>;
-			};
-		} // meta_detail
-
-		template<typename Signature>
-		struct bind_traits : meta_detail::callable_traits<Signature> {};
-
-		template<typename Signature>
-		using function_args_t = typename bind_traits<Signature>::args_list;
-
-		template<typename Signature>
-		using function_signature_t = typename bind_traits<Signature>::signature_type;
-
-		template<typename Signature>
-		using function_return_t = typename bind_traits<Signature>::return_type;
-
-	} // meta
-} // sol
-
-// end of sol/bind_traits.hpp
-
-#include <type_traits>
-#include <memory>
-#include <functional>
-#include <iterator>
-
-namespace sol {
-	template<std::size_t I>
-	using index_value = std::integral_constant<std::size_t, I>;
-
-	namespace meta {
-		template<typename T>
-		struct identity { typedef T type; };
-
-		template<typename T>
-		using identity_t = typename identity<T>::type;
-
-		template<typename... Args>
-		struct is_tuple : std::false_type { };
-
-		template<typename... Args>
-		struct is_tuple<std::tuple<Args...>> : std::true_type { };
-
-		template <typename T>
-		struct is_builtin_type : std::integral_constant<bool, std::is_arithmetic<T>::value || std::is_pointer<T>::value || std::is_array<T>::value> {};
-
-		template<typename T>
-		struct unwrapped {
-			typedef T type;
-		};
-
-		template<typename T>
-		struct unwrapped<std::reference_wrapper<T>> {
-			typedef T type;
-		};
-
-		template<typename T>
-		using unwrapped_t = typename unwrapped<T>::type;
-
-		template <typename T>
-		struct unwrap_unqualified : unwrapped<unqualified_t<T>> {};
-
-		template <typename T>
-		using unwrap_unqualified_t = typename unwrap_unqualified<T>::type;
-
-		template<typename T>
-		struct remove_member_pointer;
-
-		template<typename R, typename T>
-		struct remove_member_pointer<R T::*> {
-			typedef R type;
-		};
-
-		template<typename R, typename T>
-		struct remove_member_pointer<R T::* const> {
-			typedef R type;
-		};
-
-		template<typename T>
-		using remove_member_pointer_t = remove_member_pointer<T>;
-
-		template<template<typename...> class Templ, typename T>
-		struct is_specialization_of : std::false_type { };
-		template<typename... T, template<typename...> class Templ>
-		struct is_specialization_of<Templ, Templ<T...>> : std::true_type { };
-
-		template<class T, class...>
-		struct all_same : std::true_type { };
-
-		template<class T, class U, class... Args>
-		struct all_same<T, U, Args...> : std::integral_constant <bool, std::is_same<T, U>::value && all_same<T, Args...>::value> { };
-
-		template<class T, class...>
-		struct any_same : std::false_type { };
-
-		template<class T, class U, class... Args>
-		struct any_same<T, U, Args...> : std::integral_constant <bool, std::is_same<T, U>::value || any_same<T, Args...>::value> { };
-
-		template<typename T>
-		using invoke_t = typename T::type;
-
-		template<bool B>
-		using boolean = std::integral_constant<bool, B>;
-
-		template<typename T>
-		using neg = boolean<!T::value>;
-
-		template<typename Condition, typename Then, typename Else>
-		using condition = std::conditional_t<Condition::value, Then, Else>;
-
-		template<typename... Args>
-		struct all : boolean<true> {};
-
-		template<typename T, typename... Args>
-		struct all<T, Args...> : condition<T, all<Args...>, boolean<false>> {};
-
-		template<typename... Args>
-		struct any : boolean<false> {};
-
-		template<typename T, typename... Args>
-		struct any<T, Args...> : condition<T, boolean<true>, any<Args...>> {};
-
-		enum class enable_t {
-			_
-		};
-
-		constexpr const auto enabler = enable_t::_;
-
-		template<bool value, typename T = void>
-		using disable_if_t = std::enable_if_t<!value, T>;
-
-		template<typename... Args>
-		using enable = std::enable_if_t<all<Args...>::value, enable_t>;
-
-		template<typename... Args>
-		using disable = std::enable_if_t<neg<all<Args...>>::value, enable_t>;
-
-		template<typename... Args>
-		using disable_any = std::enable_if_t<neg<any<Args...>>::value, enable_t>;
-
-		template<typename V, typename... Vs>
-		struct find_in_pack_v : boolean<false> { };
-
-		template<typename V, typename Vs1, typename... Vs>
-		struct find_in_pack_v<V, Vs1, Vs...> : any<boolean<(V::value == Vs1::value)>, find_in_pack_v<V, Vs...>> { };
-
-		namespace meta_detail {
-			template<std::size_t I, typename T, typename... Args>
-			struct index_in_pack : std::integral_constant<std::size_t, SIZE_MAX> { };
-
-			template<std::size_t I, typename T, typename T1, typename... Args>
-			struct index_in_pack<I, T, T1, Args...> : std::conditional_t<std::is_same<T, T1>::value, std::integral_constant<std::ptrdiff_t, I>, index_in_pack<I + 1, T, Args...>> { };
-		}
-
-		template<typename T, typename... Args>
-		struct index_in_pack : meta_detail::index_in_pack<0, T, Args...> { };
-
-		template<typename T, typename List>
-		struct index_in : meta_detail::index_in_pack<0, T, List> { };
-
-		template<typename T, typename... Args>
-		struct index_in<T, types<Args...>> : meta_detail::index_in_pack<0, T, Args...> { };
-
-		template<std::size_t I, typename... Args>
-		struct at_in_pack {};
-
-		template<std::size_t I, typename... Args>
-		using at_in_pack_t = typename at_in_pack<I, Args...>::type;
-
-		template<std::size_t I, typename Arg, typename... Args>
-		struct at_in_pack<I, Arg, Args...> : std::conditional<I == 0, Arg, at_in_pack_t<I - 1, Args...>> {};
-
-		template<typename Arg, typename... Args>
-		struct at_in_pack<0, Arg, Args...> { typedef Arg type; };
-
-		namespace meta_detail {
-			template<std::size_t Limit, std::size_t I, template<typename...> class Pred, typename... Ts>
-			struct count_for_pack : std::integral_constant<std::size_t, 0> {};
-			template<std::size_t Limit, std::size_t I, template<typename...> class Pred, typename T, typename... Ts>
-			struct count_for_pack<Limit, I, Pred, T, Ts...> : std::conditional_t < sizeof...(Ts) == 0 || Limit < 2,
-				std::integral_constant<std::size_t, I + static_cast<std::size_t>(Limit != 0 && Pred<T>::value)>,
-				count_for_pack<Limit - 1, I + static_cast<std::size_t>(Pred<T>::value), Pred, Ts...>
-			> { };
-			template<std::size_t I, template<typename...> class Pred, typename... Ts>
-			struct count_2_for_pack : std::integral_constant<std::size_t, 0> {};
-			template<std::size_t I, template<typename...> class Pred, typename T, typename U, typename... Ts>
-			struct count_2_for_pack<I, Pred, T, U, Ts...> : std::conditional_t<sizeof...(Ts) == 0,
-				std::integral_constant<std::size_t, I + static_cast<std::size_t>(Pred<T>::value)>,
-				count_2_for_pack<I + static_cast<std::size_t>(Pred<T>::value), Pred, Ts...>
-			> { };
-		} // meta_detail
-
-		template<template<typename...> class Pred, typename... Ts>
-		struct count_for_pack : meta_detail::count_for_pack<sizeof...(Ts), 0, Pred, Ts...> { };
-
-		template<template<typename...> class Pred, typename List>
-		struct count_for;
-
-		template<template<typename...> class Pred, typename... Args>
-		struct count_for<Pred, types<Args...>> : count_for_pack<Pred, Args...> {};
-
-		template<std::size_t Limit, template<typename...> class Pred, typename... Ts>
-		struct count_for_to_pack : meta_detail::count_for_pack<Limit, 0, Pred, Ts...> { };
-
-		template<template<typename...> class Pred, typename... Ts>
-		struct count_2_for_pack : meta_detail::count_2_for_pack<0, Pred, Ts...> { };
-
-		template<typename... Args>
-		struct return_type {
-			typedef std::tuple<Args...> type;
-		};
-
-		template<typename T>
-		struct return_type<T> {
-			typedef T type;
-		};
-
-		template<>
-		struct return_type<> {
-			typedef void type;
-		};
-
-		template <typename... Args>
-		using return_type_t = typename return_type<Args...>::type;
-
-		namespace meta_detail {
-			template <typename> struct always_true : std::true_type {};
-			struct is_invokable_tester {
-				template <typename Fun, typename... Args>
-				always_true<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
-				template <typename...>
-				std::false_type static test(...);
-			};
-		} // meta_detail
-
-		template <typename T>
-		struct is_invokable;
-		template <typename Fun, typename... Args>
-		struct is_invokable<Fun(Args...)> : decltype(meta_detail::is_invokable_tester::test<Fun, Args...>(0)) {};
-
-		namespace meta_detail {
-
-			template<typename T, bool isclass = std::is_class<unqualified_t<T>>::value>
-			struct is_callable : std::is_function<std::remove_pointer_t<T>> {};
-
-			template<typename T>
-			struct is_callable<T, true> {
-				using yes = char;
-				using no = struct { char s[2]; };
-
-				struct F { void operator()(); };
-				struct Derived : T, F {};
-				template<typename U, U> struct Check;
-
-				template<typename V>
-				static no test(Check<void (F::*)(), &V::operator()>*);
-
-				template<typename>
-				static yes test(...);
-
-				static const bool value = sizeof(test<Derived>(0)) == sizeof(yes);
-			};
-
-			struct has_begin_end_impl {
-				template<typename T, typename U = unqualified_t<T>,
-					typename B = decltype(std::declval<U&>().begin()),
-					typename E = decltype(std::declval<U&>().end())>
-					static std::true_type test(int);
-
-				template<typename...>
-				static std::false_type test(...);
-			};
-
-			struct has_key_value_pair_impl {
-				template<typename T, typename U = unqualified_t<T>,
-					typename V = typename U::value_type,
-					typename F = decltype(std::declval<V&>().first),
-					typename S = decltype(std::declval<V&>().second)>
-					static std::true_type test(int);
-
-				template<typename...>
-				static std::false_type test(...);
-			};
-
-			template <typename T, typename U = T, typename = decltype(std::declval<T&>() < std::declval<U&>())>
-			std::true_type supports_op_less_test(const T&);
-			std::false_type supports_op_less_test(...);
-			template <typename T, typename U = T, typename = decltype(std::declval<T&>() == std::declval<U&>())>
-			std::true_type supports_op_equal_test(const T&);
-			std::false_type supports_op_equal_test(...);
-			template <typename T, typename U = T, typename = decltype(std::declval<T&>() <= std::declval<U&>())>
-			std::true_type supports_op_less_equal_test(const T&);
-			std::false_type supports_op_less_equal_test(...);
-
-		} // meta_detail
-
-		template <typename T>
-		using supports_op_less = decltype(meta_detail::supports_op_less_test(std::declval<T&>()));
-		template <typename T>
-		using supports_op_equal = decltype(meta_detail::supports_op_equal_test(std::declval<T&>()));
-		template <typename T>
-		using supports_op_less_equal = decltype(meta_detail::supports_op_less_equal_test(std::declval<T&>()));
-
-		template<typename T>
-		struct is_callable : boolean<meta_detail::is_callable<T>::value> {};
-
-		template<typename T>
-		struct has_begin_end : decltype(meta_detail::has_begin_end_impl::test<T>(0)) {};
-
-		template<typename T>
-		struct has_key_value_pair : decltype(meta_detail::has_key_value_pair_impl::test<T>(0)) {};
-
-		template <typename T>
-		using is_string_constructible = any<std::is_same<unqualified_t<T>, const char*>, std::is_same<unqualified_t<T>, char>, std::is_same<unqualified_t<T>, std::string>, std::is_same<unqualified_t<T>, std::initializer_list<char>>>;
-
-		template <typename T>
-		struct is_pair : std::false_type {};
-
-		template <typename T1, typename T2>
-		struct is_pair<std::pair<T1, T2>> : std::true_type {};
-
-		template <typename T>
-		using is_c_str = any<
-			std::is_same<std::decay_t<unqualified_t<T>>, const char*>,
-			std::is_same<std::decay_t<unqualified_t<T>>, char*>,
-			std::is_same<unqualified_t<T>, std::string>
-		>;
-
-		template <typename T>
-		struct is_move_only : all<
-			neg<std::is_reference<T>>,
-			neg<std::is_copy_constructible<unqualified_t<T>>>,
-			std::is_move_constructible<unqualified_t<T>>
-		> {};
-
-		template <typename T>
-		using is_not_move_only = neg<is_move_only<T>>;
-
-		namespace meta_detail {
-			template <typename T, meta::disable<meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>> = meta::enabler>
-			decltype(auto) force_tuple(T&& x) {
-				return std::forward_as_tuple(std::forward<T>(x));
-			}
-
-			template <typename T, meta::enable<meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>> = meta::enabler>
-			decltype(auto) force_tuple(T&& x) {
-				return std::forward<T>(x);
-			}
-		} // meta_detail
-
-		template <typename... X>
-		decltype(auto) tuplefy(X&&... x) {
-			return std::tuple_cat(meta_detail::force_tuple(std::forward<X>(x))...);
-		}
-
-		template <typename T, typename = void>
-		struct iterator_tag {
-			using type = std::input_iterator_tag;
-		};
-
-		template <typename T>
-		struct iterator_tag<T, std::conditional_t<false, typename T::iterator_category, void>> {
-			using type = typename T::iterator_category;
-		};
-
-	} // meta
-
-	namespace detail {
-		template <std::size_t I, typename Tuple>
-		decltype(auto) forward_get(Tuple&& tuple) {
-			return std::forward<meta::tuple_element_t<I, Tuple>>(std::get<I>(tuple));
-		}
-
-		template <std::size_t... I, typename Tuple>
-		auto forward_tuple_impl(std::index_sequence<I...>, Tuple&& tuple) -> decltype(std::tuple<decltype(forward_get<I>(tuple))...>(forward_get<I>(tuple)...)) {
-			return std::tuple<decltype(forward_get<I>(tuple))...>(std::move(std::get<I>(tuple))...);
-		}
-
-		template <typename Tuple>
-		auto forward_tuple(Tuple&& tuple) {
-			auto x = forward_tuple_impl(std::make_index_sequence<std::tuple_size<meta::unqualified_t<Tuple>>::value>(), std::forward<Tuple>(tuple));
-			return x;
-		}
-
-		template<typename T>
-		auto unwrap(T&& item) -> decltype(std::forward<T>(item)) {
-			return std::forward<T>(item);
-		}
-
-		template<typename T>
-		T& unwrap(std::reference_wrapper<T> arg) {
-			return arg.get();
-		}
-
-		template<typename T>
-		auto deref(T&& item) -> decltype(std::forward<T>(item)) {
-			return std::forward<T>(item);
-		}
-
-		template<typename T>
-		inline T& deref(T* item) {
-			return *item;
-		}
-
-		template<typename T, typename Dx>
-		inline std::add_lvalue_reference_t<T> deref(std::unique_ptr<T, Dx>& item) {
-			return *item;
-		}
-
-		template<typename T>
-		inline std::add_lvalue_reference_t<T> deref(std::shared_ptr<T>& item) {
-			return *item;
-		}
-
-		template<typename T, typename Dx>
-		inline std::add_lvalue_reference_t<T> deref(const std::unique_ptr<T, Dx>& item) {
-			return *item;
-		}
-
-		template<typename T>
-		inline std::add_lvalue_reference_t<T> deref(const std::shared_ptr<T>& item) {
-			return *item;
-		}
-
-		template<typename T>
-		inline T* ptr(T& val) {
-			return std::addressof(val);
-		}
-
-		template<typename T>
-		inline T* ptr(std::reference_wrapper<T> val) {
-			return std::addressof(val.get());
-		}
-
-		template<typename T>
-		inline T* ptr(T* val) {
-			return val;
-		}
-	} // detail
-} // sol
-
-// end of sol/traits.hpp
-
-// beginning of sol/object.hpp
-
-// beginning of sol/reference.hpp
-
-// beginning of sol/types.hpp
-
-// beginning of sol/optional.hpp
-
-// beginning of sol/compatibility.hpp
-
-// beginning of sol/compatibility/version.hpp
-
-#ifdef SOL_USING_CXX_LUA
-#include <lua.h>
-#include <lualib.h>
-#include <lauxlib.h>
-#else
-#include <lua.hpp>
-#endif // C++ Mangling for Lua
-
-#if defined(_WIN32) || defined(_MSC_VER)
-#ifndef SOL_CODECVT_SUPPORT
-#define SOL_CODECVT_SUPPORT 1
-#endif // sol codecvt support
-#elif defined(__GNUC__)
-#if __GNUC__ >= 5
-#ifndef SOL_CODECVT_SUPPORT
-#define SOL_CODECVT_SUPPORT 1
-#endif // codecvt support
-#endif // g++ 5.x.x (MinGW too)
-#else
-#endif // Windows/VC++ vs. g++ vs Others
-
-#ifdef LUAJIT_VERSION
-#ifndef SOL_LUAJIT
-#define SOL_LUAJIT
-#define SOL_LUAJIT_VERSION LUAJIT_VERSION_NUM
-#endif // sol luajit
-#endif // luajit
-
-#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 502
-#define SOL_LUA_VERSION LUA_VERSION_NUM
-#elif defined(LUA_VERSION_NUM) && LUA_VERSION_NUM == 501
-#define SOL_LUA_VERSION LUA_VERSION_NUM
-#elif !defined(LUA_VERSION_NUM)
-#define SOL_LUA_VERSION 500
-#else
-#define SOL_LUA_VERSION 502
-#endif // Lua Version 502, 501 || luajit, 500 
-
-#ifdef _MSC_VER
-#ifdef _DEBUG
-#ifndef NDEBUG
-#ifndef SOL_CHECK_ARGUMENTS
-#endif // Check Arguments
-#ifndef SOL_SAFE_USERTYPE
-#define SOL_SAFE_USERTYPE
-#endif // Safe Usertypes
-#endif // NDEBUG
-#endif // Debug
-
-#ifndef _CPPUNWIND
-#ifndef SOL_NO_EXCEPTIONS
-#define SOL_NO_EXCEPTIONS 1
-#endif
-#endif // Automatic Exceptions
-
-#ifndef _CPPRTTI
-#ifndef SOL_NO_RTTI
-#define SOL_NO_RTTI 1
-#endif
-#endif // Automatic RTTI
-
-#elif defined(__GNUC__) || defined(__clang__)
-
-#ifndef NDEBUG
-#ifndef __OPTIMIZE__
-#ifndef SOL_CHECK_ARGUMENTS
-#endif // Check Arguments
-#ifndef SOL_SAFE_USERTYPE
-#define SOL_SAFE_USERTYPE
-#endif // Safe Usertypes
-#endif // g++ optimizer flag
-#endif // Not Debug
-
-#ifndef __EXCEPTIONS
-#ifndef SOL_NO_EXCEPTIONS
-#define SOL_NO_EXCEPTIONS 1
-#endif
-#endif // No Exceptions
-
-#ifndef __GXX_RTTI
-#ifndef SOL_NO_RTII
-#define SOL_NO_RTTI 1
-#endif
-#endif // No RTTI
-
-#endif // vc++ || clang++/g++
-
-#ifndef SOL_SAFE_USERTYPE
-#ifdef SOL_CHECK_ARGUMENTS
-#define SOL_SAFE_USERTYPE
-#endif // Turn on Safety for all
-#endif // Safe Usertypes
-
-// end of sol/compatibility/version.hpp
-
-#ifndef SOL_NO_COMPAT
-
-#if defined(__cplusplus) && !defined(SOL_USING_CXX_LUA)
-extern "C" {
-#endif
-// beginning of sol/compatibility/5.2.0.h
-
-#ifndef SOL_5_2_0_H
-#define SOL_5_2_0_H
-
-#if SOL_LUA_VERSION < 503
-
-inline int lua_isinteger(lua_State* L, int idx) {
-	if (lua_type(L, idx) != LUA_TNUMBER)
-		return 0;
-	// This is a very slipshod way to do the testing
-	// but lua_totingerx doesn't play ball nicely
-	// on older versions...
-	lua_Number n = lua_tonumber(L, idx);
-	lua_Integer i = lua_tointeger(L, idx);
-	if (i != n)
-		return 0;
-	// it's DEFINITELY an integer
-	return 1;
-}
-
-#endif // SOL_LUA_VERSION == 502
-#endif // SOL_5_2_0_H
-// end of sol/compatibility/5.2.0.h
-
-// beginning of sol/compatibility/5.1.0.h
-
-#ifndef SOL_5_1_0_H
-#define SOL_5_1_0_H
-
-#if SOL_LUA_VERSION == 501
-/* Lua 5.1 */
-
-#include <stddef.h>
-#include <string.h>
-#include <stdio.h>
-
-/* LuaJIT doesn't define these unofficial macros ... */
-#if !defined(LUAI_INT32)
-#include <limits.h>
-#if INT_MAX-20 < 32760
-#define LUAI_INT32  long
-#define LUAI_UINT32 unsigned long
-#elif INT_MAX > 2147483640L
-#define LUAI_INT32  int
-#define LUAI_UINT32 unsigned int
-#else
-#error "could not detect suitable lua_Unsigned datatype"
-#endif
-#endif
-
-/* LuaJIT does not have the updated error codes for thread status/function returns */
-#ifndef LUA_ERRGCMM
-#define LUA_ERRGCMM (LUA_ERRERR + 2)
-#endif // LUA_ERRGCMM
-
-/* LuaJIT does not support continuation contexts / return error codes? */
-#ifndef LUA_KCONTEXT
-#define LUA_KCONTEXT std::ptrdiff_t
-typedef LUA_KCONTEXT lua_KContext;
-typedef int(*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);
-#endif // LUA_KCONTEXT
-
-#define LUA_OPADD 0
-#define LUA_OPSUB 1
-#define LUA_OPMUL 2
-#define LUA_OPDIV 3
-#define LUA_OPMOD 4
-#define LUA_OPPOW 5
-#define LUA_OPUNM 6
-#define LUA_OPEQ 0
-#define LUA_OPLT 1
-#define LUA_OPLE 2
-
-typedef LUAI_UINT32 lua_Unsigned;
-
-typedef struct luaL_Buffer_52 {
-    luaL_Buffer b; /* make incorrect code crash! */
-    char *ptr;
-    size_t nelems;
-    size_t capacity;
-    lua_State *L2;
-} luaL_Buffer_52;
-#define luaL_Buffer luaL_Buffer_52
-
-#define lua_tounsigned(L, i) lua_tounsignedx(L, i, NULL)
-
-#define lua_rawlen(L, i) lua_objlen(L, i)
-
-inline void lua_callk(lua_State *L, int nargs, int nresults, lua_KContext, lua_KFunction) {
-    // should probably warn the user of Lua 5.1 that continuation isn't supported...
-    lua_call(L, nargs, nresults);
-}
-inline int lua_pcallk(lua_State *L, int nargs, int nresults, int errfunc, lua_KContext, lua_KFunction) {
-    // should probably warn the user of Lua 5.1 that continuation isn't supported...
-    return lua_pcall(L, nargs, nresults, errfunc);
-}
-void lua_arith(lua_State *L, int op);
-int lua_compare(lua_State *L, int idx1, int idx2, int op);
-void lua_pushunsigned(lua_State *L, lua_Unsigned n);
-lua_Unsigned luaL_checkunsigned(lua_State *L, int i);
-lua_Unsigned lua_tounsignedx(lua_State *L, int i, int *isnum);
-lua_Unsigned luaL_optunsigned(lua_State *L, int i, lua_Unsigned def);
-lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum);
-void lua_len(lua_State *L, int i);
-int luaL_len(lua_State *L, int i);
-const char *luaL_tolstring(lua_State *L, int idx, size_t *len);
-void luaL_requiref(lua_State *L, char const* modname, lua_CFunction openf, int glb);
-
-#define luaL_buffinit luaL_buffinit_52
-void luaL_buffinit(lua_State *L, luaL_Buffer_52 *B);
-
-#define luaL_prepbuffsize luaL_prepbuffsize_52
-char *luaL_prepbuffsize(luaL_Buffer_52 *B, size_t s);
-
-#define luaL_addlstring luaL_addlstring_52
-void luaL_addlstring(luaL_Buffer_52 *B, const char *s, size_t l);
-
-#define luaL_addvalue luaL_addvalue_52
-void luaL_addvalue(luaL_Buffer_52 *B);
-
-#define luaL_pushresult luaL_pushresult_52
-void luaL_pushresult(luaL_Buffer_52 *B);
-
-#undef luaL_buffinitsize
-#define luaL_buffinitsize(L, B, s) \
-  (luaL_buffinit(L, B), luaL_prepbuffsize(B, s))
-
-#undef luaL_prepbuffer
-#define luaL_prepbuffer(B) \
-  luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
-
-#undef luaL_addchar
-#define luaL_addchar(B, c) \
-  ((void)((B)->nelems < (B)->capacity || luaL_prepbuffsize(B, 1)), \
-   ((B)->ptr[(B)->nelems++] = (c)))
-
-#undef luaL_addsize
-#define luaL_addsize(B, s) \
-  ((B)->nelems += (s))
-
-#undef luaL_addstring
-#define luaL_addstring(B, s) \
-  luaL_addlstring(B, s, strlen(s))
-
-#undef luaL_pushresultsize
-#define luaL_pushresultsize(B, s) \
-  (luaL_addsize(B, s), luaL_pushresult(B))
-
-typedef struct kepler_lua_compat_get_string_view {
-	const char *s;
-	size_t size;
-} kepler_lua_compat_get_string_view;
-
-inline const char* kepler_lua_compat_get_string(lua_State* L, void* ud, size_t* size) {
-    kepler_lua_compat_get_string_view* ls = (kepler_lua_compat_get_string_view*) ud;
-    (void)L;
-    if (ls->size == 0) return NULL;
-    *size = ls->size;
-    ls->size = 0;
-    return ls->s;
-}
-
-#if !defined(SOL_LUAJIT) || (SOL_LUAJIT_VERSION < 20100)
-
-inline int luaL_loadbufferx(lua_State* L, const char* buff, size_t size, const char* name, const char*) {
-    kepler_lua_compat_get_string_view ls;
-    ls.s = buff;
-    ls.size = size;
-    return lua_load(L, kepler_lua_compat_get_string, &ls, name/*, mode*/);
-}
-
-#endif // LuaJIT 2.1.x beta and beyond
-
-#endif /* Lua 5.1 */
-
-#endif // SOL_5_1_0_H
-// end of sol/compatibility/5.1.0.h
-
-// beginning of sol/compatibility/5.0.0.h
-
-#ifndef SOL_5_0_0_H
-#define SOL_5_0_0_H
-
-#if SOL_LUA_VERSION < 501
-/* Lua 5.0 */
-
-#define LUA_QL(x) "'" x "'"
-#define LUA_QS LUA_QL("%s")
-
-#define luaL_Reg luaL_reg
-
-#define luaL_opt(L, f, n, d) \
-  (lua_isnoneornil(L, n) ? (d) : f(L, n))
-
-#define luaL_addchar(B,c) \
-  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
-   (*(B)->p++ = (char)(c)))
-
-#endif // Lua 5.0
-
-#endif // SOL_5_0_0_H
-// end of sol/compatibility/5.0.0.h
-
-// beginning of sol/compatibility/5.x.x.h
-
-#ifndef SOL_5_X_X_H
-#define SOL_5_X_X_H
-
-#if SOL_LUA_VERSION < 502
-
-#define LUA_RIDX_GLOBALS LUA_GLOBALSINDEX
-
-#define LUA_OK 0
-
-#define lua_pushglobaltable(L) \
-  lua_pushvalue(L, LUA_GLOBALSINDEX)
-
-#ifndef SOL_LUAJIT
-#define luaL_newlib(L, l) \
-  (lua_newtable((L)),luaL_setfuncs((L), (l), 0))
-#else
-#if SOL_LUAJIT_VERSION < 20100
-#define luaL_newlib(L, l) \
-  (lua_newtable((L)),luaL_setfuncs((L), (l), 0))
-#endif // LuaJIT-2.1.0-beta3 added this in itself
-#endif // LuaJIT Compatibility
-
-void luaL_checkversion(lua_State *L);
-
-int lua_absindex(lua_State *L, int i);
-void lua_copy(lua_State *L, int from, int to);
-void lua_rawgetp(lua_State *L, int i, const void *p);
-void lua_rawsetp(lua_State *L, int i, const void *p);
-void *luaL_testudata(lua_State *L, int i, const char *tname);
-lua_Number lua_tonumberx(lua_State *L, int i, int *isnum);
-void lua_getuservalue(lua_State *L, int i);
-void lua_setuservalue(lua_State *L, int i);
-void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup);
-void luaL_setmetatable(lua_State *L, const char *tname);
-int luaL_getsubtable(lua_State *L, int i, const char *name);
-void luaL_traceback(lua_State *L, lua_State *L1, const char *msg, int level);
-int luaL_fileresult(lua_State *L, int stat, const char *fname);
-
-#endif // Lua 5.1 and below
-
-#endif // SOL_5_X_X_H
-// end of sol/compatibility/5.x.x.h
-
-// beginning of sol/compatibility/5.x.x.inl
-
-#ifndef SOL_5_X_X_INL
-#define SOL_5_X_X_INL
-
-#if SOL_LUA_VERSION < 502
-
-#include <errno.h>
-
-#define PACKAGE_KEY "_sol.package"
-
-inline int lua_absindex(lua_State *L, int i) {
-    if (i < 0 && i > LUA_REGISTRYINDEX)
-        i += lua_gettop(L) + 1;
-    return i;
-}
-
-inline void lua_copy(lua_State *L, int from, int to) {
-    int abs_to = lua_absindex(L, to);
-    luaL_checkstack(L, 1, "not enough stack slots");
-    lua_pushvalue(L, from);
-    lua_replace(L, abs_to);
-}
-
-inline void lua_rawgetp(lua_State *L, int i, const void *p) {
-    int abs_i = lua_absindex(L, i);
-    lua_pushlightuserdata(L, (void*)p);
-    lua_rawget(L, abs_i);
-}
-
-inline void lua_rawsetp(lua_State *L, int i, const void *p) {
-    int abs_i = lua_absindex(L, i);
-    luaL_checkstack(L, 1, "not enough stack slots");
-    lua_pushlightuserdata(L, (void*)p);
-    lua_insert(L, -2);
-    lua_rawset(L, abs_i);
-}
-
-inline void *luaL_testudata(lua_State *L, int i, const char *tname) {
-    void *p = lua_touserdata(L, i);
-    luaL_checkstack(L, 2, "not enough stack slots");
-    if (p == NULL || !lua_getmetatable(L, i))
-        return NULL;
-    else {
-        int res = 0;
-        luaL_getmetatable(L, tname);
-        res = lua_rawequal(L, -1, -2);
-        lua_pop(L, 2);
-        if (!res)
-            p = NULL;
-    }
-    return p;
-}
-
-inline lua_Number lua_tonumberx(lua_State *L, int i, int *isnum) {
-    lua_Number n = lua_tonumber(L, i);
-    if (isnum != NULL) {
-        *isnum = (n != 0 || lua_isnumber(L, i));
-    }
-    return n;
-}
-
-inline static void push_package_table(lua_State *L) {
-    lua_pushliteral(L, PACKAGE_KEY);
-    lua_rawget(L, LUA_REGISTRYINDEX);
-    if (!lua_istable(L, -1)) {
-        lua_pop(L, 1);
-        /* try to get package table from globals */
-        lua_pushliteral(L, "package");
-        lua_rawget(L, LUA_GLOBALSINDEX);
-        if (lua_istable(L, -1)) {
-            lua_pushliteral(L, PACKAGE_KEY);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, LUA_REGISTRYINDEX);
-        }
-    }
-}
-
-inline void lua_getuservalue(lua_State *L, int i) {
-    luaL_checktype(L, i, LUA_TUSERDATA);
-    luaL_checkstack(L, 2, "not enough stack slots");
-    lua_getfenv(L, i);
-    lua_pushvalue(L, LUA_GLOBALSINDEX);
-    if (lua_rawequal(L, -1, -2)) {
-        lua_pop(L, 1);
-        lua_pushnil(L);
-        lua_replace(L, -2);
-    }
-    else {
-        lua_pop(L, 1);
-        push_package_table(L);
-        if (lua_rawequal(L, -1, -2)) {
-            lua_pop(L, 1);
-            lua_pushnil(L);
-            lua_replace(L, -2);
-        }
-        else
-            lua_pop(L, 1);
-    }
-}
-
-inline void lua_setuservalue(lua_State *L, int i) {
-    luaL_checktype(L, i, LUA_TUSERDATA);
-    if (lua_isnil(L, -1)) {
-        luaL_checkstack(L, 1, "not enough stack slots");
-        lua_pushvalue(L, LUA_GLOBALSINDEX);
-        lua_replace(L, -2);
-    }
-    lua_setfenv(L, i);
-}
-
-/*
-** Adapted from Lua 5.2.0
-*/
-inline void luaL_setfuncs(lua_State *L, const luaL_Reg *l, int nup) {
-    luaL_checkstack(L, nup + 1, "too many upvalues");
-    for (; l->name != NULL; l++) {  /* fill the table with given functions */
-        int i;
-        lua_pushstring(L, l->name);
-        for (i = 0; i < nup; i++)  /* copy upvalues to the top */
-            lua_pushvalue(L, -(nup + 1));
-        lua_pushcclosure(L, l->func, nup);  /* closure with those upvalues */
-        lua_settable(L, -(nup + 3)); /* table must be below the upvalues, the name and the closure */
-    }
-    lua_pop(L, nup);  /* remove upvalues */
-}
-
-inline void luaL_setmetatable(lua_State *L, const char *tname) {
-    luaL_checkstack(L, 1, "not enough stack slots");
-    luaL_getmetatable(L, tname);
-    lua_setmetatable(L, -2);
-}
-
-inline int luaL_getsubtable(lua_State *L, int i, const char *name) {
-    int abs_i = lua_absindex(L, i);
-    luaL_checkstack(L, 3, "not enough stack slots");
-    lua_pushstring(L, name);
-    lua_gettable(L, abs_i);
-    if (lua_istable(L, -1))
-        return 1;
-    lua_pop(L, 1);
-    lua_newtable(L);
-    lua_pushstring(L, name);
-    lua_pushvalue(L, -2);
-    lua_settable(L, abs_i);
-    return 0;
-}
-
-#ifndef SOL_LUAJIT
-inline static int countlevels(lua_State *L) {
-    lua_Debug ar;
-    int li = 1, le = 1;
-    /* find an upper bound */
-    while (lua_getstack(L, le, &ar)) { li = le; le *= 2; }
-    /* do a binary search */
-    while (li < le) {
-        int m = (li + le) / 2;
-        if (lua_getstack(L, m, &ar)) li = m + 1;
-        else le = m;
-    }
-    return le - 1;
-}
-
-inline static int findfield(lua_State *L, int objidx, int level) {
-    if (level == 0 || !lua_istable(L, -1))
-        return 0;  /* not found */
-    lua_pushnil(L);  /* start 'next' loop */
-    while (lua_next(L, -2)) {  /* for each pair in table */
-        if (lua_type(L, -2) == LUA_TSTRING) {  /* ignore non-string keys */
-            if (lua_rawequal(L, objidx, -1)) {  /* found object? */
-                lua_pop(L, 1);  /* remove value (but keep name) */
-                return 1;
-            }
-            else if (findfield(L, objidx, level - 1)) {  /* try recursively */
-                lua_remove(L, -2);  /* remove table (but keep name) */
-                lua_pushliteral(L, ".");
-                lua_insert(L, -2);  /* place '.' between the two names */
-                lua_concat(L, 3);
-                return 1;
-            }
-        }
-        lua_pop(L, 1);  /* remove value */
-    }
-    return 0;  /* not found */
-}
-
-inline static int pushglobalfuncname(lua_State *L, lua_Debug *ar) {
-    int top = lua_gettop(L);
-    lua_getinfo(L, "f", ar);  /* push function */
-    lua_pushvalue(L, LUA_GLOBALSINDEX);
-    if (findfield(L, top + 1, 2)) {
-        lua_copy(L, -1, top + 1);  /* move name to proper place */
-        lua_pop(L, 2);  /* remove pushed values */
-        return 1;
-    }
-    else {
-        lua_settop(L, top);  /* remove function and global table */
-        return 0;
-    }
-}
-
-inline static void pushfuncname(lua_State *L, lua_Debug *ar) {
-    if (*ar->namewhat != '\0')  /* is there a name? */
-        lua_pushfstring(L, "function " LUA_QS, ar->name);
-    else if (*ar->what == 'm')  /* main? */
-        lua_pushliteral(L, "main chunk");
-    else if (*ar->what == 'C') {
-        if (pushglobalfuncname(L, ar)) {
-            lua_pushfstring(L, "function " LUA_QS, lua_tostring(L, -1));
-            lua_remove(L, -2);  /* remove name */
-        }
-        else
-            lua_pushliteral(L, "?");
-    }
-    else
-        lua_pushfstring(L, "function <%s:%d>", ar->short_src, ar->linedefined);
-}
-
-#define LEVELS1 12  /* size of the first part of the stack */
-#define LEVELS2 10  /* size of the second part of the stack */
-
-inline void luaL_traceback(lua_State *L, lua_State *L1,
-    const char *msg, int level) {
-    lua_Debug ar;
-    int top = lua_gettop(L);
-    int numlevels = countlevels(L1);
-    int mark = (numlevels > LEVELS1 + LEVELS2) ? LEVELS1 : 0;
-    if (msg) lua_pushfstring(L, "%s\n", msg);
-    lua_pushliteral(L, "stack traceback:");
-    while (lua_getstack(L1, level++, &ar)) {
-        if (level == mark) {  /* too many levels? */
-            lua_pushliteral(L, "\n\t...");  /* add a '...' */
-            level = numlevels - LEVELS2;  /* and skip to last ones */
-        }
-        else {
-            lua_getinfo(L1, "Slnt", &ar);
-            lua_pushfstring(L, "\n\t%s:", ar.short_src);
-            if (ar.currentline > 0)
-                lua_pushfstring(L, "%d:", ar.currentline);
-            lua_pushliteral(L, " in ");
-            pushfuncname(L, &ar);
-            lua_concat(L, lua_gettop(L) - top);
-        }
-    }
-    lua_concat(L, lua_gettop(L) - top);
-}
-#endif
-
-inline const lua_Number *lua_version(lua_State *L) {
-    static const lua_Number version = LUA_VERSION_NUM;
-    if (L == NULL) return &version;
-    // TODO: wonky hacks to get at the inside of the incomplete type lua_State?
-    //else return L->l_G->version;
-    else return &version;
-}
-
-inline static void luaL_checkversion_(lua_State *L, lua_Number ver) {
-    const lua_Number* v = lua_version(L);
-    if (v != lua_version(NULL))
-        luaL_error(L, "multiple Lua VMs detected");
-    else if (*v != ver)
-        luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
-            ver, *v);
-    /* check conversions number -> integer types */
-    lua_pushnumber(L, -(lua_Number)0x1234);
-    if (lua_tointeger(L, -1) != -0x1234 ||
-        lua_tounsigned(L, -1) != (lua_Unsigned)-0x1234)
-        luaL_error(L, "bad conversion number->int;"
-            " must recompile Lua with proper settings");
-    lua_pop(L, 1);
-}
-
-inline void luaL_checkversion(lua_State* L) {
-    luaL_checkversion_(L, LUA_VERSION_NUM);
-}
-
-#ifndef SOL_LUAJIT
-inline int luaL_fileresult(lua_State *L, int stat, const char *fname) {
-    int en = errno;  /* calls to Lua API may change this value */
-    if (stat) {
-        lua_pushboolean(L, 1);
-        return 1;
-    }
-    else {
-        char buf[1024];
-#if defined(__GLIBC__) || defined(_POSIX_VERSION)
-        strerror_r(en, buf, 1024);
-#else
-        strerror_s(buf, 1024, en);
-#endif
-        lua_pushnil(L);
-        if (fname)
-            lua_pushfstring(L, "%s: %s", fname, buf);
-        else
-            lua_pushstring(L, buf);
-        lua_pushnumber(L, (lua_Number)en);
-        return 3;
-    }
-}
-#endif // luajit
-#endif // Lua 5.0 or Lua 5.1
-
-#if SOL_LUA_VERSION == 501
-
-typedef LUAI_INT32 LUA_INT32;
-
-/********************************************************************/
-/*                    extract of 5.2's luaconf.h                    */
-/*  detects proper defines for faster unsigned<->number conversion  */
-/*           see copyright notice at the end of this file           */
-/********************************************************************/
-
-#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
-#define LUA_WIN        /* enable goodies for regular Windows platforms */
-#endif
-
-#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI)    /* { */
-
-/* Microsoft compiler on a Pentium (32 bit) ? */
-#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86)    /* { */
-
-#define LUA_MSASMTRICK
-#define LUA_IEEEENDIAN        0
-#define LUA_NANTRICK
-
-/* pentium 32 bits? */
-#elif defined(__i386__) || defined(__i386) || defined(__X86__) /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEELL
-#define LUA_IEEEENDIAN        0
-#define LUA_NANTRICK
-
-/* pentium 64 bits? */
-#elif defined(__x86_64)                        /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEEENDIAN        0
-
-#elif defined(__POWERPC__) || defined(__ppc__)            /* }{ */
-
-#define LUA_IEEE754TRICK
-#define LUA_IEEEENDIAN        1
-
-#else                                /* }{ */
-
-/* assume IEEE754 and a 32-bit integer type */
-#define LUA_IEEE754TRICK
-
-#endif                                /* } */
-
-#endif                            /* } */
-
-/********************************************************************/
-/*                    extract of 5.2's llimits.h                    */
-/*       gives us lua_number2unsigned and lua_unsigned2number       */
-/*           see copyright notice just below this one here          */
-/********************************************************************/
-
-/*********************************************************************
-* This file contains parts of Lua 5.2's source code:
-*
-* Copyright (C) 1994-2013 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*********************************************************************/
-
-#if defined(MS_ASMTRICK) || defined(LUA_MSASMTRICK)    /* { */
-/* trick with Microsoft assembler for X86 */
-
-#define lua_number2unsigned(i,n)  \
-  {__int64 l; __asm {__asm fld n   __asm fistp l} i = (unsigned int)l;}
-
-#elif defined(LUA_IEEE754TRICK)        /* }{ */
-/* the next trick should work on any machine using IEEE754 with
-a 32-bit int type */
-
-union compat52_luai_Cast { double l_d; LUA_INT32 l_p[2]; };
-
-#if !defined(LUA_IEEEENDIAN)    /* { */
-#define LUAI_EXTRAIEEE    \
-  static const union compat52_luai_Cast ieeeendian = {-(33.0 + 6755399441055744.0)};
-#define LUA_IEEEENDIANLOC    (ieeeendian.l_p[1] == 33)
-#else
-#define LUA_IEEEENDIANLOC    LUA_IEEEENDIAN
-#define LUAI_EXTRAIEEE        /* empty */
-#endif                /* } */
-
-#define lua_number2int32(i,n,t) \
-  { LUAI_EXTRAIEEE \
-    volatile union compat52_luai_Cast u; u.l_d = (n) + 6755399441055744.0; \
-    (i) = (t)u.l_p[LUA_IEEEENDIANLOC]; }
-
-#define lua_number2unsigned(i,n)    lua_number2int32(i, n, lua_Unsigned)
-
-#endif                /* } */
-
-/* the following definitions always work, but may be slow */
-
-#if !defined(lua_number2unsigned)    /* { */
-/* the following definition assures proper modulo behavior */
-#if defined(LUA_NUMBER_DOUBLE) || defined(LUA_NUMBER_FLOAT)
-#include <math.h>
-#define SUPUNSIGNED    ((lua_Number)(~(lua_Unsigned)0) + 1)
-#define lua_number2unsigned(i,n)  \
-    ((i)=(lua_Unsigned)((n) - floor((n)/SUPUNSIGNED)*SUPUNSIGNED))
-#else
-#define lua_number2unsigned(i,n)    ((i)=(lua_Unsigned)(n))
-#endif
-#endif                /* } */
-
-#if !defined(lua_unsigned2number)
-/* on several machines, coercion from unsigned to double is slow,
-so it may be worth to avoid */
-#define lua_unsigned2number(u)  \
-    (((u) <= (lua_Unsigned)INT_MAX) ? (lua_Number)(int)(u) : (lua_Number)(u))
-#endif
-
-/********************************************************************/
-
-inline static void compat52_call_lua(lua_State *L, char const code[], size_t len,
-    int nargs, int nret) {
-    lua_rawgetp(L, LUA_REGISTRYINDEX, (void*)code);
-    if (lua_type(L, -1) != LUA_TFUNCTION) {
-        lua_pop(L, 1);
-        if (luaL_loadbuffer(L, code, len, "=none"))
-            lua_error(L);
-        lua_pushvalue(L, -1);
-        lua_rawsetp(L, LUA_REGISTRYINDEX, (void*)code);
-    }
-    lua_insert(L, -nargs - 1);
-    lua_call(L, nargs, nret);
-}
-
-static const char compat52_arith_code[] = {
-    "local op,a,b=...\n"
-    "if op==0 then return a+b\n"
-    "elseif op==1 then return a-b\n"
-    "elseif op==2 then return a*b\n"
-    "elseif op==3 then return a/b\n"
-    "elseif op==4 then return a%b\n"
-    "elseif op==5 then return a^b\n"
-    "elseif op==6 then return -a\n"
-    "end\n"
-};
-
-inline void lua_arith(lua_State *L, int op) {
-    if (op < LUA_OPADD || op > LUA_OPUNM)
-        luaL_error(L, "invalid 'op' argument for lua_arith");
-    luaL_checkstack(L, 5, "not enough stack slots");
-    if (op == LUA_OPUNM)
-        lua_pushvalue(L, -1);
-    lua_pushnumber(L, op);
-    lua_insert(L, -3);
-    compat52_call_lua(L, compat52_arith_code,
-        sizeof(compat52_arith_code) - 1, 3, 1);
-}
-
-static const char compat52_compare_code[] = {
-    "local a,b=...\n"
-    "return a<=b\n"
-};
-
-inline int lua_compare(lua_State *L, int idx1, int idx2, int op) {
-    int result = 0;
-    switch (op) {
-    case LUA_OPEQ:
-        return lua_equal(L, idx1, idx2);
-    case LUA_OPLT:
-        return lua_lessthan(L, idx1, idx2);
-    case LUA_OPLE:
-        luaL_checkstack(L, 5, "not enough stack slots");
-        idx1 = lua_absindex(L, idx1);
-        idx2 = lua_absindex(L, idx2);
-        lua_pushvalue(L, idx1);
-        lua_pushvalue(L, idx2);
-        compat52_call_lua(L, compat52_compare_code,
-            sizeof(compat52_compare_code) - 1, 2, 1);
-        result = lua_toboolean(L, -1);
-        lua_pop(L, 1);
-        return result;
-    default:
-        luaL_error(L, "invalid 'op' argument for lua_compare");
-    }
-    return 0;
-}
-
-inline void lua_pushunsigned(lua_State *L, lua_Unsigned n) {
-    lua_pushnumber(L, lua_unsigned2number(n));
-}
-
-inline lua_Unsigned luaL_checkunsigned(lua_State *L, int i) {
-    lua_Unsigned result;
-    lua_Number n = lua_tonumber(L, i);
-    if (n == 0 && !lua_isnumber(L, i))
-        luaL_checktype(L, i, LUA_TNUMBER);
-    lua_number2unsigned(result, n);
-    return result;
-}
-
-inline lua_Unsigned lua_tounsignedx(lua_State *L, int i, int *isnum) {
-    lua_Unsigned result;
-    lua_Number n = lua_tonumberx(L, i, isnum);
-    lua_number2unsigned(result, n);
-    return result;
-}
-
-inline lua_Unsigned luaL_optunsigned(lua_State *L, int i, lua_Unsigned def) {
-    return luaL_opt(L, luaL_checkunsigned, i, def);
-}
-
-inline lua_Integer lua_tointegerx(lua_State *L, int i, int *isnum) {
-    lua_Integer n = lua_tointeger(L, i);
-    if (isnum != NULL) {
-        *isnum = (n != 0 || lua_isnumber(L, i));
-    }
-    return n;
-}
-
-inline void lua_len(lua_State *L, int i) {
-    switch (lua_type(L, i)) {
-    case LUA_TSTRING: /* fall through */
-    case LUA_TTABLE:
-        if (!luaL_callmeta(L, i, "__len"))
-            lua_pushnumber(L, (int)lua_objlen(L, i));
-        break;
-    case LUA_TUSERDATA:
-        if (luaL_callmeta(L, i, "__len"))
-            break;
-        /* maybe fall through */
-    default:
-        luaL_error(L, "attempt to get length of a %s value",
-            lua_typename(L, lua_type(L, i)));
-    }
-}
-
-inline int luaL_len(lua_State *L, int i) {
-    int res = 0, isnum = 0;
-    luaL_checkstack(L, 1, "not enough stack slots");
-    lua_len(L, i);
-    res = (int)lua_tointegerx(L, -1, &isnum);
-    lua_pop(L, 1);
-    if (!isnum)
-        luaL_error(L, "object length is not a number");
-    return res;
-}
-
-inline const char *luaL_tolstring(lua_State *L, int idx, size_t *len) {
-    if (!luaL_callmeta(L, idx, "__tostring")) {
-        int t = lua_type(L, idx);
-        switch (t) {
-        case LUA_TNIL:
-            lua_pushliteral(L, "nil");
-            break;
-        case LUA_TSTRING:
-        case LUA_TNUMBER:
-            lua_pushvalue(L, idx);
-            break;
-        case LUA_TBOOLEAN:
-            if (lua_toboolean(L, idx))
-                lua_pushliteral(L, "true");
-            else
-                lua_pushliteral(L, "false");
-            break;
-        default:
-            lua_pushfstring(L, "%s: %p", lua_typename(L, t),
-                lua_topointer(L, idx));
-            break;
-        }
-    }
-    return lua_tolstring(L, -1, len);
-}
-
-inline void luaL_requiref(lua_State *L, char const* modname,
-    lua_CFunction openf, int glb) {
-    luaL_checkstack(L, 3, "not enough stack slots");
-    lua_pushcfunction(L, openf);
-    lua_pushstring(L, modname);
-    lua_call(L, 1, 1);
-    lua_getglobal(L, "package");
-    if (lua_istable(L, -1) == 0) {
-        lua_pop(L, 1);
-        lua_createtable(L, 0, 16);
-        lua_setglobal(L, "package");
-        lua_getglobal(L, "package");
-    }
-    lua_getfield(L, -1, "loaded");
-    if (lua_istable(L, -1) == 0) {
-        lua_pop(L, 1);
-        lua_createtable(L, 0, 1);
-        lua_setfield(L, -2, "loaded");
-        lua_getfield(L, -1, "loaded");
-    }
-    lua_replace(L, -2);
-    lua_pushvalue(L, -2);
-    lua_setfield(L, -2, modname);
-    lua_pop(L, 1);
-    if (glb) {
-        lua_pushvalue(L, -1);
-        lua_setglobal(L, modname);
-    }
-}
-
-inline void luaL_buffinit(lua_State *L, luaL_Buffer_52 *B) {
-    /* make it crash if used via pointer to a 5.1-style luaL_Buffer */
-    B->b.p = NULL;
-    B->b.L = NULL;
-    B->b.lvl = 0;
-    /* reuse the buffer from the 5.1-style luaL_Buffer though! */
-    B->ptr = B->b.buffer;
-    B->capacity = LUAL_BUFFERSIZE;
-    B->nelems = 0;
-    B->L2 = L;
-}
-
-inline char *luaL_prepbuffsize(luaL_Buffer_52 *B, size_t s) {
-    if (B->capacity - B->nelems < s) { /* needs to grow */
-        char* newptr = NULL;
-        size_t newcap = B->capacity * 2;
-        if (newcap - B->nelems < s)
-            newcap = B->nelems + s;
-        if (newcap < B->capacity) /* overflow */
-            luaL_error(B->L2, "buffer too large");
-        newptr = (char*)lua_newuserdata(B->L2, newcap);
-        memcpy(newptr, B->ptr, B->nelems);
-        if (B->ptr != B->b.buffer)
-            lua_replace(B->L2, -2); /* remove old buffer */
-        B->ptr = newptr;
-        B->capacity = newcap;
-    }
-    return B->ptr + B->nelems;
-}
-
-inline void luaL_addlstring(luaL_Buffer_52 *B, const char *s, size_t l) {
-    memcpy(luaL_prepbuffsize(B, l), s, l);
-    luaL_addsize(B, l);
-}
-
-inline void luaL_addvalue(luaL_Buffer_52 *B) {
-    size_t len = 0;
-    const char *s = lua_tolstring(B->L2, -1, &len);
-    if (!s)
-        luaL_error(B->L2, "cannot convert value to string");
-    if (B->ptr != B->b.buffer)
-        lua_insert(B->L2, -2); /* userdata buffer must be at stack top */
-    luaL_addlstring(B, s, len);
-    lua_remove(B->L2, B->ptr != B->b.buffer ? -2 : -1);
-}
-
-inline void luaL_pushresult(luaL_Buffer_52 *B) {
-    lua_pushlstring(B->L2, B->ptr, B->nelems);
-    if (B->ptr != B->b.buffer)
-        lua_replace(B->L2, -2); /* remove userdata buffer */
-}
-
-#endif /* SOL_LUA_VERSION == 501 */
-
-#endif // SOL_5_X_X_INL
-// end of sol/compatibility/5.x.x.inl
-
-#if defined(__cplusplus) && !defined(SOL_USING_CXX_LUA)
-}
-#endif
-
-#endif // SOL_NO_COMPAT
-
-// end of sol/compatibility.hpp
-
-// beginning of sol/in_place.hpp
-
-namespace sol {
-
-	namespace detail {
-		struct in_place_of {};
-		template <std::size_t I>
-		struct in_place_of_i {};
-		template <typename T>
-		struct in_place_of_t {};
-	} // detail
-
-	struct in_place_tag { struct init {}; constexpr in_place_tag(init) {} in_place_tag() = delete; };
-	constexpr inline in_place_tag in_place(detail::in_place_of) { return in_place_tag(in_place_tag::init()); }
-	template <typename T>
-	constexpr inline in_place_tag in_place(detail::in_place_of_t<T>) { return in_place_tag(in_place_tag::init()); }
-	template <std::size_t I>
-	constexpr inline in_place_tag in_place(detail::in_place_of_i<I>) { return in_place_tag(in_place_tag::init()); }
-
-	using in_place_t = in_place_tag(&)(detail::in_place_of);
-	template <typename T>
-	using in_place_type_t = in_place_tag(&)(detail::in_place_of_t<T>);
-	template <std::size_t I>
-	using in_place_index_t = in_place_tag(&)(detail::in_place_of_i<I>);
-
-} // sol
-
-// end of sol/in_place.hpp
-
-#if defined(SOL_USE_BOOST)
-#include <boost/optional.hpp>
-#else
-// beginning of sol/optional_implementation.hpp
-
-# ifndef SOL_OPTIONAL_IMPLEMENTATION_HPP
-# define SOL_OPTIONAL_IMPLEMENTATION_HPP
-
-# include <utility>
-# include <type_traits>
-# include <initializer_list>
-# include <cassert>
-# include <functional>
-# include <string>
-# include <stdexcept>
-#ifdef SOL_NO_EXCEPTIONS
-#include <cstdlib>
-#endif // Exceptions
-
-# define TR2_OPTIONAL_REQUIRES(...) typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false
-
-# if defined __GNUC__ // NOTE: GNUC is also defined for Clang
-#   if (__GNUC__ >= 5)
-#     define TR2_OPTIONAL_GCC_5_0_AND_HIGHER___
-#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
-#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-#   endif
-#
-#   if (__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)
-#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_7_AND_HIGHER___
-#   endif
-#
-#   if (__GNUC__ == 4) && (__GNUC_MINOR__ == 8) && (__GNUC_PATCHLEVEL__ >= 1)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   elif (__GNUC__ == 4) && (__GNUC_MINOR__ >= 9)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   elif (__GNUC__ > 4)
-#     define TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   endif
-# endif
-#
-# if defined __clang_major__
-#   if (__clang_major__ == 3 && __clang_minor__ >= 5)
-#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#   elif (__clang_major__ > 3)
-#     define TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#   endif
-#   if defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_
-#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-#   elif (__clang_major__ == 3 && __clang_minor__ == 4 && __clang_patchlevel__ >= 2)
-#     define TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-#   endif
-# endif
-#
-# if defined _MSC_VER
-#   if (_MSC_VER >= 1900)
-#     define TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#   endif
-# endif
-
-# if defined __clang__
-#   if (__clang_major__ > 2) || (__clang_major__ == 2) && (__clang_minor__ >= 9)
-#     define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-#   else
-#     define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-#   endif
-# elif defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 1
-# else
-#   define OPTIONAL_HAS_THIS_RVALUE_REFS 0
-# endif
-
-# if defined TR2_OPTIONAL_GCC_4_8_1_AND_HIGHER___
-#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 1
-#   define OPTIONAL_CONSTEXPR_INIT_LIST constexpr
-# else
-#   define OPTIONAL_HAS_CONSTEXPR_INIT_LIST 0
-#   define OPTIONAL_CONSTEXPR_INIT_LIST
-# endif
-
-# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || (defined TR2_OPTIONAL_CLANG_3_5_AND_HIGHTER_ && (defined __cplusplus) && (__cplusplus != 201103L))
-#   define OPTIONAL_HAS_MOVE_ACCESSORS 1
-# else
-#   define OPTIONAL_HAS_MOVE_ACCESSORS 0
-# endif
-
-# // In C++11 constexpr implies const, so we need to make non-const members also non-constexpr
-# if defined(TR2_OPTIONAL_MSVC_2015_AND_HIGHER___) || ((defined __cplusplus) && (__cplusplus == 201103L))
-#   define OPTIONAL_MUTABLE_CONSTEXPR
-# else
-#   define OPTIONAL_MUTABLE_CONSTEXPR constexpr
-# endif
-
-# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#pragma warning( push )
-#pragma warning( disable : 4814 )
-#endif
-
-namespace sol {
-
-	// BEGIN workaround for missing is_trivially_destructible
-# if defined TR2_OPTIONAL_GCC_4_8_AND_HIGHER___
-	// leave it: it is already there
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-	// leave it: it is already there
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-	// leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
-	// leave it: the user doesn't want it
-# else
-	template <typename T>
-	using is_trivially_destructible = ::std::has_trivial_destructor<T>;
-# endif
-	// END workaround for missing is_trivially_destructible
-
-# if (defined TR2_OPTIONAL_GCC_4_7_AND_HIGHER___)
-	// leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_CLANG_3_4_2_AND_HIGHER_
-	// leave it; our metafunctions are already defined.
-# elif defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-	// leave it: it is already there
-# elif defined TR2_OPTIONAL_DISABLE_EMULATION_OF_TYPE_TRAITS
-	// leave it: the user doesn't want it
-# else
-
-	template <class T>
-	struct is_nothrow_move_constructible
-	{
-		constexpr static bool value = ::std::is_nothrow_constructible<T, T&&>::value;
-	};
-
-	template <class T, class U>
-	struct is_assignable
-	{
-		template <class X, class Y>
-		constexpr static bool has_assign(...) { return false; }
-
-		template <class X, class Y, size_t S = sizeof((::std::declval<X>() = ::std::declval<Y>(), true)) >
-		// the comma operator is necessary for the cases where operator= returns void
-		constexpr static bool has_assign(bool) { return true; }
-
-		constexpr static bool value = has_assign<T, U>(true);
-	};
-
-	template <class T>
-	struct is_nothrow_move_assignable
-	{
-		template <class X, bool has_any_move_assign>
-		struct has_nothrow_move_assign {
-			constexpr static bool value = false;
-		};
-
-		template <class X>
-		struct has_nothrow_move_assign<X, true> {
-			constexpr static bool value = noexcept(::std::declval<X&>() = ::std::declval<X&&>());
-		};
-
-		constexpr static bool value = has_nothrow_move_assign<T, is_assignable<T&, T&&>::value>::value;
-	};
-	// end workaround
-
-# endif
-
-	template <class T> class optional;
-
-	// 20.5.5, optional for lvalue reference types
-	template <class T> class optional<T&>;
-
-	// workaround: std utility functions aren't constexpr yet
-	template <class T> inline constexpr T&& constexpr_forward(typename ::std::remove_reference<T>::type& t) noexcept
-	{
-		return static_cast<T&&>(t);
-	}
-
-	template <class T> inline constexpr T&& constexpr_forward(typename ::std::remove_reference<T>::type&& t) noexcept
-	{
-		static_assert(!::std::is_lvalue_reference<T>::value, "!!");
-		return static_cast<T&&>(t);
-	}
-
-	template <class T> inline constexpr typename ::std::remove_reference<T>::type&& constexpr_move(T&& t) noexcept
-	{
-		return static_cast<typename ::std::remove_reference<T>::type&&>(t);
-	}
-
-#if defined NDEBUG
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
-#else
-# define TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR) ((CHECK) ? (EXPR) : ([]{assert(!#CHECK);}(), (EXPR)))
-#endif
-
-	namespace detail_
-	{
-
-		// static_addressof: a constexpr version of addressof
-		template <typename T>
-		struct has_overloaded_addressof
-		{
-			template <class X>
-			constexpr static bool has_overload(...) { return false; }
-
-			template <class X, size_t S = sizeof(::std::declval<X&>().operator&()) >
-			constexpr static bool has_overload(bool) { return true; }
-
-			constexpr static bool value = has_overload<T>(true);
-		};
-
-		template <typename T, TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof<T>)>
-		constexpr T* static_addressof(T& ref)
-		{
-			return &ref;
-		}
-
-		template <typename T, TR2_OPTIONAL_REQUIRES(has_overloaded_addressof<T>)>
-		T* static_addressof(T& ref)
-		{
-			return ::std::addressof(ref);
-		}
-
-		// the call to convert<A>(b) has return type A and converts b to type A iff b decltype(b) is implicitly convertible to A  
-		template <class U>
-		constexpr U convert(U v) { return v; }
-
-	} // namespace detail_
-
-	constexpr struct trivial_init_t {} trivial_init{};
-
-	// 20.5.7, Disengaged state indicator
-	struct nullopt_t
-	{
-		struct init {};
-		constexpr explicit nullopt_t(init) {}
-	};
-	constexpr nullopt_t nullopt{ nullopt_t::init() };
-
-	// 20.5.8, class bad_optional_access
-	class bad_optional_access : public ::std::logic_error {
-	public:
-		explicit bad_optional_access(const ::std::string& what_arg) : ::std::logic_error{ what_arg } {}
-		explicit bad_optional_access(const char* what_arg) : ::std::logic_error{ what_arg } {}
-	};
-
-	template <class T>
-	struct alignas(T) optional_base {
-		char storage_[sizeof(T)];
-		bool init_;
-
-		constexpr optional_base() noexcept : storage_(), init_(false) {};
-
-		explicit optional_base(const T& v) : storage_(), init_(true) {
-			new (&storage())T(v);
-		}
-
-		explicit optional_base(T&& v) : storage_(), init_(true) {
-			new (&storage())T(constexpr_move(v));
-		}
-
-		template <class... Args> explicit optional_base(in_place_t, Args&&... args)
-			: init_(true), storage_() {
-			new (&storage())T(constexpr_forward<Args>(args)...);
-		}
-
-		template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
-		explicit optional_base(in_place_t, ::std::initializer_list<U> il, Args&&... args)
-			: init_(true), storage_() {
-			new (&storage())T(il, constexpr_forward<Args>(args)...);
-		}
-#if defined __GNUC__ 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-		T& storage() {
-			return *reinterpret_cast<T*>(&storage_[0]);
-		}
-
-		constexpr const T& storage() const {
-			return *reinterpret_cast<T const*>(&storage_[0]);
-		}
-#if defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-		~optional_base() { if (init_) { storage().T::~T(); } }
-	};
-
-#if defined __GNUC__ && !defined TR2_OPTIONAL_GCC_5_0_AND_HIGHER___
-	// Sorry, GCC 4.x; you're just a piece of shit
-	template <typename T>
-	using constexpr_optional_base = optional_base<T>;
-#else
-	template <class T>
-	struct alignas(T) constexpr_optional_base {
-		char storage_[sizeof(T)];
-		bool init_;
-		constexpr constexpr_optional_base() noexcept : storage_(), init_(false) {}
-
-		explicit constexpr constexpr_optional_base(const T& v) : storage_(), init_(true) {
-			new (&storage())T(v);
-		}
-
-		explicit constexpr constexpr_optional_base(T&& v) : storage_(), init_(true) {
-			new (&storage())T(constexpr_move(v));
-		}
-
-		template <class... Args> explicit constexpr constexpr_optional_base(in_place_t, Args&&... args)
-			: init_(true), storage_() {
-			new (&storage())T(constexpr_forward<Args>(args)...);
-		}
-
-		template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
-		OPTIONAL_CONSTEXPR_INIT_LIST explicit constexpr_optional_base(in_place_t, ::std::initializer_list<U> il, Args&&... args)
-			: init_(true), storage_() {
-			new (&storage())T(il, constexpr_forward<Args>(args)...);
-		}
-
-#if defined __GNUC__ 
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wstrict-aliasing"
-#endif
-		T& storage() {
-			return (*reinterpret_cast<T*>(&storage_[0]));
-		}
-
-		constexpr const T& storage() const {
-			return (*reinterpret_cast<T const*>(&storage_[0]));
-		}
-#if defined __GNUC__
-#pragma GCC diagnostic pop
-#endif
-
-		~constexpr_optional_base() = default;
-	};
-#endif
-
-	template <class T>
-	using OptionalBase = typename ::std::conditional<
-		::std::is_trivially_destructible<T>::value,
-		constexpr_optional_base<typename ::std::remove_const<T>::type>,
-		optional_base<typename ::std::remove_const<T>::type>
-	>::type;
-
-	template <class T>
-	class optional : private OptionalBase<T>
-	{
-		static_assert(!::std::is_same<typename ::std::decay<T>::type, nullopt_t>::value, "bad T");
-		static_assert(!::std::is_same<typename ::std::decay<T>::type, in_place_t>::value, "bad T");
-
-		constexpr bool initialized() const noexcept { return OptionalBase<T>::init_; }
-		typename ::std::remove_const<T>::type* dataptr() { return ::std::addressof(OptionalBase<T>::storage()); }
-		constexpr const T* dataptr() const { return detail_::static_addressof(OptionalBase<T>::storage()); }
-
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-		constexpr const T& contained_val() const& { return OptionalBase<T>::storage(); }
-#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-		OPTIONAL_MUTABLE_CONSTEXPR T&& contained_val() && { return ::std::move(OptionalBase<T>::storage()); }
-		OPTIONAL_MUTABLE_CONSTEXPR T& contained_val() & { return OptionalBase<T>::storage(); }
-#   else
-		T& contained_val() & { return OptionalBase<T>::storage(); }
-		T&& contained_val() && { return ::std::move(OptionalBase<T>::storage()); }
-#   endif
-# else
-		constexpr const T& contained_val() const { return OptionalBase<T>::storage(); }
-		T& contained_val() { return OptionalBase<T>::storage(); }
-# endif
-
-		void clear() noexcept {
-			if (initialized()) dataptr()->T::~T();
-			OptionalBase<T>::init_ = false;
-		}
-
-		template <class... Args>
-		void initialize(Args&&... args) noexcept(noexcept(T(::std::forward<Args>(args)...)))
-		{
-			assert(!OptionalBase<T>::init_);
-			::new (static_cast<void*>(dataptr())) T(::std::forward<Args>(args)...);
-			OptionalBase<T>::init_ = true;
-		}
-
-		template <class U, class... Args>
-		void initialize(::std::initializer_list<U> il, Args&&... args) noexcept(noexcept(T(il, ::std::forward<Args>(args)...)))
-		{
-			assert(!OptionalBase<T>::init_);
-			::new (static_cast<void*>(dataptr())) T(il, ::std::forward<Args>(args)...);
-			OptionalBase<T>::init_ = true;
-		}
-
-	public:
-		typedef T value_type;
-
-		// 20.5.5.1, constructors
-		constexpr optional() noexcept : OptionalBase<T>() {};
-		constexpr optional(nullopt_t) noexcept : OptionalBase<T>() {};
-
-		optional(const optional& rhs)
-			: OptionalBase<T>()
-		{
-			if (rhs.initialized()) {
-				::new (static_cast<void*>(dataptr())) T(*rhs);
-				OptionalBase<T>::init_ = true;
-			}
-		}
-
-		optional(const optional<T&>& rhs) : optional()
-		{
-			if (rhs) {
-				::new (static_cast<void*>(dataptr())) T(*rhs);
-				OptionalBase<T>::init_ = true;
-			}
-		}
-
-		optional(optional&& rhs) noexcept(::std::is_nothrow_move_constructible<T>::value)
-			: OptionalBase<T>()
-		{
-			if (rhs.initialized()) {
-				::new (static_cast<void*>(dataptr())) T(::std::move(*rhs));
-				OptionalBase<T>::init_ = true;
-			}
-		}
-
-		constexpr optional(const T& v) : OptionalBase<T>(v) {}
-
-		constexpr optional(T&& v) : OptionalBase<T>(constexpr_move(v)) {}
-
-		template <class... Args>
-		explicit constexpr optional(in_place_t, Args&&... args)
-			: OptionalBase<T>(in_place, constexpr_forward<Args>(args)...) {}
-
-		template <class U, class... Args, TR2_OPTIONAL_REQUIRES(::std::is_constructible<T, ::std::initializer_list<U>>)>
-		OPTIONAL_CONSTEXPR_INIT_LIST explicit optional(in_place_t, ::std::initializer_list<U> il, Args&&... args)
-			: OptionalBase<T>(in_place, il, constexpr_forward<Args>(args)...) {}
-
-		// 20.5.4.2, Destructor
-		~optional() = default;
-
-		// 20.5.4.3, assignment
-		optional& operator=(nullopt_t) noexcept
-		{
-			clear();
-			return *this;
-		}
-
-		optional& operator=(const optional& rhs)
-		{
-			if (initialized() == true && rhs.initialized() == false) clear();
-			else if (initialized() == false && rhs.initialized() == true)  initialize(*rhs);
-			else if (initialized() == true && rhs.initialized() == true)  contained_val() = *rhs;
-			return *this;
-		}
-
-		optional& operator=(optional&& rhs)
-			noexcept(::std::is_nothrow_move_assignable<T>::value && ::std::is_nothrow_move_constructible<T>::value)
-		{
-			if (initialized() == true && rhs.initialized() == false) clear();
-			else if (initialized() == false && rhs.initialized() == true)  initialize(::std::move(*rhs));
-			else if (initialized() == true && rhs.initialized() == true)  contained_val() = ::std::move(*rhs);
-			return *this;
-		}
-
-		template <class U>
-		auto operator=(U&& v)
-			-> typename ::std::enable_if
-			<
-			::std::is_same<typename ::std::decay<U>::type, T>::value,
-			optional&
-			>::type
-		{
-			if (initialized()) { contained_val() = ::std::forward<U>(v); }
-			else { initialize(::std::forward<U>(v)); }
-			return *this;
-		}
-
-		template <class... Args>
-		void emplace(Args&&... args)
-		{
-			clear();
-			initialize(::std::forward<Args>(args)...);
-		}
-
-		template <class U, class... Args>
-		void emplace(::std::initializer_list<U> il, Args&&... args)
-		{
-			clear();
-			initialize<U, Args...>(il, ::std::forward<Args>(args)...);
-		}
-
-		// 20.5.4.4, Swap
-		void swap(optional<T>& rhs) noexcept(::std::is_nothrow_move_constructible<T>::value && noexcept(swap(::std::declval<T&>(), ::std::declval<T&>())))
-		{
-			if (initialized() == true && rhs.initialized() == false) { rhs.initialize(::std::move(**this)); clear(); }
-			else if (initialized() == false && rhs.initialized() == true) { initialize(::std::move(*rhs)); rhs.clear(); }
-			else if (initialized() == true && rhs.initialized() == true) { using ::std::swap; swap(**this, *rhs); }
-		}
-
-		// 20.5.4.5, Observers
-
-		explicit constexpr operator bool() const noexcept { return initialized(); }
-
-		constexpr T const* operator ->() const {
-			return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), dataptr());
-		}
-
-# if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
-		OPTIONAL_MUTABLE_CONSTEXPR T* operator ->() {
-			assert(initialized());
-			return dataptr();
-		}
-
-		constexpr T const& operator *() const& {
-			return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
-		}
-
-		OPTIONAL_MUTABLE_CONSTEXPR T& operator *() & {
-			assert(initialized());
-			return contained_val();
-		}
-
-		OPTIONAL_MUTABLE_CONSTEXPR T&& operator *() && {
-			assert(initialized());
-			return constexpr_move(contained_val());
-		}
-
-		constexpr T const& value() const& {
-			return initialized() ?
-				contained_val()
-#ifdef SOL_NO_EXCEPTIONS
-				// we can't abort here
-				// because there's no constexpr abort
-				: *(T*)nullptr;
-#else
-				: (throw bad_optional_access("bad optional access"), contained_val());
-#endif
-		}
-
-		OPTIONAL_MUTABLE_CONSTEXPR T& value() & {
-			return initialized() ?
-				contained_val()
-#ifdef SOL_NO_EXCEPTIONS
-				: *(T*)nullptr;
-#else
-				: (throw bad_optional_access("bad optional access"), contained_val());
-#endif
-		}
-
-		OPTIONAL_MUTABLE_CONSTEXPR T&& value() && {
-			return initialized() ?
-				contained_val()
-#ifdef SOL_NO_EXCEPTIONS
-				// we can't abort here
-				// because there's no constexpr abort
-				: std::move(*(T*)nullptr);
-#else
-				: (throw bad_optional_access("bad optional access"), contained_val());
-#endif
-		}
-
-# else
-
-		T* operator ->() {
-			assert(initialized());
-			return dataptr();
-		}
-
-		constexpr T const& operator *() const {
-			return TR2_OPTIONAL_ASSERTED_EXPRESSION(initialized(), contained_val());
-		}
-
-		T& operator *() {
-			assert(initialized());
-			return contained_val();
-		}
-
-		constexpr T const& value() const {
-			return initialized() ? 
-				contained_val() 
-#ifdef SOL_NO_EXCEPTIONS
-				// we can't abort here
-				// because there's no constexpr abort
-				: *(T*)nullptr;
-#else
-				: (throw bad_optional_access("bad optional access"), contained_val());
-#endif
-		}
-
-		T& value() {
-			return initialized() ?
-				contained_val()
-#ifdef SOL_NO_EXCEPTIONS
-				// we can abort here
-				// but the others are constexpr, so we can't...
-				: (std::abort(), *(T*)nullptr);
-#else
-				: (throw bad_optional_access("bad optional access"), contained_val());
-#endif
-		}
-
-# endif
-
-# if OPTIONAL_HAS_THIS_RVALUE_REFS == 1
-
-		template <class V>
-		constexpr T value_or(V&& v) const&
-		{
-			return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
-		}
-
-#   if OPTIONAL_HAS_MOVE_ACCESSORS == 1
-
-		template <class V>
-		OPTIONAL_MUTABLE_CONSTEXPR T value_or(V&& v) &&
-		{
-			return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
-		}
-
-#   else
-
-		template <class V>
-		T value_or(V&& v) &&
-		{
-			return *this ? constexpr_move(const_cast<optional<T>&>(*this).contained_val()) : detail_::convert<T>(constexpr_forward<V>(v));
-		}
-
-#   endif
-
-# else
-
-		template <class V>
-		constexpr T value_or(V&& v) const
-		{
-			return *this ? **this : detail_::convert<T>(constexpr_forward<V>(v));
-		}
-
-# endif
-
-	};
-
-	template <class T>
-	class optional<T&>
-	{
-		static_assert(!::std::is_same<T, nullopt_t>::value, "bad T");
-		static_assert(!::std::is_same<T, in_place_t>::value, "bad T");
-		T* ref;
-
-	public:
-
-		// 20.5.5.1, construction/destruction
-		constexpr optional() noexcept : ref(nullptr) {}
-
-		constexpr optional(nullopt_t) noexcept : ref(nullptr) {}
-
-		constexpr optional(T& v) noexcept : ref(detail_::static_addressof(v)) {}
-
-		optional(T&&) = delete;
-
-		constexpr optional(const optional& rhs) noexcept : ref(rhs.ref) {}
-
-		explicit constexpr optional(in_place_t, T& v) noexcept : ref(detail_::static_addressof(v)) {}
-
-		explicit optional(in_place_t, T&&) = delete;
-
-		~optional() = default;
-
-		// 20.5.5.2, mutation
-		optional& operator=(nullopt_t) noexcept {
-			ref = nullptr;
-			return *this;
-		}
-
-		// optional& operator=(const optional& rhs) noexcept {
-		  // ref = rhs.ref;
-		  // return *this;
-		// }
-
-		// optional& operator=(optional&& rhs) noexcept {
-		  // ref = rhs.ref;
-		  // return *this;
-		// }
-
-		template <typename U>
-		auto operator=(U&& rhs) noexcept
-			-> typename ::std::enable_if
-			<
-			::std::is_same<typename ::std::decay<U>::type, optional<T&>>::value,
-			optional&
-			>::type
-		{
-			ref = rhs.ref;
-			return *this;
-		}
-
-		template <typename U>
-		auto operator=(U&& rhs) noexcept
-			-> typename ::std::enable_if
-			<
-			!::std::is_same<typename ::std::decay<U>::type, optional<T&>>::value,
-			optional&
-			>::type
-			= delete;
-
-		void emplace(T& v) noexcept {
-			ref = detail_::static_addressof(v);
-		}
-
-		void emplace(T&&) = delete;
-
-		void swap(optional<T&>& rhs) noexcept
-		{
-			::std::swap(ref, rhs.ref);
-		}
-
-		// 20.5.5.3, observers
-		constexpr T* operator->() const {
-			return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, ref);
-		}
-
-		constexpr T& operator*() const {
-			return TR2_OPTIONAL_ASSERTED_EXPRESSION(ref, *ref);
-		}
-
-		constexpr T& value() const {
-#ifdef SOL_NO_EXCEPTIONS
-			return *ref;
-#else
-			return ref ? *ref
-			: (throw bad_optional_access("bad optional access"), *ref);
-#endif // Exceptions
-		}
-
-		explicit constexpr operator bool() const noexcept {
-			return ref != nullptr;
-		}
-
-		template <typename V>
-		constexpr T& value_or(V&& v) const
-		{
-			return *this ? **this : detail_::convert<T&>(constexpr_forward<V>(v));
-		}
-	};
-
-	template <class T>
-	class optional<T&&>
-	{
-		static_assert(sizeof(T) == 0, "optional rvalue references disallowed");
-	};
-
-	// 20.5.8, Relational operators
-	template <class T> constexpr bool operator==(const optional<T>& x, const optional<T>& y)
-	{
-		return bool(x) != bool(y) ? false : bool(x) == false ? true : *x == *y;
-	}
-
-	template <class T> constexpr bool operator!=(const optional<T>& x, const optional<T>& y)
-	{
-		return !(x == y);
-	}
-
-	template <class T> constexpr bool operator<(const optional<T>& x, const optional<T>& y)
-	{
-		return (!y) ? false : (!x) ? true : *x < *y;
-	}
-
-	template <class T> constexpr bool operator>(const optional<T>& x, const optional<T>& y)
-	{
-		return (y < x);
-	}
-
-	template <class T> constexpr bool operator<=(const optional<T>& x, const optional<T>& y)
-	{
-		return !(y < x);
-	}
-
-	template <class T> constexpr bool operator>=(const optional<T>& x, const optional<T>& y)
-	{
-		return !(x < y);
-	}
-
-	// 20.5.9, Comparison with nullopt
-	template <class T> constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept
-	{
-		return (!x);
-	}
-
-	template <class T> constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept
-	{
-		return (!x);
-	}
-
-	template <class T> constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept
-	{
-		return bool(x);
-	}
-
-	template <class T> constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept
-	{
-		return bool(x);
-	}
-
-	template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept
-	{
-		return false;
-	}
-
-	template <class T> constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept
-	{
-		return bool(x);
-	}
-
-	template <class T> constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept
-	{
-		return (!x);
-	}
-
-	template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept
-	{
-		return true;
-	}
-
-	template <class T> constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept
-	{
-		return bool(x);
-	}
-
-	template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept
-	{
-		return false;
-	}
-
-	template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept
-	{
-		return true;
-	}
-
-	template <class T> constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept
-	{
-		return (!x);
-	}
-
-	// 20.5.10, Comparison with T
-	template <class T> constexpr bool operator==(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x == v : false;
-	}
-
-	template <class T> constexpr bool operator==(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v == *x : false;
-	}
-
-	template <class T> constexpr bool operator!=(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x != v : true;
-	}
-
-	template <class T> constexpr bool operator!=(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v != *x : true;
-	}
-
-	template <class T> constexpr bool operator<(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x < v : true;
-	}
-
-	template <class T> constexpr bool operator>(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v > *x : true;
-	}
-
-	template <class T> constexpr bool operator>(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x > v : false;
-	}
-
-	template <class T> constexpr bool operator<(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v < *x : false;
-	}
-
-	template <class T> constexpr bool operator>=(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x >= v : false;
-	}
-
-	template <class T> constexpr bool operator<=(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v <= *x : false;
-	}
-
-	template <class T> constexpr bool operator<=(const optional<T>& x, const T& v)
-	{
-		return bool(x) ? *x <= v : true;
-	}
-
-	template <class T> constexpr bool operator>=(const T& v, const optional<T>& x)
-	{
-		return bool(x) ? v >= *x : true;
-	}
-
-	// Comparison of optional<T&> with T
-	template <class T> constexpr bool operator==(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x == v : false;
-	}
-
-	template <class T> constexpr bool operator==(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v == *x : false;
-	}
-
-	template <class T> constexpr bool operator!=(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x != v : true;
-	}
-
-	template <class T> constexpr bool operator!=(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v != *x : true;
-	}
-
-	template <class T> constexpr bool operator<(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x < v : true;
-	}
-
-	template <class T> constexpr bool operator>(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v > *x : true;
-	}
-
-	template <class T> constexpr bool operator>(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x > v : false;
-	}
-
-	template <class T> constexpr bool operator<(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v < *x : false;
-	}
-
-	template <class T> constexpr bool operator>=(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x >= v : false;
-	}
-
-	template <class T> constexpr bool operator<=(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v <= *x : false;
-	}
-
-	template <class T> constexpr bool operator<=(const optional<T&>& x, const T& v)
-	{
-		return bool(x) ? *x <= v : true;
-	}
-
-	template <class T> constexpr bool operator>=(const T& v, const optional<T&>& x)
-	{
-		return bool(x) ? v >= *x : true;
-	}
-
-	// Comparison of optional<T const&> with T
-	template <class T> constexpr bool operator==(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x == v : false;
-	}
-
-	template <class T> constexpr bool operator==(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v == *x : false;
-	}
-
-	template <class T> constexpr bool operator!=(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x != v : true;
-	}
-
-	template <class T> constexpr bool operator!=(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v != *x : true;
-	}
-
-	template <class T> constexpr bool operator<(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x < v : true;
-	}
-
-	template <class T> constexpr bool operator>(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v > *x : true;
-	}
-
-	template <class T> constexpr bool operator>(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x > v : false;
-	}
-
-	template <class T> constexpr bool operator<(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v < *x : false;
-	}
-
-	template <class T> constexpr bool operator>=(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x >= v : false;
-	}
-
-	template <class T> constexpr bool operator<=(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v <= *x : false;
-	}
-
-	template <class T> constexpr bool operator<=(const optional<const T&>& x, const T& v)
-	{
-		return bool(x) ? *x <= v : true;
-	}
-
-	template <class T> constexpr bool operator>=(const T& v, const optional<const T&>& x)
-	{
-		return bool(x) ? v >= *x : true;
-	}
-
-	// 20.5.12, Specialized algorithms
-	template <class T>
-	void swap(optional<T>& x, optional<T>& y) noexcept(noexcept(x.swap(y))) {
-		x.swap(y);
-	}
-
-	template <class T>
-	constexpr optional<typename ::std::decay<T>::type> make_optional(T&& v) {
-		return optional<typename ::std::decay<T>::type>(constexpr_forward<T>(v));
-	}
-
-	template <class X>
-	constexpr optional<X&> make_optional(::std::reference_wrapper<X> v) {
-		return optional<X&>(v.get());
-	}
-
-} // namespace 
-
-namespace std
-{
-	template <typename T>
-	struct hash<sol::optional<T>> {
-		typedef typename hash<T>::result_type result_type;
-		typedef sol::optional<T> argument_type;
-
-		constexpr result_type operator()(argument_type const& arg) const {
-			return arg ? ::std::hash<T>{}(*arg) : result_type{};
-		}
-	};
-
-	template <typename T>
-	struct hash<sol::optional<T&>> {
-		typedef typename hash<T>::result_type result_type;
-		typedef sol::optional<T&> argument_type;
-
-		constexpr result_type operator()(argument_type const& arg) const {
-			return arg ? ::std::hash<T>{}(*arg) : result_type{};
-		}
-	};
-}
-
-# if defined TR2_OPTIONAL_MSVC_2015_AND_HIGHER___
-#pragma warning( pop )
-#endif
-
-# undef TR2_OPTIONAL_REQUIRES
-# undef TR2_OPTIONAL_ASSERTED_EXPRESSION
-
-# endif // SOL_OPTIONAL_IMPLEMENTATION_HPP
-// end of sol/optional_implementation.hpp
-
-#endif // Boost vs. Better optional
-
-namespace sol {
-
-#if defined(SOL_USE_BOOST)
-	template <typename T>
-	using optional = boost::optional<T>;
-	using nullopt_t = boost::none_t;
-	const nullopt_t nullopt = boost::none;
-#endif // Boost vs. Better optional
-
-	namespace meta {
-		template <typename T>
-		struct is_optional : std::false_type {};
-		template <typename T>
-		struct is_optional<optional<T>> : std::true_type {};
-	} // meta
-} // sol
-
-// end of sol/optional.hpp
-
-// beginning of sol/string_shim.hpp
-
-namespace sol {
-	namespace string_detail {
-		struct string_shim {
-			std::size_t s;
-			const char* p;
-
-			string_shim(const std::string& r) : string_shim(r.data(), r.size()) {}
-			string_shim(const char* ptr) : string_shim(ptr, std::char_traits<char>::length(ptr)) {}
-			string_shim(const char* ptr, std::size_t sz) : s(sz), p(ptr) {}
-
-			static int compare(const char* lhs_p, std::size_t lhs_sz, const char* rhs_p, std::size_t rhs_sz) {
-				int result = std::char_traits<char>::compare(lhs_p, rhs_p, lhs_sz < rhs_sz ? lhs_sz : rhs_sz);
-				if (result != 0)
-					return result;
-				if (lhs_sz < rhs_sz)
-					return -1;
-				if (lhs_sz > rhs_sz)
-					return 1;
-				return 0;
-			}
-
-			const char* c_str() const {
-				return p;
-			}
-
-			const char* data() const {
-				return p;
-			}
-
-			std::size_t size() const {
-				return s;
-			}
-
-			bool operator==(const string_shim& r) const {
-				return compare(p, s, r.data(), r.size()) == 0;
-			}
-
-			bool operator==(const char* r) const {
-				return compare(r, std::char_traits<char>::length(r), p, s) == 0;
-			}
-
-			bool operator==(const std::string& r) const {
-				return compare(r.data(), r.size(), p, s) == 0;
-			}
-
-			bool operator!=(const string_shim& r) const {
-				return !(*this == r);
-			}
-
-			bool operator!=(const char* r) const {
-				return !(*this == r);
-			}
-
-			bool operator!=(const std::string& r) const {
-				return !(*this == r);
-			}
-		};
-	}
-}
-
-// end of sol/string_shim.hpp
-
-#include <array>
-
-namespace sol {
-	namespace detail {
-#ifdef SOL_NO_EXCEPTIONS
-		template <lua_CFunction f>
-		int static_trampoline(lua_State* L) {
-			return f(L);
-		}
-
-		template <typename Fx, typename... Args>
-		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
-			return f(L, std::forward<Args>(args)...);
-		}
-
-		inline int c_trampoline(lua_State* L, lua_CFunction f) {
-			return trampoline(L, f);
-		}
-#else
-		template <lua_CFunction f>
-		int static_trampoline(lua_State* L) {
-			try {
-				return f(L);
-			}
-			catch (const char *s) {
-				lua_pushstring(L, s);
-			}
-			catch (const std::exception& e) {
-				lua_pushstring(L, e.what());
-			}
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
-			catch (...) {
-				std::exception_ptr eptr = std::current_exception();
-				lua_pushstring(L, "caught (...) exception");
-			}
-#endif
-			return lua_error(L);
-		}
-
-		template <typename Fx, typename... Args>
-		int trampoline(lua_State* L, Fx&& f, Args&&... args) {
-			try {
-				return f(L, std::forward<Args>(args)...);
-			}
-			catch (const char *s) {
-				lua_pushstring(L, s);
-			}
-			catch (const std::exception& e) {
-				lua_pushstring(L, e.what());
-			}
-#if !defined(SOL_EXCEPTIONS_SAFE_PROPAGATION)
-			catch (...) {
-				lua_pushstring(L, "caught (...) exception");
-			}
-#endif
-			return lua_error(L);
-		}
-
-		inline int c_trampoline(lua_State* L, lua_CFunction f) {
-			return trampoline(L, f);
-		}
-#endif // Exceptions vs. No Exceptions
-
-		template <typename T>
-		struct unique_usertype {};
-
-		template <typename T>
-		struct implicit_wrapper {
-			T& item;
-			implicit_wrapper(T* item) : item(*item) {}
-			implicit_wrapper(T& item) : item(item) {}
-			operator T& () {
-				return item;
-			}
-			operator T* () {
-				return std::addressof(item);
-			}
-		};
-
-		struct unchecked_t {};
-		const unchecked_t unchecked = unchecked_t{};
-	} // detail
-
-	struct lua_nil_t {};
-	const lua_nil_t lua_nil{};
-	inline bool operator==(lua_nil_t, lua_nil_t) { return true; }
-	inline bool operator!=(lua_nil_t, lua_nil_t) { return false; }
-#ifndef __OBJC__
-	typedef lua_nil_t nil_t;
-	const nil_t nil{};
-#endif
-
-	struct metatable_t {};
-	const metatable_t metatable_key = {};
-
-	struct env_t {};
-	const env_t env_key = {};
-
-	struct no_metatable_t {};
-	const no_metatable_t no_metatable = {};
-
-	typedef std::remove_pointer_t<lua_CFunction> lua_r_CFunction;
-
-	template <typename T>
-	struct unique_usertype_traits {
-		typedef T type;
-		typedef T actual_type;
-		static const bool value = false;
-
-		template <typename U>
-		static bool is_null(U&&) {
-			return false;
-		}
-
-		template <typename U>
-		static auto get(U&& value) {
-			return std::addressof(detail::deref(value));
-		}
-	};
-
-	template <typename T>
-	struct unique_usertype_traits<std::shared_ptr<T>> {
-		typedef T type;
-		typedef std::shared_ptr<T> actual_type;
-		static const bool value = true;
-
-		static bool is_null(const actual_type& p) {
-			return p == nullptr;
-		}
-
-		static type* get(const actual_type& p) {
-			return p.get();
-		}
-	};
-
-	template <typename T, typename D>
-	struct unique_usertype_traits<std::unique_ptr<T, D>> {
-		typedef T type;
-		typedef std::unique_ptr<T, D> actual_type;
-		static const bool value = true;
-
-		static bool is_null(const actual_type& p) {
-			return p == nullptr;
-		}
-
-		static type* get(const actual_type& p) {
-			return p.get();
-		}
-	};
-
-	template <typename T>
-	struct non_null {};
-
-	template <typename... Args>
-	struct function_sig {};
-
-	struct upvalue_index {
-		int index;
-		upvalue_index(int idx) : index(lua_upvalueindex(idx)) {
-		
-		}
-		
-		operator int() const { 
-			return index; 
-		}
-	};
-
-	struct raw_index {
-		int index;
-		raw_index(int i) : index(i) {
-		
-		}
-		
-		operator int() const { 
-			return index; 
-		}
-	};
-
-	struct absolute_index {
-		int index;
-		absolute_index(lua_State* L, int idx) : index(lua_absindex(L, idx)) {
-		
-		}
-		
-		operator int() const { 
-			return index; 
-		}
-	};
-
-	struct ref_index {
-		int index;
-		ref_index(int idx) : index(idx) {
-		
-		}
-		
-		operator int() const { 
-			return index; 
-		}
-	};
-
-	struct lightuserdata_value {
-		void* value;
-		lightuserdata_value(void* data) : value(data) {}
-		operator void*() const { return value; }
-	};
-
-	struct userdata_value {
-		void* value;
-		userdata_value(void* data) : value(data) {}
-		operator void*() const { return value; }
-	};
-
-	template <typename L>
-	struct light {
-		L* value;
-
-		light(L& x) : value(std::addressof(x)) {}
-		light(L* x) : value(x) {}
-		light(void* x) : value(static_cast<L*>(x)) {}
-		operator L* () const { return value; }
-		operator L& () const { return *value; }
-	};
-
-	template <typename T>
-	auto make_light(T& l) {
-		typedef meta::unwrapped_t<std::remove_pointer_t<std::remove_pointer_t<T>>> L;
-		return light<L>(l);
-	}
-
-	template <typename U>
-	struct user {
-		U value;
-
-		user(U x) : value(std::move(x)) {}
-		operator U* () { return std::addressof(value); }
-		operator U& () { return value; }
-		operator const U& () const { return value; }
-	};
-
-	template <typename T>
-	auto make_user(T&& u) {
-		typedef meta::unwrapped_t<meta::unqualified_t<T>> U;
-		return user<U>(std::forward<T>(u));
-	}
-
-	template <typename T>
-	struct metatable_registry_key {
-		T key;
-
-		metatable_registry_key(T key) : key(std::forward<T>(key)) {}
-	};
-
-	template <typename T>
-	auto meta_registry_key(T&& key) {
-		typedef meta::unqualified_t<T> K;
-		return metatable_registry_key<K>(std::forward<T>(key));
-	}
-
-	template <typename... Upvalues>
-	struct closure {
-		lua_CFunction c_function;
-		std::tuple<Upvalues...> upvalues;
-		closure(lua_CFunction f, Upvalues... targetupvalues) : c_function(f), upvalues(std::forward<Upvalues>(targetupvalues)...) {}
-	};
-
-	template <>
-	struct closure<> {
-		lua_CFunction c_function;
-		int upvalues;
-		closure(lua_CFunction f, int upvalue_count = 0) : c_function(f), upvalues(upvalue_count) {}
-	};
-
-	typedef closure<> c_closure;
-
-	template <typename... Args>
-	closure<Args...> make_closure(lua_CFunction f, Args&&... args) {
-		return closure<Args...>(f, std::forward<Args>(args)...);
-	}
-
-	template <typename Sig, typename... Ps>
-	struct function_arguments {
-		std::tuple<Ps...> arguments;
-		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, function_arguments>> = meta::enabler>
-		function_arguments(Arg&& arg, Args&&... args) : arguments(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-	};
-
-	template <typename Sig = function_sig<>, typename... Args>
-	auto as_function(Args&&... args) {
-		return function_arguments<Sig, std::decay_t<Args>...>(std::forward<Args>(args)...);
-	}
-
-	template <typename Sig = function_sig<>, typename... Args>
-	auto as_function_reference(Args&&... args) {
-		return function_arguments<Sig, Args...>(std::forward<Args>(args)...);
-	}
-
-	template <typename T>
-	struct as_table_t {
-		T source;
-		template <typename... Args>
-		as_table_t(Args&&... args) : source(std::forward<Args>(args)...) {}
-
-		operator std::add_lvalue_reference_t<T> () {
-			return source;
-		}
-	};
-
-	template <typename T>
-	struct nested {
-		T source;
-		
-		template <typename... Args>
-		nested(Args&&... args) : source(std::forward<Args>(args)...) {}
-
-		operator std::add_lvalue_reference_t<T>() {
-			return source;
-		}
-	};
-
-	template <typename T>
-	as_table_t<T> as_table(T&& container) {
-		return as_table_t<T>(std::forward<T>(container));
-	}
-
-	struct this_state {
-		lua_State* L;
-		operator lua_State* () const {
-			return L;
-		}
-		lua_State* operator-> () const {
-			return L;
-		}
-	};
-
-	struct new_table {
-		int sequence_hint = 0;
-		int map_hint = 0;
-
-		new_table() = default;
-		new_table(const new_table&) = default;
-		new_table(new_table&&) = default;
-		new_table& operator=(const new_table&) = default;
-		new_table& operator=(new_table&&) = default;
-
-		new_table(int sequence_hint, int map_hint = 0) : sequence_hint(sequence_hint), map_hint(map_hint) {}
-	};
-
-	enum class call_syntax {
-		dot = 0,
-		colon = 1
-	};
-
-	enum class call_status : int {
-		ok = LUA_OK,
-		yielded = LUA_YIELD,
-		runtime = LUA_ERRRUN,
-		memory = LUA_ERRMEM,
-		handler = LUA_ERRERR,
-#if SOL_LUA_VERSION < 504
-		gc = LUA_ERRGCMM,
-#endif
-		syntax = LUA_ERRSYNTAX,
-		file = LUA_ERRFILE,
-	};
-
-	enum class thread_status : int {
-		ok = LUA_OK,
-		yielded = LUA_YIELD,
-		runtime = LUA_ERRRUN,
-		memory = LUA_ERRMEM,
-#if SOL_LUA_VERSION < 504
-		gc = LUA_ERRGCMM,
-#endif
-		handler = LUA_ERRERR,
-		dead = -1,
-	};
-
-	enum class load_status : int {
-		ok = LUA_OK,
-		syntax = LUA_ERRSYNTAX,
-		memory = LUA_ERRMEM,
-#if SOL_LUA_VERSION < 504
-		gc = LUA_ERRGCMM,
-#endif
-		file = LUA_ERRFILE,
-	};
-
-	enum class type : int {
-		none = LUA_TNONE,
-		lua_nil = LUA_TNIL,
-#ifndef __OBJC__
-		nil = lua_nil,
-#endif // Objective C++ Keyword
-		string = LUA_TSTRING,
-		number = LUA_TNUMBER,
-		thread = LUA_TTHREAD,
-		boolean = LUA_TBOOLEAN,
-		function = LUA_TFUNCTION,
-		userdata = LUA_TUSERDATA,
-		lightuserdata = LUA_TLIGHTUSERDATA,
-		table = LUA_TTABLE,
-		poly = none | lua_nil | string | number | thread |
-		table | boolean | function | userdata | lightuserdata
-	};
-
-	inline const std::string& to_string(call_status c) {
-		static const std::array<std::string, 8> names{{
-			"ok",
-			"yielded",
-			"runtime",
-			"memory",
-			"handler",
-			"gc",
-			"syntax",
-			"file",
-		}};
-		switch (c) {
-		case call_status::ok:
-			return names[0];
-		case call_status::yielded:
-			return names[1];
-		case call_status::runtime:
-			return names[2];
-		case call_status::memory:
-			return names[3];
-		case call_status::handler:
-			return names[4];
-#if SOL_LUA_VERSION < 504
-		case call_status::gc:
-			return names[5];
-#endif
-		case call_status::syntax:
-			return names[6];
-		case call_status::file:
-			return names[7];
-		}
-		return names[0];
-	}
-
-	inline const std::string& to_string(load_status c) {
-		static const std::array<std::string, 8> names{ {
-				"ok",
-				"memory",
-				"gc",
-				"syntax",
-				"file",
-			} };
-		switch (c) {
-		case load_status::ok:
-			return names[0];
-		case load_status::memory:
-			return names[1];
-#if SOL_LUA_VERSION < 504
-		case load_status::gc:
-			return names[2];
-#endif
-		case load_status::syntax:
-			return names[3];
-		case load_status::file:
-			return names[4];
-		}
-		return names[0];
-	}
-
-	enum class meta_function {
-		construct,
-		index,
-		new_index,
-		mode,
-		call,
-		call_function = call,
-		metatable,
-		to_string,
-		length,
-		unary_minus,
-		addition,
-		subtraction,
-		multiplication,
-		division,
-		modulus,
-		power_of,
-		involution = power_of,
-		concatenation,
-		equal_to,
-		less_than,
-		less_than_or_equal_to,
-		garbage_collect,
-		floor_division,
-		bitwise_left_shift,
-		bitwise_right_shift,
-		bitwise_not,
-		bitwise_and,
-		bitwise_or,
-		bitwise_xor,
-		pairs,
-		next
-	};
-
-	typedef meta_function meta_method;
-
-	inline const std::array<std::string, 29>& meta_function_names() {
-		static const std::array<std::string, 29> names = { {
-				"new",
-				"__index",
-				"__newindex",
-				"__mode",
-				"__call",
-				"__mt",
-				"__tostring",
-				"__len",
-				"__unm",
-				"__add",
-				"__sub",
-				"__mul",
-				"__div",
-				"__mod",
-				"__pow",
-				"__concat",
-				"__eq",
-				"__lt",
-				"__le",
-				"__gc",
-
-				"__idiv",
-				"__shl",
-				"__shr",
-				"__bnot",
-				"__band",
-				"__bor",
-				"__bxor",
-
-				"__pairs",
-				"__next"
-			} };
-		return names;
-	}
-
-	inline const std::string& to_string(meta_function mf) {
-		return meta_function_names()[static_cast<int>(mf)];
-	}
-
-	inline type type_of(lua_State* L, int index) {
-		return static_cast<type>(lua_type(L, index));
-	}
-
-	inline int type_panic(lua_State* L, int index, type expected, type actual) noexcept(false) {
-		return luaL_error(L, "stack index %d, expected %s, received %s", index,
-			expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(expected)),
-			expected == type::poly ? "anything" : lua_typename(L, static_cast<int>(actual))
-		);
-	}
-
-	// Specify this function as the handler for lua::check if you know there's nothing wrong
-	inline int no_panic(lua_State*, int, type, type) noexcept {
-		return 0;
-	}
-
-	inline void type_error(lua_State* L, int expected, int actual) noexcept(false) {
-		luaL_error(L, "expected %s, received %s", lua_typename(L, expected), lua_typename(L, actual));
-	}
-
-	inline void type_error(lua_State* L, type expected, type actual) noexcept(false) {
-		type_error(L, static_cast<int>(expected), static_cast<int>(actual));
-	}
-
-	inline void type_assert(lua_State* L, int index, type expected, type actual) noexcept(false) {
-		if (expected != type::poly && expected != actual) {
-			type_panic(L, index, expected, actual);
-		}
-	}
-
-	inline void type_assert(lua_State* L, int index, type expected) {
-		type actual = type_of(L, index);
-		type_assert(L, index, expected, actual);
-	}
-
-	inline std::string type_name(lua_State* L, type t) {
-		return lua_typename(L, static_cast<int>(t));
-	}
-
-	class reference;
-	class stack_reference;
-	template <typename Table, typename Key>
-	struct proxy;
-	template<typename T>
-	class usertype;
-	template <bool, typename T>
-	class basic_table_core;
-	template <bool b>
-	using table_core = basic_table_core<b, reference>;
-	template <bool b>
-	using stack_table_core = basic_table_core<b, stack_reference>;
-	template <typename T>
-	using basic_table = basic_table_core<false, T>;
-	typedef table_core<false> table;
-	typedef table_core<true> global_table;
-	typedef stack_table_core<false> stack_table;
-	typedef stack_table_core<true> stack_global_table;
-	template <typename base_t>
-	struct basic_environment;
-	using environment = basic_environment<reference>;
-	using stack_environment = basic_environment<stack_reference>;
-	template <typename T>
-	class basic_function;
-	template <typename T>
-	class basic_protected_function;
-	using protected_function = basic_protected_function<reference>;
-	using stack_protected_function = basic_protected_function<stack_reference>;
-	using unsafe_function = basic_function<reference>;
-	using safe_function = basic_protected_function<reference>;
-	using stack_unsafe_function = basic_function<stack_reference>;
-	using stack_safe_function = basic_protected_function<stack_reference>;
-#ifdef SOL_SAFE_FUNCTIONS
-	using function = protected_function;
-	using stack_function = stack_protected_function;
-#else
-	using function = unsafe_function;
-	using stack_function = stack_unsafe_function;
-#endif
-	template <typename base_t>
-	class basic_object;
-	template <typename base_t>
-	class basic_userdata;
-	template <typename base_t>
-	class basic_lightuserdata;
-	struct variadic_args;
-	using object = basic_object<reference>;
-	using stack_object = basic_object<stack_reference>;
-	using userdata = basic_userdata<reference>;
-	using stack_userdata = basic_userdata<stack_reference>;
-	using lightuserdata = basic_lightuserdata<reference>;
-	using stack_lightuserdata = basic_lightuserdata<stack_reference>;
-	class coroutine;
-	class thread;
-	struct variadic_args;
-	struct this_state;
-	struct this_environment;
-
-	namespace detail {
-		template <typename T, typename = void>
-		struct lua_type_of : std::integral_constant<type, type::userdata> {};
-
-		template <>
-		struct lua_type_of<std::string> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<std::wstring> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<std::u16string> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<std::u32string> : std::integral_constant<type, type::string> {};
-
-		template <std::size_t N>
-		struct lua_type_of<char[N]> : std::integral_constant<type, type::string> {};
-
-		template <std::size_t N>
-		struct lua_type_of<wchar_t[N]> : std::integral_constant<type, type::string> {};
-
-		template <std::size_t N>
-		struct lua_type_of<char16_t[N]> : std::integral_constant<type, type::string> {};
-
-		template <std::size_t N>
-		struct lua_type_of<char32_t[N]> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<char> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<wchar_t> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<char16_t> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<char32_t> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<const char*> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<const char16_t*> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<const char32_t*> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<string_detail::string_shim> : std::integral_constant<type, type::string> {};
-
-		template <>
-		struct lua_type_of<bool> : std::integral_constant<type, type::boolean> {};
-
-		template <>
-		struct lua_type_of<lua_nil_t> : std::integral_constant<type, type::lua_nil> { };
-
-		template <>
-		struct lua_type_of<nullopt_t> : std::integral_constant<type, type::lua_nil> { };
-
-		template <>
-		struct lua_type_of<std::nullptr_t> : std::integral_constant<type, type::lua_nil> { };
-
-		template <>
-		struct lua_type_of<sol::error> : std::integral_constant<type, type::string> { };
-
-		template <bool b, typename Base>
-		struct lua_type_of<basic_table_core<b, Base>> : std::integral_constant<type, type::table> { };
-
-		template <>
-		struct lua_type_of<metatable_t> : std::integral_constant<type, type::table> { };
-
-		template <typename B>
-		struct lua_type_of<basic_environment<B>> : std::integral_constant<type, type::poly> { };
-
-		template <>
-		struct lua_type_of<env_t> : std::integral_constant<type, type::poly> { };
-
-		template <>
-		struct lua_type_of<new_table> : std::integral_constant<type, type::table> { };
-
-		template <typename T>
-		struct lua_type_of<as_table_t<T>> : std::integral_constant<type, type::table> {};
-
-		template <>
-		struct lua_type_of<reference> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<stack_reference> : std::integral_constant<type, type::poly> {};
-
-		template <typename Base>
-		struct lua_type_of<basic_object<Base>> : std::integral_constant<type, type::poly> {};
-
-		template <typename... Args>
-		struct lua_type_of<std::tuple<Args...>> : std::integral_constant<type, type::poly> {};
-
-		template <typename A, typename B>
-		struct lua_type_of<std::pair<A, B>> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<void*> : std::integral_constant<type, type::lightuserdata> {};
-
-		template <>
-		struct lua_type_of<lightuserdata_value> : std::integral_constant<type, type::lightuserdata> {};
-
-		template <>
-		struct lua_type_of<userdata_value> : std::integral_constant<type, type::userdata> {};
-
-		template <typename T>
-		struct lua_type_of<light<T>> : std::integral_constant<type, type::lightuserdata> {};
-
-		template <typename T>
-		struct lua_type_of<user<T>> : std::integral_constant<type, type::userdata> {};
-
-		template <typename Base>
-		struct lua_type_of<basic_lightuserdata<Base>> : std::integral_constant<type, type::lightuserdata> {};
-
-		template <typename Base>
-		struct lua_type_of<basic_userdata<Base>> : std::integral_constant<type, type::userdata> {};
-
-		template <>
-		struct lua_type_of<lua_CFunction> : std::integral_constant<type, type::function> {};
-
-		template <>
-		struct lua_type_of<std::remove_pointer_t<lua_CFunction>> : std::integral_constant<type, type::function> {};
-
-		template <typename Base>
-		struct lua_type_of<basic_function<Base>> : std::integral_constant<type, type::function> {};
-
-		template <typename Base>
-		struct lua_type_of<basic_protected_function<Base>> : std::integral_constant<type, type::function> {};
-
-		template <>
-		struct lua_type_of<coroutine> : std::integral_constant<type, type::function> {};
-
-		template <>
-		struct lua_type_of<thread> : std::integral_constant<type, type::thread> {};
-
-		template <typename Signature>
-		struct lua_type_of<std::function<Signature>> : std::integral_constant<type, type::function> {};
-
-		template <typename T>
-		struct lua_type_of<optional<T>> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<variadic_args> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<this_state> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<this_environment> : std::integral_constant<type, type::poly> {};
-
-		template <>
-		struct lua_type_of<type> : std::integral_constant<type, type::poly> {};
-
-		template <typename T>
-		struct lua_type_of<T*> : std::integral_constant<type, type::userdata> {};
-
-		template <typename T>
-		struct lua_type_of<T, std::enable_if_t<std::is_arithmetic<T>::value>> : std::integral_constant<type, type::number> {};
-
-		template <typename T>
-		struct lua_type_of<T, std::enable_if_t<std::is_enum<T>::value>> : std::integral_constant<type, type::number> {};
-
-		template <typename T, typename C = void>
-		struct is_container : std::false_type {};
-
-		template <>
-		struct is_container<std::string> : std::false_type {};
-
-		template <>
-		struct is_container<std::wstring> : std::false_type {};
-
-		template <>
-		struct is_container<std::u16string> : std::false_type {};
-
-		template <>
-		struct is_container<std::u32string> : std::false_type {};
-
-		template <typename T>
-		struct is_container<T, std::enable_if_t<meta::has_begin_end<meta::unqualified_t<T>>::value>> : std::true_type {};
-
-		template <>
-		struct lua_type_of<meta_function> : std::integral_constant<type, type::string> {};
-
-		template <typename C, C v, template <typename...> class V, typename... Args>
-		struct accumulate : std::integral_constant<C, v> {};
-
-		template <typename C, C v, template <typename...> class V, typename T, typename... Args>
-		struct accumulate<C, v, V, T, Args...> : accumulate<C, v + V<T>::value, V, Args...> {};
-	} // detail
-
-	template <typename T>
-	struct is_unique_usertype : std::integral_constant<bool, unique_usertype_traits<T>::value> {};
-
-	template <typename T>
-	struct lua_type_of : detail::lua_type_of<T> {
-		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_;
-	};
-
-	template <typename T>
-	struct lua_size : std::integral_constant<int, 1> { 
-		typedef int SOL_INTERNAL_UNSPECIALIZED_MARKER_; 
-	};
-
-	template <typename A, typename B>
-	struct lua_size<std::pair<A, B>> : std::integral_constant<int, lua_size<A>::value + lua_size<B>::value> { };
-
-	template <typename... Args>
-	struct lua_size<std::tuple<Args...>> : std::integral_constant<int, detail::accumulate<int, 0, lua_size, Args...>::value> { };
-
-	namespace detail {
-		template <typename...>
-		struct void_ { typedef void type; };
-		template <typename T, typename = void>
-		struct has_internal_marker_impl : std::false_type {};
-		template <typename T>
-		struct has_internal_marker_impl<T, typename void_<typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_>::type> : std::true_type {};
-
-		template <typename T>
-		struct has_internal_marker : has_internal_marker_impl<T> {};
-	}
-
-	template <typename T>
-	struct is_lua_primitive : std::integral_constant<bool,
-		type::userdata != lua_type_of<meta::unqualified_t<T>>::value
-		|| ((type::userdata == lua_type_of<meta::unqualified_t<T>>::value) 
-			&& detail::has_internal_marker<lua_type_of<meta::unqualified_t<T>>>::value 
-			&& !detail::has_internal_marker<lua_size<meta::unqualified_t<T>>>::value)
-		|| std::is_base_of<reference, meta::unqualified_t<T>>::value
-		|| std::is_base_of<stack_reference, meta::unqualified_t<T>>::value
-		|| meta::is_specialization_of<std::tuple, meta::unqualified_t<T>>::value
-		|| meta::is_specialization_of<std::pair, meta::unqualified_t<T>>::value
-	> { };
-
-	template <typename T>
-	struct is_lua_reference : std::integral_constant<bool,
-		std::is_base_of<reference, meta::unqualified_t<T>>::value
-		|| std::is_base_of<stack_reference, meta::unqualified_t<T>>::value
-		|| meta::is_specialization_of<proxy, meta::unqualified_t<T>>::value
-	> { };
-
-	template <typename T>
-	struct is_lua_primitive<T*> : std::true_type {};
-	template <typename T>
-	struct is_lua_primitive<std::reference_wrapper<T>> : std::true_type { };
-	template <typename T>
-	struct is_lua_primitive<user<T>> : std::true_type { };
-	template <typename T>
-	struct is_lua_primitive<light<T>> : is_lua_primitive<T*> { };
-	template <typename T>
-	struct is_lua_primitive<optional<T>> : std::true_type {};
-	template <>
-	struct is_lua_primitive<userdata_value> : std::true_type {};
-	template <>
-	struct is_lua_primitive<lightuserdata_value> : std::true_type {};
-	template <typename T>
-	struct is_lua_primitive<non_null<T>> : is_lua_primitive<T*> {};
-
-	template <typename T>
-	struct is_proxy_primitive : is_lua_primitive<T> { };
-
-	template <typename T>
-	struct is_transparent_argument : std::false_type {};
-
-	template <>
-	struct is_transparent_argument<this_state> : std::true_type {};
-
-	template <>
-	struct is_transparent_argument<this_environment> : std::true_type {};
-
-	template <>
-	struct is_transparent_argument<variadic_args> : std::true_type {};
-
-	template <typename T>
-	struct is_variadic_arguments : std::is_same<T, variadic_args> {};
-
-	template <typename Signature>
-	struct lua_bind_traits : meta::bind_traits<Signature> {
-	private:
-		typedef meta::bind_traits<Signature> base_t;
-	public:
-		typedef std::integral_constant<bool, meta::count_for<is_transparent_argument, typename base_t::args_list>::value != 0> runtime_variadics_t;
-		static const std::size_t true_arity = base_t::arity;
-		static const std::size_t arity = base_t::arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
-		static const std::size_t true_free_arity = base_t::free_arity;
-		static const std::size_t free_arity = base_t::free_arity - meta::count_for<is_transparent_argument, typename base_t::args_list>::value;
-	};
-
-	template <typename T>
-	struct is_table : std::false_type {};
-	template <bool x, typename T>
-	struct is_table<basic_table_core<x, T>> : std::true_type {};
-
-	template <typename T>
-	struct is_function : std::false_type {};
-	template <typename T>
-	struct is_function<basic_function<T>> : std::true_type {};
-	template <typename T>
-	struct is_function<basic_protected_function<T>> : std::true_type {};
-
-	template <typename T>
-	struct is_lightuserdata : std::false_type {};
-	template <typename T>
-	struct is_lightuserdata<basic_lightuserdata<T>> : std::true_type {};
-
-	template <typename T>
-	struct is_userdata : std::false_type {};
-	template <typename T>
-	struct is_userdata<basic_userdata<T>> : std::true_type {};
-
-	template <typename T>
-	struct is_environment : std::integral_constant<bool, is_userdata<T>::value || is_table<T>::value> {};
-
-	template <typename T>
-	struct is_container : detail::is_container<T>{};
-	
-	template<typename T>
-	inline type type_of() {
-		return lua_type_of<meta::unqualified_t<T>>::value;
-	}
-
-	namespace detail {
-		template <typename T>
-		struct lua_type_of<nested<T>, std::enable_if_t<::sol::is_container<T>::value>> : std::integral_constant<type, type::table> {};
-
-		template <typename T>
-		struct lua_type_of<nested<T>, std::enable_if_t<!::sol::is_container<T>::value>> : lua_type_of<T> {};
-	} // detail
-} // sol
-
-// end of sol/types.hpp
-
-// beginning of sol/stack_reference.hpp
-
-namespace sol {
-	class stack_reference {
-	private:
-		lua_State* L = nullptr;
-		int index = 0;
-
-	protected:
-		int registry_index() const noexcept {
-			return LUA_NOREF;
-		}
-
-	public:
-		stack_reference() noexcept = default;
-		stack_reference(lua_nil_t) noexcept : stack_reference() {};
-		stack_reference(lua_State* L, int i) noexcept : L(L), index(lua_absindex(L, i)) {}
-		stack_reference(lua_State* L, absolute_index i) noexcept : L(L), index(i) {}
-		stack_reference(lua_State* L, raw_index i) noexcept : L(L), index(i) {}
-		stack_reference(lua_State* L, ref_index i) noexcept = delete;
-		stack_reference(stack_reference&& o) noexcept = default;
-		stack_reference& operator=(stack_reference&&) noexcept = default;
-		stack_reference(const stack_reference&) noexcept = default;
-		stack_reference& operator=(const stack_reference&) noexcept = default;
-
-		int push() const noexcept {
-			return push(lua_state());
-		}
-
-		int push(lua_State* Ls) const noexcept {
-			lua_pushvalue(lua_state(), index);
-			if (Ls != lua_state()) {
-				lua_xmove(lua_state(), Ls, 1);
-			}
-			return 1;
-		}
-
-		void pop() const noexcept {
-			pop(lua_state());
-		}
-
-		void pop(lua_State* Ls, int n = 1) const noexcept {
-			lua_pop(Ls, n);
-		}
-
-		int stack_index() const noexcept {
-			return index;
-		}
-
-		type get_type() const noexcept {
-			int result = lua_type(L, index);
-			return static_cast<type>(result);
-		}
-
-		lua_State* lua_state() const noexcept {
-			return L;
-		}
-
-		bool valid() const noexcept {
-			type t = get_type();
-			return t != type::lua_nil && t != type::none;
-		}
-	};
-
-	inline bool operator== (const stack_reference& l, const stack_reference& r) {
-		return lua_compare(l.lua_state(), l.stack_index(), r.stack_index(), LUA_OPEQ) == 0;
-	}
-
-	inline bool operator!= (const stack_reference& l, const stack_reference& r) {
-		return !operator==(l, r);
-	}
-
-	inline bool operator==(const stack_reference& lhs, const lua_nil_t&) {
-		return !lhs.valid();
-	}
-
-	inline bool operator==(const lua_nil_t&, const stack_reference& rhs) {
-		return !rhs.valid();
-	}
-
-	inline bool operator!=(const stack_reference& lhs, const lua_nil_t&) {
-		return lhs.valid();
-	}
-
-	inline bool operator!=(const lua_nil_t&, const stack_reference& rhs) {
-		return rhs.valid();
-	}
-} // sol
-
-// end of sol/stack_reference.hpp
-
-namespace sol {
-	namespace stack {
-		inline void remove(lua_State* L, int rawindex, int count) {
-			if (count < 1)
-				return;
-			int top = lua_gettop(L);
-			if (rawindex == -count || top == rawindex) {
-				// Slice them right off the top
-				lua_pop(L, static_cast<int>(count));
-				return;
-			}
-
-			// Remove each item one at a time using stack operations
-			// Probably slower, maybe, haven't benchmarked,
-			// but necessary
-			int index = lua_absindex(L, rawindex);
-			if (index < 0) {
-				index = lua_gettop(L) + (index + 1);
-			}
-			int last = index + count;
-			for (int i = index; i < last; ++i) {
-				lua_remove(L, index);
-			}
-		}
-
-		struct push_popper_at {
-			lua_State* L;
-			int index;
-			int count;
-			push_popper_at(lua_State* luastate, int index = -1, int count = 1) : L(luastate), index(index), count(count) { }
-			~push_popper_at() { remove(L, index, count); }
-		};
-
-		template <bool top_level>
-		struct push_popper_n {
-			lua_State* L;
-			int t;
-			push_popper_n(lua_State* luastate, int x) : L(luastate), t(x) { }
-			~push_popper_n() { lua_pop(L, t); }
-		};
-		template <>
-		struct push_popper_n<true> {
-			push_popper_n(lua_State*, int) { }
-		};
-		template <bool top_level, typename T>
-		struct push_popper {
-			T t;
-			push_popper(T x) : t(x) { t.push(); }
-			~push_popper() { t.pop(); }
-		};
-		template <typename T>
-		struct push_popper<true, T> {
-			push_popper(T) {}
-			~push_popper() {}
-		};
-		template <bool top_level = false, typename T>
-		push_popper<top_level, T> push_pop(T&& x) {
-			return push_popper<top_level, T>(std::forward<T>(x));
-		}
-		template <typename T>
-		push_popper_at push_pop_at(T&& x) {
-			int c = x.push();
-			lua_State* L = x.lua_state();
-			return push_popper_at(L, lua_absindex(L, -c), c);
-		}
-		template <bool top_level = false>
-		push_popper_n<top_level> pop_n(lua_State* L, int x) {
-			return push_popper_n<top_level>(L, x);
-		}
-	} // stack
-
-	namespace detail {
-		struct global_tag { } const global_{};
-		struct no_safety_tag {} const no_safety{};
-	} // detail
-
-	class reference {
-	private:
-		lua_State* luastate = nullptr; // non-owning
-		int ref = LUA_NOREF;
-
-		int copy() const noexcept {
-			if (ref == LUA_NOREF)
-				return LUA_NOREF;
-			push();
-			return luaL_ref(lua_state(), LUA_REGISTRYINDEX);
-		}
-
-	protected:
-		reference(lua_State* L, detail::global_tag) noexcept : luastate(L) {
-			lua_pushglobaltable(lua_state());
-			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
-		}
-
-		int stack_index() const noexcept {
-			return -1;
-		}
-
-		void deref() const noexcept {
-			luaL_unref(lua_state(), LUA_REGISTRYINDEX, ref);
-		}
-
-	public:
-		reference() noexcept = default;
-		reference(lua_nil_t) noexcept : reference() {}
-		reference(const stack_reference& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
-		reference(stack_reference&& r) noexcept : reference(r.lua_state(), r.stack_index()) {}
-		reference(lua_State* L, int index = -1) noexcept : luastate(L) {
-			lua_pushvalue(lua_state(), index);
-			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
-		}
-		reference(lua_State* L, ref_index index) noexcept : luastate(L) {
-			lua_rawgeti(L, LUA_REGISTRYINDEX, index.index);
-			ref = luaL_ref(lua_state(), LUA_REGISTRYINDEX);
-		}
-
-		~reference() noexcept {
-			deref();
-		}
-
-		reference(reference&& o) noexcept {
-			luastate = o.luastate;
-			ref = o.ref;
-
-			o.luastate = nullptr;
-			o.ref = LUA_NOREF;
-		}
-
-		reference& operator=(reference&& o) noexcept {
-			if (valid()) {
-				deref();
-			}
-			luastate = o.luastate;
-			ref = o.ref;
-
-			o.luastate = nullptr;
-			o.ref = LUA_NOREF;
-
-			return *this;
-		}
-
-		reference(const reference& o) noexcept {
-			luastate = o.luastate;
-			ref = o.copy();
-		}
-
-		reference& operator=(const reference& o) noexcept {
-			luastate = o.luastate;
-			deref();
-			ref = o.copy();
-			return *this;
-		}
-
-		int push() const noexcept {
-			return push(lua_state());
-		}
-
-		int push(lua_State* Ls) const noexcept {
-			lua_rawgeti(Ls, LUA_REGISTRYINDEX, ref);
-			return 1;
-		}
-
-		void pop() const noexcept {
-			pop(lua_state());
-		}
-
-		void pop(lua_State* Ls, int n = 1) const noexcept {
-			lua_pop(Ls, n);
-		}
-
-		int registry_index() const noexcept {
-			return ref;
-		}
-
-		bool valid() const noexcept {
-			return !(ref == LUA_NOREF || ref == LUA_REFNIL);
-		}
-
-		explicit operator bool() const noexcept {
-			return valid();
-		}
-
-		type get_type() const noexcept {
-			auto pp = stack::push_pop(*this);
-			int result = lua_type(lua_state(), -1);
-			return static_cast<type>(result);
-		}
-
-		lua_State* lua_state() const noexcept {
-			return luastate;
-		}
-	};
-
-	inline bool operator== (const reference& l, const reference& r) {
-		auto ppl = stack::push_pop(l);
-		auto ppr = stack::push_pop(r);
-		return lua_compare(l.lua_state(), -1, -2, LUA_OPEQ) == 1;
-	}
-
-	inline bool operator!= (const reference& l, const reference& r) {
-		return !operator==(l, r);
-	}
-
-	inline bool operator==(const reference& lhs, const lua_nil_t&) {
-		return !lhs.valid();
-	}
-
-	inline bool operator==(const lua_nil_t&, const reference& rhs) {
-		return !rhs.valid();
-	}
-
-	inline bool operator!=(const reference& lhs, const lua_nil_t&) {
-		return lhs.valid();
-	}
-
-	inline bool operator!=(const lua_nil_t&, const reference& rhs) {
-		return rhs.valid();
-	}
-} // sol
-
-// end of sol/reference.hpp
-
-// beginning of sol/stack.hpp
-
-// beginning of sol/stack_core.hpp
-
-// beginning of sol/tie.hpp
-
-namespace sol {
-
-	namespace detail {
-		template <typename T>
-		struct is_speshul : std::false_type {};
-	}
-
-	template <typename T>
-	struct tie_size : std::tuple_size<T> {};
-
-	template <typename T>
-	struct is_tieable : std::integral_constant<bool, (::sol::tie_size<T>::value > 0)> {};
-
-	template <typename... Tn>
-	struct tie_t : public std::tuple<std::add_lvalue_reference_t<Tn>...> {
-	private:
-		typedef std::tuple<std::add_lvalue_reference_t<Tn>...> base_t;
-
-		template <typename T>
-		void set(std::false_type, T&& target) {
-			std::get<0>(*this) = std::forward<T>(target);
-		}
-
-		template <typename T>
-		void set(std::true_type, T&& target) {
-			typedef tie_size<meta::unqualified_t<T>> value_size;
-			typedef tie_size<std::tuple<Tn...>> tie_size;
-			typedef std::conditional_t<(value_size::value < tie_size::value), value_size, tie_size> indices_size;
-			typedef std::make_index_sequence<indices_size::value> indices;
-			set_extra(detail::is_speshul<meta::unqualified_t<T>>(), indices(), std::forward<T>(target));
-		}
-
-		template <std::size_t... I, typename T>
-		void set_extra(std::true_type, std::index_sequence<I...>, T&& target) {
-			using std::get;
-			(void)detail::swallow{ 0,
-				(get<I>(static_cast<base_t&>(*this)) = get<I>(types<Tn...>(), target), 0)...
-				, 0 };
-		}
-
-		template <std::size_t... I, typename T>
-		void set_extra(std::false_type, std::index_sequence<I...>, T&& target) {
-			using std::get;
-			(void)detail::swallow{ 0,
-				(get<I>(static_cast<base_t&>(*this)) = get<I>(target), 0)...
-				, 0 };
-		}
-
-	public:
-		using base_t::base_t;
-
-		template <typename T>
-		tie_t& operator= (T&& value) {
-			typedef is_tieable<meta::unqualified_t<T>> tieable;
-			set(tieable(), std::forward<T>(value));
-			return *this;
-		}
-
-	};
-
-	template <typename... Tn>
-	struct tie_size< tie_t<Tn...> > : std::tuple_size< std::tuple<Tn...> > { };
-
-	namespace adl_barrier_detail {
-		template <typename... Tn>
-		inline tie_t<std::remove_reference_t<Tn>...> tie(Tn&&... argn) {
-			return tie_t<std::remove_reference_t<Tn>...>(std::forward<Tn>(argn)...);
-		}
-	}
-
-	using namespace adl_barrier_detail;
-
-} // sol
-
-// end of sol/tie.hpp
-
-// beginning of sol/stack_guard.hpp
-
-namespace sol {
-	namespace detail {
-		inline void stack_fail(int, int) {
-#ifndef SOL_NO_EXCEPTIONS
-			throw error(detail::direct_error, "imbalanced stack after operation finish");
-#else
-			// Lol, what do you want, an error printout? :3c
-			// There's no sane default here. The right way would be C-style abort(), and that's not acceptable, so
-			// hopefully someone will register their own stack_fail thing for the `fx` parameter of stack_guard.
-#endif // No Exceptions
-		}
-	} // detail
-
-	struct stack_guard {
-		lua_State* L;
-		int top;
-		std::function<void(int, int)> on_mismatch;
-
-		stack_guard(lua_State* L) : stack_guard(L, lua_gettop(L)) {}
-		stack_guard(lua_State* L, int top, std::function<void(int, int)> fx = detail::stack_fail) : L(L), top(top), on_mismatch(std::move(fx)) {}
-		bool check_stack(int modification = 0) const {
-			int bottom = lua_gettop(L) + modification;
-			if (top == bottom) {
-				return true;
-			}
-			on_mismatch(top, bottom);
-			return false;
-		}
-		~stack_guard() {
-			check_stack();
-		}
-	};
-} // sol
-
-// end of sol/stack_guard.hpp
-
-#include <vector>
-
-namespace sol {
-	namespace detail {
-		struct as_reference_tag {};
-		template <typename T>
-		struct as_pointer_tag {};
-		template <typename T>
-		struct as_value_tag {};
-
-		using special_destruct_func = void(*)(void*);
-
-		template <typename T, typename Real>
-		inline void special_destruct(void* memory) {
-			T** pointerpointer = static_cast<T**>(memory);
-			special_destruct_func* dx = static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer + 1));
-			Real* target = static_cast<Real*>(static_cast<void*>(dx + 1));
-			target->~Real();
-		}
-
-		template <typename T>
-		inline int unique_destruct(lua_State* L) {
-			void* memory = lua_touserdata(L, 1);
-			T** pointerpointer = static_cast<T**>(memory);
-			special_destruct_func& dx = *static_cast<special_destruct_func*>(static_cast<void*>(pointerpointer + 1));
-			(dx)(memory);
-			return 0;
-		}
-
-		template <typename T>
-		inline int user_alloc_destroy(lua_State* L) {
-			void* rawdata = lua_touserdata(L, 1);
-			T* data = static_cast<T*>(rawdata);
-			std::allocator<T> alloc;
-			alloc.destroy(data);
-			return 0;
-		}
-
-		template <typename T>
-		inline int usertype_alloc_destroy(lua_State* L) {
-			void* rawdata = lua_touserdata(L, 1);
-			T** pdata = static_cast<T**>(rawdata);
-			T* data = *pdata;
-			std::allocator<T> alloc{};
-			alloc.destroy(data);
-			return 0;
-		}
-
-		template <typename T>
-		void reserve(T&, std::size_t) {}
-
-		template <typename T, typename Al>
-		void reserve(std::vector<T, Al>& arr, std::size_t hint) {
-			arr.reserve(hint);
-		}
-
-		template <typename T, typename Tr, typename Al>
-		void reserve(std::basic_string<T, Tr, Al>& arr, std::size_t hint) {
-			arr.reserve(hint);
-		}
-	} // detail
-
-	namespace stack {
-
-		template<typename T, bool global = false, bool raw = false, typename = void>
-		struct field_getter;
-		template <typename T, bool global = false, bool raw = false, typename = void>
-		struct probe_field_getter;
-		template<typename T, bool global = false, bool raw = false, typename = void>
-		struct field_setter;
-		template<typename T, typename = void>
-		struct getter;
-		template<typename T, typename = void>
-		struct popper;
-		template<typename T, typename = void>
-		struct pusher;
-		template<typename T, type = lua_type_of<T>::value, typename = void>
-		struct checker;
-		template<typename T, typename = void>
-		struct check_getter;
-
-		struct probe {
-			bool success;
-			int levels;
-
-			probe(bool s, int l) : success(s), levels(l) {}
-
-			operator bool() const { return success; };
-		};
-
-		struct record {
-			int last;
-			int used;
-
-			record() : last(), used() {}
-			void use(int count) {
-				last = count;
-				used += count;
-			}
-		};
-
-		namespace stack_detail {
-			template <typename T>
-			struct strip {
-				typedef T type;
-			};
-			template <typename T>
-			struct strip<std::reference_wrapper<T>> {
-				typedef T& type;
-			};
-			template <typename T>
-			struct strip<user<T>> {
-				typedef T& type;
-			};
-			template <typename T>
-			struct strip<non_null<T>> {
-				typedef T type;
-			};
-			template <typename T>
-			using strip_t = typename strip<T>::type;
-
-			const bool default_check_arguments =
-#ifdef SOL_CHECK_ARGUMENTS
-				true;
-#else
-				false;
-#endif
-			template<typename T>
-			inline decltype(auto) unchecked_get(lua_State* L, int index, record& tracking) {
-				return getter<meta::unqualified_t<T>>{}.get(L, index, tracking);
-			}
-
-			template<typename T, typename Arg, typename... Args>
-			inline int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
-				typedef meta::all<
-					std::is_lvalue_reference<T>,
-					meta::neg<std::is_const<T>>,
-					meta::neg<is_lua_primitive<meta::unqualified_t<T>>>,
-					meta::neg<is_unique_usertype<meta::unqualified_t<T>>>
-				> use_reference_tag;
-				return pusher<std::conditional_t<use_reference_tag::value, detail::as_reference_tag, meta::unqualified_t<T>>>{}.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
-			}
-		} // stack_detail
-
-		inline bool maybe_indexable(lua_State* L, int index = -1) {
-			type t = type_of(L, index);
-			return t == type::userdata || t == type::table;
-		}
-
-		template<typename T, typename... Args>
-		inline int push(lua_State* L, T&& t, Args&&... args) {
-			return pusher<meta::unqualified_t<T>>{}.push(L, std::forward<T>(t), std::forward<Args>(args)...);
-		}
-
-		// overload allows to use a pusher of a specific type, but pass in any kind of args
-		template<typename T, typename Arg, typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
-		inline int push(lua_State* L, Arg&& arg, Args&&... args) {
-			return pusher<meta::unqualified_t<T>>{}.push(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
-		}
-
-		template<typename T, typename... Args>
-		inline int push_reference(lua_State* L, T&& t, Args&&... args) {
-			return stack_detail::push_reference<T>(L, std::forward<T>(t), std::forward<Args>(args)...);
-		}
-
-		template<typename T, typename Arg, typename... Args>
-		inline int push_reference(lua_State* L, Arg&& arg, Args&&... args) {
-			return stack_detail::push_reference<T>(L, std::forward<Arg>(arg), std::forward<Args>(args)...);
-		}
-
-		inline int multi_push(lua_State*) {
-			// do nothing
-			return 0;
-		}
-
-		template<typename T, typename... Args>
-		inline int multi_push(lua_State* L, T&& t, Args&&... args) {
-			int pushcount = push(L, std::forward<T>(t));
-			void(sol::detail::swallow{ (pushcount += sol::stack::push(L, std::forward<Args>(args)), 0)... });
-			return pushcount;
-		}
-
-		inline int multi_push_reference(lua_State*) {
-			// do nothing
-			return 0;
-		}
-
-		template<typename T, typename... Args>
-		inline int multi_push_reference(lua_State* L, T&& t, Args&&... args) {
-			int pushcount = push_reference(L, std::forward<T>(t));
-			void(sol::detail::swallow{ (pushcount += sol::stack::push_reference(L, std::forward<Args>(args)), 0)... });
-			return pushcount;
-		}
-
-		template <typename T, typename Handler>
-		bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-			typedef meta::unqualified_t<T> Tu;
-			checker<Tu> c;
-			// VC++ has a bad warning here: shut it up
-			(void)c;
-			return c.check(L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template <typename T, typename Handler>
-		bool check(lua_State* L, int index, Handler&& handler) {
-			record tracking{};
-			return check<T>(L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template <typename T>
-		bool check(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
-			auto handler = no_panic;
-			return check<T>(L, index, handler);
-		}
-
-		template<typename T, typename Handler>
-		inline decltype(auto) check_get(lua_State* L, int index, Handler&& handler, record& tracking) {
-			return check_getter<meta::unqualified_t<T>>{}.get(L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template<typename T, typename Handler>
-		inline decltype(auto) check_get(lua_State* L, int index, Handler&& handler) {
-			record tracking{};
-			return check_get<T>(L, index, handler, tracking);
-		}
-
-		template<typename T>
-		inline decltype(auto) check_get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
-			auto handler = no_panic;
-			return check_get<T>(L, index, handler);
-		}
-
-		namespace stack_detail {
-
-#ifdef SOL_CHECK_ARGUMENTS
-			template <typename T>
-			inline auto tagged_get(types<T>, lua_State* L, int index, record& tracking) -> decltype(stack_detail::unchecked_get<T>(L, index, tracking)) {
-				auto op = check_get<T>(L, index, type_panic, tracking);
-				return *std::move(op);
-			}
-#else
-			template <typename T>
-			inline decltype(auto) tagged_get(types<T>, lua_State* L, int index, record& tracking) {
-				return stack_detail::unchecked_get<T>(L, index, tracking);
-			}
-#endif
-
-			template <typename T>
-			inline decltype(auto) tagged_get(types<optional<T>>, lua_State* L, int index, record& tracking) {
-				return stack_detail::unchecked_get<optional<T>>(L, index, tracking);
-			}
-
-			template <bool b>
-			struct check_types {
-				template <typename T, typename... Args, typename Handler>
-				static bool check(types<T, Args...>, lua_State* L, int firstargument, Handler&& handler, record& tracking) {
-					if (!stack::check<T>(L, firstargument + tracking.used, handler, tracking))
-						return false;
-					return check(types<Args...>(), L, firstargument, std::forward<Handler>(handler), tracking);
-				}
-
-				template <typename Handler>
-				static bool check(types<>, lua_State*, int, Handler&&, record&) {
-					return true;
-				}
-			};
-
-			template <>
-			struct check_types<false> {
-				template <typename... Args, typename Handler>
-				static bool check(types<Args...>, lua_State*, int, Handler&&, record&) {
-					return true;
-				}
-			};
-
-		} // stack_detail
-
-		template <bool b, typename... Args, typename Handler>
-		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
-			return stack_detail::check_types<b>{}.check(types<meta::unqualified_t<Args>...>(), L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template <bool b, typename... Args, typename Handler>
-		bool multi_check(lua_State* L, int index, Handler&& handler) {
-			record tracking{};
-			return multi_check<b, Args...>(L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template <bool b, typename... Args>
-		bool multi_check(lua_State* L, int index) {
-			auto handler = no_panic;
-			return multi_check<b, Args...>(L, index, handler);
-		}
-
-		template <typename... Args, typename Handler>
-		bool multi_check(lua_State* L, int index, Handler&& handler, record& tracking) {
-			return multi_check<true, Args...>(L, index, std::forward<Handler>(handler), tracking);
-		}
-
-		template <typename... Args, typename Handler>
-		bool multi_check(lua_State* L, int index, Handler&& handler) {
-			return multi_check<true, Args...>(L, index, std::forward<Handler>(handler));
-		}
-
-		template <typename... Args>
-		bool multi_check(lua_State* L, int index) {
-			return multi_check<true, Args...>(L, index);
-		}
-
-		template<typename T>
-		inline decltype(auto) get(lua_State* L, int index, record& tracking) {
-			return stack_detail::tagged_get(types<T>(), L, index, tracking);
-		}
-
-		template<typename T>
-		inline decltype(auto) get(lua_State* L, int index = -lua_size<meta::unqualified_t<T>>::value) {
-			record tracking{};
-			return get<T>(L, index, tracking);
-		}
-
-		template<typename T>
-		inline decltype(auto) pop(lua_State* L) {
-			return popper<meta::unqualified_t<T>>{}.pop(L);
-		}
-
-		template <bool global = false, bool raw = false, typename Key>
-		void get_field(lua_State* L, Key&& key) {
-			field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key));
-		}
-
-		template <bool global = false, bool raw = false, typename Key>
-		void get_field(lua_State* L, Key&& key, int tableindex) {
-			field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key), tableindex);
-		}
-
-		template <bool global = false, typename Key>
-		void raw_get_field(lua_State* L, Key&& key) {
-			get_field<global, true>(L, std::forward<Key>(key));
-		}
-
-		template <bool global = false, typename Key>
-		void raw_get_field(lua_State* L, Key&& key, int tableindex) {
-			get_field<global, true>(L, std::forward<Key>(key), tableindex);
-		}
-
-		template <bool global = false, bool raw = false, typename Key>
-		probe probe_get_field(lua_State* L, Key&& key) {
-			return probe_field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key));
-		}
-
-		template <bool global = false, bool raw = false, typename Key>
-		probe probe_get_field(lua_State* L, Key&& key, int tableindex) {
-			return probe_field_getter<meta::unqualified_t<Key>, global, raw>{}.get(L, std::forward<Key>(key), tableindex);
-		}
-
-		template <bool global = false, typename Key>
-		probe probe_raw_get_field(lua_State* L, Key&& key) {
-			return probe_get_field<global, true>(L, std::forward<Key>(key));
-		}
-
-		template <bool global = false, typename Key>
-		probe probe_raw_get_field(lua_State* L, Key&& key, int tableindex) {
-			return probe_get_field<global, true>(L, std::forward<Key>(key), tableindex);
-		}
-
-		template <bool global = false, bool raw = false, typename Key, typename Value>
-		void set_field(lua_State* L, Key&& key, Value&& value) {
-			field_setter<meta::unqualified_t<Key>, global, raw>{}.set(L, std::forward<Key>(key), std::forward<Value>(value));
-		}
-
-		template <bool global = false, bool raw = false, typename Key, typename Value>
-		void set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
-			field_setter<meta::unqualified_t<Key>, global, raw>{}.set(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
-		}
-
-		template <bool global = false, typename Key, typename Value>
-		void raw_set_field(lua_State* L, Key&& key, Value&& value) {
-			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value));
-		}
-
-		template <bool global = false, typename Key, typename Value>
-		void raw_set_field(lua_State* L, Key&& key, Value&& value, int tableindex) {
-			set_field<global, true>(L, std::forward<Key>(key), std::forward<Value>(value), tableindex);
-		}
-	} // stack
-} // sol
-
-// end of sol/stack_core.hpp
-
-// beginning of sol/stack_check.hpp
-
-// beginning of sol/usertype_traits.hpp
-
-// beginning of sol/demangle.hpp
-
-#include <cctype>
-#include <locale>
-
-namespace sol {
-	namespace detail {
-#if defined(__GNUC__) || defined(__clang__)
-		template <typename T, class seperator_mark = int>
-		inline std::string ctti_get_type_name() {
-			const static std::array<std::string, 2> removals = { { "{anonymous}", "(anonymous namespace)" } };
-			std::string name = __PRETTY_FUNCTION__;
-			std::size_t start = name.find_first_of('[');
-			start = name.find_first_of('=', start);
-			std::size_t end = name.find_last_of(']');
-			if (end == std::string::npos)
-				end = name.size();
-			if (start == std::string::npos)
-				start = 0;
-			if (start < name.size() - 1)
-				start += 1;
-			name = name.substr(start, end - start);
-			start = name.rfind("seperator_mark");
-			if (start != std::string::npos) {
-				name.erase(start - 2, name.length());
-			}
-			while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
-			while (!name.empty() && std::isblank(name.back())) name.pop_back();
-
-			for (std::size_t r = 0; r < removals.size(); ++r) {
-				auto found = name.find(removals[r]);
-				while (found != std::string::npos) {
-					name.erase(found, removals[r].size());
-					found = name.find(removals[r]);
-				}
-			}
-
-			return name;
-		}
-#elif defined(_MSC_VER)
-		template <typename T>
-		inline std::string ctti_get_type_name() {
-			const static std::array<std::string, 7> removals = { { "public:", "private:", "protected:", "struct ", "class ", "`anonymous-namespace'", "`anonymous namespace'" } };
-			std::string name = __FUNCSIG__;
-			std::size_t start = name.find("get_type_name");
-			if (start == std::string::npos)
-				start = 0;
-			else
-				start += 13;
-			if (start < name.size() - 1)
-				start += 1;
-			std::size_t end = name.find_last_of('>');
-			if (end == std::string::npos)
-				end = name.size();
-			name = name.substr(start, end - start);
-			if (name.find("struct", 0) == 0)
-				name.replace(0, 6, "", 0);
-			if (name.find("class", 0) == 0)
-				name.replace(0, 5, "", 0);
-			while (!name.empty() && std::isblank(name.front())) name.erase(name.begin());
-			while (!name.empty() && std::isblank(name.back())) name.pop_back();
-
-			for (std::size_t r = 0; r < removals.size(); ++r) {
-				auto found = name.find(removals[r]);
-				while (found != std::string::npos) {
-					name.erase(found, removals[r].size());
-					found = name.find(removals[r]);
-				}
-			}
-
-			return name;
-		}
-#else
-#error Compiler not supported for demangling
-#endif // compilers
-
-		template <typename T>
-		inline std::string demangle_once() {
-			std::string realname = ctti_get_type_name<T>();
-			return realname;
-		}
-
-		template <typename T>
-		inline std::string short_demangle_once() {
-			std::string realname = ctti_get_type_name<T>();
-			// This isn't the most complete but it'll do for now...?
-			static const std::array<std::string, 10> ops = { { "operator<", "operator<<", "operator<<=", "operator<=", "operator>", "operator>>", "operator>>=", "operator>=", "operator->", "operator->*" } };
-			int level = 0;
-			std::ptrdiff_t idx = 0;
-			for (idx = static_cast<std::ptrdiff_t>(realname.empty() ? 0 : realname.size() - 1); idx > 0; --idx) {
-				if (level == 0 && realname[idx] == ':') {
-					break;
-				}
-				bool isleft = realname[idx] == '<';
-				bool isright = realname[idx] == '>';
-				if (!isleft && !isright)
-					continue;
-				bool earlybreak = false;
-				for (const auto& op : ops) {
-					std::size_t nisop = realname.rfind(op, idx);
-					if (nisop == std::string::npos)
-						continue;
-					std::size_t nisopidx = idx - op.size() + 1;
-					if (nisop == nisopidx) {
-						idx = static_cast<std::ptrdiff_t>(nisopidx);
-						earlybreak = true;
-					}
-					break;
-				}
-				if (earlybreak) {
-					continue;
-				}
-				level += isleft ? -1 : 1;
-			}
-			if (idx > 0) {
-				realname.erase(0, realname.length() < static_cast<std::size_t>(idx) ? realname.length() : idx + 1);
-			}
-			return realname;
-		}
-
-		template <typename T>
-		inline const std::string& demangle() {
-			static const std::string d = demangle_once<T>();
-			return d;
-		}
-
-		template <typename T>
-		inline const std::string& short_demangle() {
-			static const std::string d = short_demangle_once<T>();
-			return d;
-		}
-	} // detail
-} // sol
-
-// end of sol/demangle.hpp
-
-namespace sol {
-
-	template<typename T>
-	struct usertype_traits {
-		static const std::string& name() {
-			static const std::string& n = detail::short_demangle<T>();
-			return n;
-		}
-		static const std::string& qualified_name() {
-			static const std::string& q_n = detail::demangle<T>();
-			return q_n;
-		}
-		static const std::string& metatable() {
-			static const std::string m = std::string("sol.").append(detail::demangle<T>());
-			return m;
-		}
-		static const std::string& user_metatable() {
-			static const std::string u_m = std::string("sol.").append(detail::demangle<T>()).append(".user");
-			return u_m;
-		}
-		static const std::string& user_gc_metatable() {
-			static const std::string u_g_m = std::string("sol.").append(detail::demangle<T>()).append(".user\xE2\x99\xBB");
-			return u_g_m;
-		}
-		static const std::string& gc_table() {
-			static const std::string g_t = std::string("sol.").append(detail::demangle<T>()).append(".\xE2\x99\xBB");
-			return g_t;
-		}
-	};
-
-}
-
-// end of sol/usertype_traits.hpp
-
-// beginning of sol/inheritance.hpp
-
-#include <atomic>
-
-namespace sol {
-	template <typename... Args>
-	struct base_list { };
-	template <typename... Args>
-	using bases = base_list<Args...>;
-
-	typedef bases<> base_classes_tag;
-	const auto base_classes = base_classes_tag();
-
-	namespace detail {
-
-		template <typename T>
-		struct has_derived {
-			static bool value;
-		};
-
-		template <typename T>
-		bool has_derived<T>::value = false;
-
-		inline std::size_t unique_id() {
-			static std::atomic<std::size_t> x(0);
-			return ++x;
-		}
-
-		template <typename T>
-		struct id_for {
-			static const std::size_t value;
-		};
-
-		template <typename T>
-		const std::size_t id_for<T>::value = unique_id();
-
-		inline decltype(auto) base_class_check_key() {
-			static const auto& key = "class_check";
-			return key;
-		}
-
-		inline decltype(auto) base_class_cast_key() {
-			static const auto& key = "class_cast";
-			return key;
-		}
-
-		inline decltype(auto) base_class_index_propogation_key() {
-			static const auto& key = u8"\xF0\x9F\x8C\xB2.index";
-			return key;
-		}
-
-		inline decltype(auto) base_class_new_index_propogation_key() {
-			static const auto& key = u8"\xF0\x9F\x8C\xB2.new_index";
-			return key;
-		}
-
-		template <typename T, typename... Bases>
-		struct inheritance {
-			static bool type_check_bases(types<>, std::size_t) {
-				return false;
-			}
-
-			template <typename Base, typename... Args>
-			static bool type_check_bases(types<Base, Args...>, std::size_t ti) {
-				return ti == id_for<Base>::value || type_check_bases(types<Args...>(), ti);
-			}
-
-			static bool type_check(std::size_t ti) {
-				return ti == id_for<T>::value || type_check_bases(types<Bases...>(), ti);
-			}
-
-			static void* type_cast_bases(types<>, T*, std::size_t) {
-				return nullptr;
-			}
-
-			template <typename Base, typename... Args>
-			static void* type_cast_bases(types<Base, Args...>, T* data, std::size_t ti) {
-				// Make sure to convert to T first, and then dynamic cast to the proper type
-				return ti != id_for<Base>::value ? type_cast_bases(types<Args...>(), data, ti) : static_cast<void*>(static_cast<Base*>(data));
-			}
-
-			static void* type_cast(void* voiddata, std::size_t ti) {
-				T* data = static_cast<T*>(voiddata);
-				return static_cast<void*>(ti != id_for<T>::value ? type_cast_bases(types<Bases...>(), data, ti) : data);
-			}
-		};
-
-		using inheritance_check_function = decltype(&inheritance<void>::type_check);
-		using inheritance_cast_function = decltype(&inheritance<void>::type_cast);
-
-	} // detail
-} // sol
-
-// end of sol/inheritance.hpp
-
-#include <utility>
-
-namespace sol {
-	namespace stack {
-		namespace stack_detail {
-			template <typename T, bool poptable = true>
-			inline bool check_metatable(lua_State* L, int index = -2) {
-				const auto& metakey = usertype_traits<T>::metatable();
-				luaL_getmetatable(L, &metakey[0]);
-				const type expectedmetatabletype = static_cast<type>(lua_type(L, -1));
-				if (expectedmetatabletype != type::lua_nil) {
-					if (lua_rawequal(L, -1, index) == 1) {
-						lua_pop(L, 1 + static_cast<int>(poptable));
-						return true;
-					}
-				}
-				lua_pop(L, 1);
-				return false;
-			}
-
-			template <type expected, int(*check_func)(lua_State*, int)>
-			struct basic_check {
-				template <typename Handler>
-				static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-					tracking.use(1);
-					bool success = check_func(L, index) == 1;
-					if (!success) {
-						// expected type, actual type
-						handler(L, index, expected, type_of(L, index));
-					}
-					return success;
-				}
-			};
-		} // stack_detail
-
-		template <typename T, type expected, typename>
-		struct checker {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				const type indextype = type_of(L, index);
-				bool success = expected == indextype;
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, expected, indextype);
-				}
-				return success;
-			}
-		};
-
-		template<typename T>
-		struct checker<T, type::number, std::enable_if_t<std::is_integral<T>::value>> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				bool success = lua_isinteger(L, index) == 1;
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, type::number, type_of(L, index));
-				}
-				return success;
-			}
-		};
-
-		template<typename T>
-		struct checker<T, type::number, std::enable_if_t<std::is_floating_point<T>::value>> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				bool success = lua_isnumber(L, index) == 1;
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, type::number, type_of(L, index));
-				}
-				return success;
-			}
-		};
-
-		template <type expected, typename C>
-		struct checker<lua_nil_t, expected, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				bool success = lua_isnil(L, index);
-				if (success) {
-					tracking.use(1);
-					return success;
-				}
-				tracking.use(0);
-				success = lua_isnone(L, index);
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, expected, type_of(L, index));
-				}
-				return success;
-			}
-		};
-
-		template <type expected, typename C>
-		struct checker<nullopt_t, expected, C> : checker<lua_nil_t> {};
-
-		template <typename C>
-		struct checker<this_state, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State*, int, Handler&&, record& tracking) {
-				tracking.use(0);
-				return true;
-			}
-		};
-
-		template <typename C>
-		struct checker<this_environment, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State*, int, Handler&&, record& tracking) {
-				tracking.use(0);
-				return true;
-			}
-		};
-
-		template <typename C>
-		struct checker<variadic_args, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State*, int, Handler&&, record& tracking) {
-				tracking.use(0);
-				return true;
-			}
-		};
-
-		template <typename C>
-		struct checker<type, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State*, int, Handler&&, record& tracking) {
-				tracking.use(0);
-				return true;
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<T, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				bool success = !lua_isnone(L, index);
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, type::none, type_of(L, index));
-				}
-				return success;
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<T, type::lightuserdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				type t = type_of(L, index);
-				bool success = t == type::userdata || t == type::lightuserdata;
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, type::lightuserdata, t);
-				}
-				return success;
-			}
-		};
-
-		template <typename C>
-		struct checker<userdata_value, type::userdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				type t = type_of(L, index);
-				bool success = t == type::userdata;
-				if (!success) {
-					// expected type, actual type
-					handler(L, index, type::userdata, t);
-				}
-				return success;
-			}
-		};
-
-		template <typename B, typename C>
-		struct checker<basic_userdata<B>, type::userdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				return stack::check<userdata_value>(L, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<user<T>, type::userdata, C> : checker<user<T>, type::lightuserdata, C> {};
-
-		template <typename T, typename C>
-		struct checker<non_null<T>, type::userdata, C> : checker<T, lua_type_of<T>::value, C> {};
-
-		template <typename C>
-		struct checker<lua_CFunction, type::function, C> : stack_detail::basic_check<type::function, lua_iscfunction> {};
-		template <typename C>
-		struct checker<std::remove_pointer_t<lua_CFunction>, type::function, C> : checker<lua_CFunction, type::function, C> {};
-		template <typename C>
-		struct checker<c_closure, type::function, C> : checker<lua_CFunction, type::function, C> {};
-
-		template <typename T, typename C>
-		struct checker<T, type::function, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				type t = type_of(L, index);
-				if (t == type::lua_nil || t == type::none || t == type::function) {
-					// allow for lua_nil to be returned
-					return true;
-				}
-				if (t != type::userdata && t != type::table) {
-					handler(L, index, type::function, t);
-					return false;
-				}
-				// Do advanced check for call-style userdata?
-				static const auto& callkey = to_string(meta_function::call);
-				if (lua_getmetatable(L, index) == 0) {
-					// No metatable, no __call key possible
-					handler(L, index, type::function, t);
-					return false;
-				}
-				if (lua_isnoneornil(L, -1)) {
-					lua_pop(L, 1);
-					handler(L, index, type::function, t);
-					return false;
-				}
-				lua_getfield(L, -1, &callkey[0]);
-				if (lua_isnoneornil(L, -1)) {
-					lua_pop(L, 2);
-					handler(L, index, type::function, t);
-					return false;
-				}
-				// has call, is definitely a function
-				lua_pop(L, 2);
-				return true;
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<T, type::table, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				type t = type_of(L, index);
-				if (t == type::table) {
-					return true;
-				}
-				if (t != type::userdata) {
-					handler(L, index, type::table, t);
-					return false;
-				}
-				return true;
-			}
-		};
-
-		template <type expected, typename C>
-		struct checker<metatable_t, expected, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				if (lua_getmetatable(L, index) == 0) {
-					return true;
-				}
-				type t = type_of(L, -1);
-				if (t == type::table || t == type::none || t == type::nil) {
-					lua_pop(L, 1);
-					return true;
-				}
-				if (t != type::userdata) {
-					lua_pop(L, 1);
-					handler(L, index, expected, t);
-					return false;
-				}
-				return true;
-			}
-		};
-
-		template <typename C>
-		struct checker<env_t, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				if (lua_getmetatable(L, index) == 0) {
-					return true;
-				}
-				type t = type_of(L, -1);
-				if (t == type::table || t == type::none || t == type::nil) {
-					lua_pop(L, 1);
-					return true;
-				}
-				if (t != type::userdata) {
-					lua_pop(L, 1);
-					handler(L, index, type::table, t);
-					return false;
-				}
-				return true;
-			}
-		};
-
-		template <typename E, typename C>
-		struct checker<basic_environment<E>, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				if (lua_getmetatable(L, index) == 0) {
-					return true;
-				}
-				type t = type_of(L, -1);
-				if (t == type::table || t == type::none || t == type::nil) {
-					lua_pop(L, 1);
-					return true;
-				}
-				if (t != type::userdata) {
-					lua_pop(L, 1);
-					handler(L, index, type::table, t);
-					return false;
-				}
-				return true;
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<detail::as_value_tag<T>, type::userdata, C> {
-			template <typename U, typename Handler>
-			static bool check(types<U>, lua_State* L, type indextype, int index, Handler&& handler, record& tracking) {
-				tracking.use(1);
-				if (indextype != type::userdata) {
-					handler(L, index, type::userdata, indextype);
-					return false;
-				}
-				if (meta::any<std::is_same<T, lightuserdata_value>, std::is_same<T, userdata_value>, std::is_same<T, userdata>, std::is_same<T, lightuserdata>>::value)
-					return true;
-				if (lua_getmetatable(L, index) == 0) {
-					return true;
-				}
-				int metatableindex = lua_gettop(L);
-				if (stack_detail::check_metatable<U>(L, metatableindex))
-					return true;
-				if (stack_detail::check_metatable<U*>(L, metatableindex))
-					return true;
-				if (stack_detail::check_metatable<detail::unique_usertype<U>>(L, metatableindex))
-					return true;
-				bool success = false;
-				if (detail::has_derived<T>::value) {
-					auto pn = stack::pop_n(L, 1);
-					lua_pushstring(L, &detail::base_class_check_key()[0]);
-					lua_rawget(L, metatableindex);
-					if (type_of(L, -1) != type::lua_nil) {
-						void* basecastdata = lua_touserdata(L, -1);
-						detail::inheritance_check_function ic = (detail::inheritance_check_function)basecastdata;
-						success = ic(detail::id_for<T>::value);
-					}
-				}
-				if (!success) {
-					lua_pop(L, 1);
-					handler(L, index, type::userdata, indextype);
-					return false;
-				}
-				lua_pop(L, 1);
-				return true;
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<T, type::userdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				const type indextype = type_of(L, index);
-				return checker<detail::as_value_tag<T>, type::userdata, C>{}.check(types<T>(), L, indextype, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template <typename T, typename C>
-		struct checker<T*, type::userdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				const type indextype = type_of(L, index);
-				// Allow lua_nil to be transformed to nullptr
-				if (indextype == type::lua_nil) {
-					tracking.use(1);
-					return true;
-				}
-				return checker<meta::unqualified_t<T>, type::userdata, C>{}.check(L, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template<typename X>
-		struct checker<X, type::userdata, std::enable_if_t<is_unique_usertype<X>::value>> {
-			typedef typename unique_usertype_traits<X>::type T;
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				const type indextype = type_of(L, index);
-				tracking.use(1);
-				if (indextype != type::userdata) {
-					handler(L, index, type::userdata, indextype);
-					return false;
-				}
-				if (lua_getmetatable(L, index) == 0) {
-					return true;
-				}
-				int metatableindex = lua_gettop(L);
-				if (stack_detail::check_metatable<detail::unique_usertype<T>>(L, metatableindex))
-					return true;
-				lua_pop(L, 1);
-				handler(L, index, type::userdata, indextype);
-				return false;
-			}
-		};
-
-		template<typename T, typename C>
-		struct checker<std::reference_wrapper<T>, type::userdata, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				return checker<T, type::userdata, C>{}.check(L, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template<typename... Args, typename C>
-		struct checker<std::tuple<Args...>, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				return stack::multi_check<Args...>(L, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template<typename A, typename B, typename C>
-		struct checker<std::pair<A, B>, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&& handler, record& tracking) {
-				return stack::multi_check<A, B>(L, index, std::forward<Handler>(handler), tracking);
-			}
-		};
-
-		template<typename T, typename C>
-		struct checker<optional<T>, type::poly, C> {
-			template <typename Handler>
-			static bool check(lua_State* L, int index, Handler&&, record& tracking) {
-				type t = type_of(L, index);
-				if (t == type::none) {
-					tracking.use(0);
-					return true;
-				}
-				if (t == type::lua_nil) {
-					tracking.use(1);
-					return true;
-				}
-				return stack::check<T>(L, index, no_panic, tracking);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_check.hpp
-
-// beginning of sol/stack_get.hpp
-
-// beginning of sol/overload.hpp
-
-namespace sol {
-    template <typename... Functions>
-    struct overload_set {
-        std::tuple<Functions...> functions;
-        template <typename Arg, typename... Args, meta::disable<std::is_same<overload_set, meta::unqualified_t<Arg>>> = meta::enabler>
-        overload_set (Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-        overload_set(const overload_set&) = default;
-        overload_set(overload_set&&) = default;
-        overload_set& operator=(const overload_set&) = default;
-        overload_set& operator=(overload_set&&) = default;
-    };
-
-    template <typename... Args>
-    decltype(auto) overload(Args&&... args) {
-        return overload_set<std::decay_t<Args>...>(std::forward<Args>(args)...);
-    }
-}
-
-// end of sol/overload.hpp
-
-#ifdef SOL_CODECVT_SUPPORT
-#include <codecvt>
-#endif
-
-namespace sol {
-	namespace stack {
-
-		template<typename T, typename>
-		struct getter {
-			static T& get(lua_State* L, int index, record& tracking) {
-				return getter<sol::detail::as_value_tag<T>>{}.get(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<T>(lua_tonumber(L, index));
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_signed<T>>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<T>(lua_tointeger(L, index));
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_unsigned<T>>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<T>(lua_tointeger(L, index));
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<std::is_enum<T>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<T>(lua_tointegerx(L, index, nullptr));
-			}
-		};
-
-		template<typename T>
-		struct getter<as_table_t<T>, std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<T>>::value>> {
-			static T get(lua_State* L, int relindex, record& tracking) {
-				typedef typename T::value_type V;
-				return get(types<V>(), L, relindex, tracking);
-			}
-
-			template <typename V>
-			static T get(types<V>, lua_State* L, int relindex, record& tracking) {
-				tracking.use(1);
-
-				int index = lua_absindex(L, relindex);
-				T arr;
-#if SOL_LUA_VERSION >= 503
-				// This method is HIGHLY performant over regular table iteration thanks to the Lua API changes in 5.3
-				for (lua_Integer i = 0; ; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
-					bool isnil = false;
-					for (int vi = 0; vi < lua_size<V>::value; ++vi) {
-						type t = static_cast<type>(lua_geti(L, index, i + vi));
-						isnil = t == type::lua_nil;
-						if (isnil) {
-							if (i == 0) {
-								break;
-							}
-							lua_pop(L, (vi + 1));
-							return arr;
-						}
-					}
-					if (isnil)
-						continue;
-					arr.push_back(stack::get<V>(L, -lua_size<V>::value));
-				}
-#else
-				// Zzzz slower but necessary thanks to the lower version API and missing functions qq
-				for (lua_Integer i = 0; ; i += lua_size<V>::value, lua_pop(L, lua_size<V>::value)) {
-					bool isnil = false;
-					for (int vi = 0; vi < lua_size<V>::value; ++vi) {
-						lua_pushinteger(L, i);
-						lua_gettable(L, index);
-						type t = type_of(L, -1);
-						isnil = t == type::lua_nil;
-						if (isnil) {
-							if (i == 0) {
-								break;
-							}
-							lua_pop(L, (vi + 1));
-							return arr;
-						}
-					}
-					if (isnil)
-						continue;
-					arr.push_back(stack::get<V>(L, -1));
-				}
-#endif
-				return arr;
-			}
-		};
-
-		template<typename T>
-		struct getter<as_table_t<T>, std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<T>>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				typedef typename T::value_type P;
-				typedef typename P::first_type K;
-				typedef typename P::second_type V;
-				return get(types<K, V>(), L, index, tracking);
-			}
-			
-			template <typename K, typename V>
-			static T get(types<K, V>, lua_State* L, int relindex, record& tracking) {
-				tracking.use(1);
-
-				T associative;
-				int index = lua_absindex(L, relindex);
-				lua_pushnil(L);
-				while (lua_next(L, index) != 0) {
-					decltype(auto) key = stack::check_get<K>(L, -2);
-					if (!key) {
-						lua_pop(L, 1);
-						continue;
-					}
-					associative.emplace(std::forward<decltype(*key)>(*key), stack::get<V>(L, -1));
-					lua_pop(L, 1);
-				}
-				return associative;
-			}
-		};
-
-		template<typename T>
-		struct getter<nested<T>, std::enable_if_t<!is_container<T>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				getter<T> g;
-				// VC++ has a bad warning here: shut it up
-				(void)g;
-				return g.get(L, index, tracking);
-			}
-		};
-		
-		template<typename T>
-		struct getter<nested<T>, std::enable_if_t<meta::all<is_container<T>, meta::neg<meta::has_key_value_pair<meta::unqualified_t<T>>>>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				typedef typename T::value_type V;
-				getter<as_table_t<T>> g;
-				// VC++ has a bad warning here: shut it up
-				(void)g;
-				return g.get(types<nested<V>>(), L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<nested<T>, std::enable_if_t<meta::all<is_container<T>, meta::has_key_value_pair<meta::unqualified_t<T>>>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				typedef typename T::value_type P;
-				typedef typename P::first_type K;
-				typedef typename P::second_type V;
-				getter<as_table_t<T>> g;
-				// VC++ has a bad warning here: shut it up
-				(void)g;
-				return g.get(types<K, nested<V>>(), L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<std::is_base_of<reference, T>::value || std::is_base_of<stack_reference, T>::value>> {
-			static T get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return T(L, index);
-			}
-		};
-
-		template<>
-		struct getter<userdata_value> {
-			static userdata_value get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return userdata_value(lua_touserdata(L, index));
-			}
-		};
-
-		template<>
-		struct getter<lightuserdata_value> {
-			static lightuserdata_value get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return lightuserdata_value(lua_touserdata(L, index));
-			}
-		};
-
-		template<typename T>
-		struct getter<light<T>> {
-			static light<T> get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return light<T>(static_cast<T*>(lua_touserdata(L, index)));
-			}
-		};
-
-		template<typename T>
-		struct getter<user<T>> {
-			static T& get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return *static_cast<T*>(lua_touserdata(L, index));
-			}
-		};
-
-		template<typename T>
-		struct getter<user<T*>> {
-			static T* get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<T*>(lua_touserdata(L, index));
-			}
-		};
-
-		template<>
-		struct getter<type> {
-			static type get(lua_State *L, int index, record& tracking) {
-				tracking.use(1);
-				return static_cast<type>(lua_type(L, index));
-			}
-		};
-
-		template<>
-		struct getter<bool> {
-			static bool get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return lua_toboolean(L, index) != 0;
-			}
-		};
-
-		template<>
-		struct getter<std::string> {
-			static std::string get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				std::size_t len;
-				auto str = lua_tolstring(L, index, &len);
-				return std::string( str, len );
-			}
-		};
-
-		template <>
-		struct getter<string_detail::string_shim> {
-			string_detail::string_shim get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t len;
-				const char* p = lua_tolstring(L, index, &len);
-				return string_detail::string_shim(p, len);
-			}
-		};
-
-		template<>
-		struct getter<const char*> {
-			static const char* get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return lua_tostring(L, index);
-			}
-		};
-		
-		template<>
-		struct getter<char> {
-			static char get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t len;
-				auto str = lua_tolstring(L, index, &len);
-				return len > 0 ? str[0] : '\0';
-			}
-		};
-
-#ifdef SOL_CODECVT_SUPPORT
-		template<>
-		struct getter<std::wstring> {
-			static std::wstring get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t len;
-				auto str = lua_tolstring(L, index, &len);
-				if (len < 1)
-					return std::wstring();
-				if (sizeof(wchar_t) == 2) {
-					static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
-					std::wstring r = convert.from_bytes(str, str + len);
-#if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ < 7
-					// Fuck you, MinGW, and fuck you libstdc++ for introducing this absolutely asinine bug
-					// https://sourceforge.net/p/mingw-w64/bugs/538/
-					// http://chat.stackoverflow.com/transcript/message/32271369#32271369
-					for (auto& c : r) {
-                        uint8_t* b = reinterpret_cast<uint8_t*>(&c);
-						std::swap(b[0], b[1]);
-					}
-#endif 
-					return r;
-				}
-				static std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
-				std::wstring r = convert.from_bytes(str, str + len);
-				return r;
-			}
-		};
-
-		template<>
-		struct getter<std::u16string> {
-			static std::u16string get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t len;
-				auto str = lua_tolstring(L, index, &len);
-				if (len < 1)
-					return std::u16string();
-#ifdef _MSC_VER
-				static std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> convert;
-				auto intd = convert.from_bytes(str, str + len);
-				std::u16string r(intd.size(), '\0');
-				std::memcpy(&r[0], intd.data(), intd.size() * sizeof(char16_t));
-#else
-				static std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-				std::u16string r = convert.from_bytes(str, str + len);
-#endif // VC++ is a shit
-				return r;
-			}
-		};
-
-		template<>
-		struct getter<std::u32string> {
-			static std::u32string get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t len;
-				auto str = lua_tolstring(L, index, &len);
-				if (len < 1)
-					return std::u32string();
-#ifdef _MSC_VER
-				static std::wstring_convert<std::codecvt_utf8<int32_t>, int32_t> convert;
-				auto intd = convert.from_bytes(str, str + len);
-				std::u32string r(intd.size(), '\0');
-				std::memcpy(&r[0], intd.data(), r.size() * sizeof(char32_t));
-#else
-				static std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
-				std::u32string r = convert.from_bytes(str, str + len);
-#endif // VC++ is a shit
-				return r;
-			}
-		};
-
-		template<>
-		struct getter<wchar_t> {
-			static wchar_t get(lua_State* L, int index, record& tracking) {
-				auto str = getter<std::wstring>{}.get(L, index, tracking);
-				return str.size() > 0 ? str[0] : wchar_t(0);
-			}
-		};
-
-		template<>
-		struct getter<char16_t> {
-			static char16_t get(lua_State* L, int index, record& tracking) {
-				auto str = getter<std::u16string>{}.get(L, index, tracking);
-				return str.size() > 0 ? str[0] : char16_t(0);
-			}
-		};
-
-		template<>
-		struct getter<char32_t> {
-			static char32_t get(lua_State* L, int index, record& tracking) {
-				auto str = getter<std::u32string>{}.get(L, index, tracking);
-				return str.size() > 0 ? str[0] : char32_t(0);
-			}
-		};
-#endif // codecvt header support
-
-		template<>
-		struct getter<meta_function> {
-			static meta_function get(lua_State *L, int index, record& tracking) {
-				tracking.use(1);
-				const char* name = getter<const char*>{}.get(L, index, tracking);
-				const auto& mfnames = meta_function_names();
-				for (std::size_t i = 0; i < mfnames.size(); ++i)
-					if (mfnames[i] == name)
-						return static_cast<meta_function>(i);
-				return meta_function::construct;
-			}
-		};
-
-		template<>
-		struct getter<lua_nil_t> {
-			static lua_nil_t get(lua_State*, int, record& tracking) {
-				tracking.use(1);
-				return lua_nil;
-			}
-		};
-
-		template<>
-		struct getter<std::nullptr_t> {
-			static std::nullptr_t get(lua_State*, int, record& tracking) {
-				tracking.use(1);
-				return nullptr;
-			}
-		};
-
-		template<>
-		struct getter<nullopt_t> {
-			static nullopt_t get(lua_State*, int, record& tracking) {
-				tracking.use(1);
-				return nullopt;
-			}
-		};
-
-		template<>
-		struct getter<this_state> {
-			static this_state get(lua_State* L, int, record& tracking) {
-				tracking.use(0);
-				return this_state{ L };
-			}
-		};
-
-		template<>
-		struct getter<lua_CFunction> {
-			static lua_CFunction get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return lua_tocfunction(L, index);
-			}
-		};
-
-		template<>
-		struct getter<c_closure> {
-			static c_closure get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return c_closure(lua_tocfunction(L, index), -1);
-			}
-		};
-
-		template<>
-		struct getter<error> {
-			static error get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				size_t sz = 0;
-				const char* err = lua_tolstring(L, index, &sz);
-				if (err == nullptr) {
-					return error(detail::direct_error, "");
-				}
-				return error(detail::direct_error, std::string(err, sz));
-			}
-		};
-
-		template<>
-		struct getter<void*> {
-			static void* get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return lua_touserdata(L, index);
-			}
-		};
-
-		template<typename T>
-		struct getter<detail::as_value_tag<T>> {
-			static T* get_no_lua_nil(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				void** pudata = static_cast<void**>(lua_touserdata(L, index));
-				void* udata = *pudata;
-				return get_no_lua_nil_from(L, udata, index, tracking);
-			}
-
-			static T* get_no_lua_nil_from(lua_State* L, void* udata, int index, record&) {
-				if (detail::has_derived<T>::value && luaL_getmetafield(L, index, &detail::base_class_cast_key()[0]) != 0) {
-					void* basecastdata = lua_touserdata(L, -1);
-					detail::inheritance_cast_function ic = (detail::inheritance_cast_function)basecastdata;
-					// use the casting function to properly adjust the pointer for the desired T
-					udata = ic(udata, detail::id_for<T>::value);
-					lua_pop(L, 1);
-				}
-				T* obj = static_cast<T*>(udata);
-				return obj;
-			}
-			
-			static T& get(lua_State* L, int index, record& tracking) {
-				return *get_no_lua_nil(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<detail::as_pointer_tag<T>> {
-			static T* get(lua_State* L, int index, record& tracking) {
-				type t = type_of(L, index);
-				if (t == type::lua_nil) {
-					tracking.use(1);
-					return nullptr;
-				}
-				getter<detail::as_value_tag<T>> g;
-				// Avoid VC++ warning
-				(void)g;
-				return g.get_no_lua_nil(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<non_null<T*>> {
-			static T* get(lua_State* L, int index, record& tracking) {
-				getter<detail::as_value_tag<T>> g;
-				// Avoid VC++ warning
-				(void)g;
-				return g.get_no_lua_nil(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<T&> {
-			static T& get(lua_State* L, int index, record& tracking) {
-				getter<detail::as_value_tag<T>> g;
-				// Avoid VC++ warning
-				(void)g;
-				return g.get(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<std::reference_wrapper<T>> {
-			static T& get(lua_State* L, int index, record& tracking) {
-				getter<T&> g;
-				// Avoid VC++ warning
-				(void)g;
-				return g.get(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<T*> {
-			static T* get(lua_State* L, int index, record& tracking) {
-				getter<detail::as_pointer_tag<T>> g;
-				// Avoid VC++ warning
-				(void)g;
-				return g.get(L, index, tracking);
-			}
-		};
-
-		template<typename T>
-		struct getter<T, std::enable_if_t<is_unique_usertype<T>::value>> {
-			typedef typename unique_usertype_traits<T>::type P;
-			typedef typename unique_usertype_traits<T>::actual_type Real;
-
-			static Real& get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				P** pref = static_cast<P**>(lua_touserdata(L, index));
-				detail::special_destruct_func* fx = static_cast<detail::special_destruct_func*>(static_cast<void*>(pref + 1));
-				Real* mem = static_cast<Real*>(static_cast<void*>(fx + 1));
-				return *mem;
-			}
-		};
-
-		template<typename... Args>
-		struct getter<std::tuple<Args...>> {
-			typedef std::tuple<decltype(stack::get<Args>(nullptr, 0))...> R;
-			
-			template <typename... TArgs>
-			static R apply(std::index_sequence<>, lua_State*, int, record&, TArgs&&... args) {
-				// Fuck you too, VC++
-				return R{std::forward<TArgs>(args)...};
-			}
-			
-			template <std::size_t I, std::size_t... Ix, typename... TArgs>
-			static R apply(std::index_sequence<I, Ix...>, lua_State* L, int index, record& tracking, TArgs&&... args) {
-				// Fuck you too, VC++
-				typedef std::tuple_element_t<I, std::tuple<Args...>> T;
-				return apply(std::index_sequence<Ix...>(), L, index, tracking, std::forward<TArgs>(args)..., stack::get<T>(L, index + tracking.used, tracking));
-			}
-
-			static R get(lua_State* L, int index, record& tracking) {
-				return apply(std::make_index_sequence<sizeof...(Args)>(), L, index, tracking);
-			}
-		};
-
-		template<typename A, typename B>
-		struct getter<std::pair<A, B>> {
-			static decltype(auto) get(lua_State* L, int index, record& tracking) {
-				return std::pair<decltype(stack::get<A>(L, index)), decltype(stack::get<B>(L, index))>{stack::get<A>(L, index, tracking), stack::get<B>(L, index + tracking.used, tracking)};
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_get.hpp
-
-// beginning of sol/stack_check_get.hpp
-
-namespace sol {
-	namespace stack {
-		template <typename T, typename>
-		struct check_getter {
-			typedef decltype(stack_detail::unchecked_get<T>(nullptr, 0, std::declval<record&>())) R;
-
-			template <typename Handler>
-			static optional<R> get(lua_State* L, int index, Handler&& handler, record& tracking) {
-				if (!check<T>(L, index, std::forward<Handler>(handler))) {
-					tracking.use(static_cast<int>(!lua_isnone(L, index)));
-					return nullopt;
-				}
-				return stack_detail::unchecked_get<T>(L, index, tracking);
-			}
-		};
-
-		template <typename T>
-		struct check_getter<optional<T>> {
-			template <typename Handler>
-			static decltype(auto) get(lua_State* L, int index, Handler&&, record& tracking) {
-				return check_get<T>(L, index, no_panic, tracking);
-			}
-		};
-
-		template <typename T>
-		struct check_getter<T, std::enable_if_t<std::is_integral<T>::value && lua_type_of<T>::value == type::number>> {
-			template <typename Handler>
-			static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
-				int isnum = 0;
-				lua_Integer value = lua_tointegerx(L, index, &isnum);
-				if (isnum == 0) {
-					type t = type_of(L, index);
-					tracking.use(static_cast<int>(t != type::none));
-					handler(L, index, type::number, t);
-					return nullopt;
-				}
-				tracking.use(1);
-				return static_cast<T>(value);
-			}
-		};
-
-		template <typename T>
-		struct check_getter<T, std::enable_if_t<std::is_enum<T>::value && !meta::any_same<T, meta_function, type>::value>> {
-			template <typename Handler>
-			static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
-				int isnum = 0;
-				lua_Integer value = lua_tointegerx(L, index, &isnum);
-				if (isnum == 0) {
-					type t = type_of(L, index);
-					tracking.use(static_cast<int>(t != type::none));
-					handler(L, index, type::number, t);
-					return nullopt;
-				}
-				tracking.use(1);
-				return static_cast<T>(value);
-			}
-		};
-
-		template <typename T>
-		struct check_getter<T, std::enable_if_t<std::is_floating_point<T>::value>> {
-			template <typename Handler>
-			static optional<T> get(lua_State* L, int index, Handler&& handler, record& tracking) {
-				int isnum = 0;
-				lua_Number value = lua_tonumberx(L, index, &isnum);
-				if (isnum == 0) {
-					type t = type_of(L, index);
-					tracking.use(static_cast<int>(t != type::none));
-					handler(L, index, type::number, t);
-					return nullopt;
-				}
-				tracking.use(1);
-				return static_cast<T>(value);
-			}
-		};
-
-		template <typename T>
-		struct getter<optional<T>> {
-			static decltype(auto) get(lua_State* L, int index, record& tracking) {
-				return check_get<T>(L, index, no_panic, tracking);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_check_get.hpp
-
-// beginning of sol/stack_push.hpp
-
-// beginning of sol/raii.hpp
-
-namespace sol {
-	namespace detail {
-		struct default_construct {
-			template<typename T, typename... Args>
-			static void construct(T&& obj, Args&&... args) {
-				std::allocator<meta::unqualified_t<T>> alloc{};
-				alloc.construct(obj, std::forward<Args>(args)...);
-			}
-
-			template<typename T, typename... Args>
-			void operator()(T&& obj, Args&&... args) const {
-				construct(std::forward<T>(obj), std::forward<Args>(args)...);
-			}
-		};
-
-		struct default_destruct {
-			template<typename T>
-			static void destroy(T&& obj) {
-				std::allocator<meta::unqualified_t<T>> alloc{};
-				alloc.destroy(obj);
-			}
-
-			template<typename T>
-			void operator()(T&& obj) const {
-				destroy(std::forward<T>(obj));
-			}
-		};
-
-		struct deleter {
-			template <typename T>
-			void operator()(T* p) const {
-				delete p;
-			}
-		};
-
-		template <typename T, typename Dx, typename... Args>
-		inline std::unique_ptr<T, Dx> make_unique_deleter(Args&&... args) {
-			return std::unique_ptr<T, Dx>(new T(std::forward<Args>(args)...));
-		}
-
-		template <typename Tag, typename T>
-		struct tagged {
-			T value;
-			template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, tagged>> = meta::enabler>
-			tagged(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-		};
-	} // detail
-
-	template <typename... Args>
-	struct constructor_list {};
-
-	template<typename... Args>
-	using constructors = constructor_list<Args...>;
-
-	const auto default_constructor = constructors<types<>>{};
-
-	struct no_construction {};
-	const auto no_constructor = no_construction{};
-
-	struct call_construction {};
-	const auto call_constructor = call_construction{};
-
-	template <typename... Functions>
-	struct constructor_wrapper {
-		std::tuple<Functions...> functions;
-		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, constructor_wrapper>> = meta::enabler>
-		constructor_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-	};
-
-	template <typename... Functions>
-	inline auto initializers(Functions&&... functions) {
-		return constructor_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
-	}
-
-	template <typename... Functions>
-	struct factory_wrapper {
-		std::tuple<Functions...> functions;
-		template <typename Arg, typename... Args, meta::disable<std::is_same<meta::unqualified_t<Arg>, factory_wrapper>> = meta::enabler>
-		factory_wrapper(Arg&& arg, Args&&... args) : functions(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-	};
-
-	template <typename... Functions>
-	inline auto factories(Functions&&... functions) {
-		return factory_wrapper<std::decay_t<Functions>...>(std::forward<Functions>(functions)...);
-	}
-
-	template <typename Function>
-	struct destructor_wrapper {
-		Function fx;
-		destructor_wrapper(Function f) : fx(std::move(f)) {}
-	};
-
-	template <>
-	struct destructor_wrapper<void> {};
-
-	const destructor_wrapper<void> default_destructor{};
-
-	template <typename Fx>
-	inline auto destructor(Fx&& fx) {
-		return destructor_wrapper<std::decay_t<Fx>>(std::forward<Fx>(fx));
-	}
-
-} // sol
-
-// end of sol/raii.hpp
-
-#ifdef SOL_CODECVT_SUPPORT
-#endif
-
-namespace sol {
-	namespace stack {
-		inline int push_environment_of(lua_State* L, int index = -1) {
-#if SOL_LUA_VERSION < 502
-			// Use lua_setfenv
-			lua_getfenv(L, index);
-			return 1;
-#else
-			// Use upvalues as explained in Lua 5.2 and beyond's manual
-			if (lua_getupvalue(L, index, 1) == nullptr) {
-				push(L, lua_nil);
-				return 1;
-			}
-#endif
-			return 1;
-		}
-
-		template <typename T>
-		int push_environment_of(const T& target) {
-			target.push();
-			return push_environment_of(target.lua_state(), -1) + 1;
-		}
-
-		template <typename T>
-		struct pusher<detail::as_value_tag<T>> {
-			template <typename F, typename... Args>
-			static int push_fx(lua_State* L, F&& f, Args&&... args) {
-				// Basically, we store all user-data like this:
-				// If it's a movable/copyable value (no std::ref(x)), then we store the pointer to the new
-				// data in the first sizeof(T*) bytes, and then however many bytes it takes to
-				// do the actual object. Things that are std::ref or plain T* are stored as 
-				// just the sizeof(T*), and nothing else.
-				T** pointerpointer = static_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
-				T*& referencereference = *pointerpointer;
-				T* allocationtarget = reinterpret_cast<T*>(pointerpointer + 1);
-				referencereference = allocationtarget;
-				std::allocator<T> alloc{};
-				alloc.construct(allocationtarget, std::forward<Args>(args)...);
-				f();
-				return 1;
-			}
-
-			template <typename K, typename... Args>
-			static int push_keyed(lua_State* L, K&& k, Args&&... args) {
-				return push_fx(L, [&L, &k]() {
-					luaL_newmetatable(L, &k[0]);
-					lua_setmetatable(L, -2);
-				}, std::forward<Args>(args)...);
-			}
-
-			template <typename... Args>
-			static int push(lua_State* L, Args&&... args) {
-				return push_keyed(L, usertype_traits<T>::metatable(), std::forward<Args>(args)...);
-			}
-		};
-
-		template <typename T>
-		struct pusher<detail::as_pointer_tag<T>> {
-			template <typename F>
-			static int push_fx(lua_State* L, F&& f, T* obj) {
-				if (obj == nullptr)
-					return stack::push(L, lua_nil);
-				T** pref = static_cast<T**>(lua_newuserdata(L, sizeof(T*)));
-				*pref = obj;
-				f();
-				return 1;
-			}
-
-			template <typename K>
-			static int push_keyed(lua_State* L, K&& k, T* obj) {
-				return push_fx(L, [&L, &k]() {
-					luaL_newmetatable(L, &k[0]);
-					lua_setmetatable(L, -2);
-				}, obj);
-			}
-
-			static int push(lua_State* L, T* obj) {
-				return push_keyed(L, usertype_traits<meta::unqualified_t<T>*>::metatable(), obj);
-			}
-		};
-
-		template <>
-		struct pusher<detail::as_reference_tag> {
-			template <typename T>
-			static int push(lua_State* L, T&& obj) {
-				return stack::push(L, detail::ptr(obj));
-			}
-		};
-
-		template<typename T, typename>
-		struct pusher {
-			template <typename... Args>
-			static int push(lua_State* L, Args&&... args) {
-				return pusher<detail::as_value_tag<T>>{}.push(L, std::forward<Args>(args)...);
-			}
-		};
-		
-		template<typename T>
-		struct pusher<T*, meta::disable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
-			template <typename... Args>
-			static int push(lua_State* L, Args&&... args) {
-				return pusher<detail::as_pointer_tag<T>>{}.push(L, std::forward<Args>(args)...);
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<is_unique_usertype<T>::value>> {
-			typedef typename unique_usertype_traits<T>::type P;
-			typedef typename unique_usertype_traits<T>::actual_type Real;
-
-			template <typename Arg, meta::enable<std::is_base_of<Real, meta::unqualified_t<Arg>>> = meta::enabler>
-			static int push(lua_State* L, Arg&& arg) {
-				return push_deep(L, std::forward<Arg>(arg));
-			}
-
-			template <typename Arg0, typename Arg1, typename... Args>
-			static int push(lua_State* L, Arg0&& arg0, Arg0&& arg1, Args&&... args) {
-				return push_deep(L, std::forward<Arg0>(arg0), std::forward<Arg1>(arg1), std::forward<Args>(args)...);
-			}
-
-			template <typename... Args>
-			static int push_deep(lua_State* L, Args&&... args) {
-				P** pref = static_cast<P**>(lua_newuserdata(L, sizeof(P*) + sizeof(detail::special_destruct_func) + sizeof(Real)));
-				detail::special_destruct_func* fx = static_cast<detail::special_destruct_func*>(static_cast<void*>(pref + 1));
-				Real* mem = static_cast<Real*>(static_cast<void*>(fx + 1));
-				*fx = detail::special_destruct<P, Real>;
-				detail::default_construct::construct(mem, std::forward<Args>(args)...);
-				*pref = unique_usertype_traits<T>::get(*mem);
-				if (luaL_newmetatable(L, &usertype_traits<detail::unique_usertype<P>>::metatable()[0]) == 1) {
-					set_field(L, "__gc", detail::unique_destruct<P>);
-				}
-				lua_setmetatable(L, -2);
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<std::reference_wrapper<T>> {
-			static int push(lua_State* L, const std::reference_wrapper<T>& t) {
-				return stack::push(L, std::addressof(detail::deref(t.get())));
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<std::is_floating_point<T>::value>> {
-			static int push(lua_State* L, const T& value) {
-				lua_pushnumber(L, value);
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_signed<T>>::value>> {
-			static int push(lua_State* L, const T& value) {
-				lua_pushinteger(L, static_cast<lua_Integer>(value));
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<std::is_enum<T>::value>> {
-			static int push(lua_State* L, const T& value) {
-				if (std::is_same<char, T>::value) {
-					return stack::push(L, static_cast<int>(value));
-				}
-				return stack::push(L, static_cast<std::underlying_type_t<T>>(value));
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<meta::all<std::is_integral<T>, std::is_unsigned<T>>::value>> {
-			static int push(lua_State* L, const T& value) {
-				lua_pushinteger(L, static_cast<lua_Integer>(value));
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<as_table_t<T>, std::enable_if_t<!meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>> {
-			static int push(lua_State* L, const as_table_t<T>& tablecont) {
-				auto& cont = detail::deref(detail::unwrap(tablecont.source));
-				lua_createtable(L, static_cast<int>(cont.size()), 0);
-				int tableindex = lua_gettop(L);
-				std::size_t index = 1;
-				for (const auto& i : cont) {
-#if SOL_LUA_VERSION >= 503
-					int p = stack::push(L, i);
-					for (int pi = 0; pi < p; ++pi) {
-						lua_seti(L, tableindex, static_cast<lua_Integer>(index++));
-					}
-#else
-					lua_pushinteger(L, static_cast<lua_Integer>(index));
-					int p = stack::push(L, i);
-					if (p == 1) {
-						++index;
-						lua_settable(L, tableindex);
-					}
-					else {
-						int firstindex = tableindex + 1 + 1;
-						for (int pi = 0; pi < p; ++pi) {
-							stack::push(L, index);
-							lua_pushvalue(L, firstindex);
-							lua_settable(L, tableindex);
-							++index;
-							++firstindex;
-						}
-						lua_pop(L, 1 + p);
-					}
-#endif
-				}
-				// TODO: figure out a better way to do this...?
-				//set_field(L, -1, cont.size());
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<as_table_t<T>, std::enable_if_t<meta::has_key_value_pair<meta::unqualified_t<std::remove_pointer_t<T>>>::value>> {
-			static int push(lua_State* L, const as_table_t<T>& tablecont) {
-				auto& cont = detail::deref(detail::unwrap(tablecont.source));
-				lua_createtable(L, static_cast<int>(cont.size()), 0);
-				int tableindex = lua_gettop(L);
-				for (const auto& pair : cont) {
-					set_field(L, pair.first, pair.second, tableindex);
-				}
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<T, std::enable_if_t<std::is_base_of<reference, T>::value || std::is_base_of<stack_reference, T>::value>> {
-			static int push(lua_State* L, const T& ref) {
-				return ref.push(L);
-			}
-
-			static int push(lua_State* L, T&& ref) {
-				return ref.push(L);
-			}
-		};
-
-		template<>
-		struct pusher<bool> {
-			static int push(lua_State* L, bool b) {
-				lua_pushboolean(L, b);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<lua_nil_t> {
-			static int push(lua_State* L, lua_nil_t) {
-				lua_pushnil(L);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<metatable_t> {
-			static int push(lua_State* L, metatable_t) {
-				lua_pushlstring(L, "__mt", 4);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<std::remove_pointer_t<lua_CFunction>> {
-			static int push(lua_State* L, lua_CFunction func, int n = 0) {
-				lua_pushcclosure(L, func, n);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<lua_CFunction> {
-			static int push(lua_State* L, lua_CFunction func, int n = 0) {
-				lua_pushcclosure(L, func, n);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<c_closure> {
-			static int push(lua_State* L, c_closure cc) {
-				lua_pushcclosure(L, cc.c_function, cc.upvalues);
-				return 1;
-			}
-		};
-
-		template<typename Arg, typename... Args>
-		struct pusher<closure<Arg, Args...>> {
-			template <std::size_t... I, typename T>
-			static int push(std::index_sequence<I...>, lua_State* L, T&& c) {
-				int pushcount = multi_push(L, detail::forward_get<I>(c.upvalues)...);
-				return stack::push(L, c_closure(c.c_function, pushcount));
-			}
-
-			template <typename T>
-			static int push(lua_State* L, T&& c) {
-				return push(std::make_index_sequence<1 + sizeof...(Args)>(), L, std::forward<T>(c));
-			}
-		};
-
-		template<>
-		struct pusher<void*> {
-			static int push(lua_State* L, void* userdata) {
-				lua_pushlightuserdata(L, userdata);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<lightuserdata_value> {
-			static int push(lua_State* L, lightuserdata_value userdata) {
-				lua_pushlightuserdata(L, userdata);
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<light<T>> {
-			static int push(lua_State* L, light<T> l) {
-				lua_pushlightuserdata(L, static_cast<void*>(l.value));
-				return 1;
-			}
-		};
-
-		template<typename T>
-		struct pusher<user<T>> {
-			template <bool with_meta = true, typename Key, typename... Args>
-			static int push_with(lua_State* L, Key&& name, Args&&... args) {
-				// A dumb pusher
-				void* rawdata = lua_newuserdata(L, sizeof(T));
-				T* data = static_cast<T*>(rawdata);
-				std::allocator<T> alloc;
-				alloc.construct(data, std::forward<Args>(args)...);
-				if (with_meta) {
-					lua_CFunction cdel = detail::user_alloc_destroy<T>;
-					// Make sure we have a plain GC set for this data
-					if (luaL_newmetatable(L, name) != 0) {
-						lua_pushcclosure(L, cdel, 0);
-						lua_setfield(L, -2, "__gc");
-					}
-					lua_setmetatable(L, -2);
-				}
-				return 1;
-			}
-
-			template <typename Arg, typename... Args, meta::disable<meta::any_same<meta::unqualified_t<Arg>, no_metatable_t, metatable_t>> = meta::enabler>
-			static int push(lua_State* L, Arg&& arg, Args&&... args) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with(L, name, std::forward<Arg>(arg), std::forward<Args>(args)...);
-			}
-
-			template <typename... Args>
-			static int push(lua_State* L, no_metatable_t, Args&&... args) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with<false>(L, name, std::forward<Args>(args)...);
-			}
-
-			template <typename Key, typename... Args>
-			static int push(lua_State* L, metatable_t, Key&& key, Args&&... args) {
-				const auto name = &key[0];
-				return push_with<true>(L, name, std::forward<Args>(args)...);
-			}
-
-			static int push(lua_State* L, const user<T>& u) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with(L, name, u.value);
-			}
-
-			static int push(lua_State* L, user<T>&& u) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with(L, name, std::move(u.value));
-			}
-
-			static int push(lua_State* L, no_metatable_t, const user<T>& u) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with<false>(L, name, u.value);
-			}
-
-			static int push(lua_State* L, no_metatable_t, user<T>&& u) {
-				const auto name = &usertype_traits<meta::unqualified_t<T>>::user_gc_metatable()[0];
-				return push_with<false>(L, name, std::move(u.value));
-			}
-		};
-
-		template<>
-		struct pusher<userdata_value> {
-			static int push(lua_State* L, userdata_value data) {
-				void** ud = static_cast<void**>(lua_newuserdata(L, sizeof(void*)));
-				*ud = data.value;
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<const char*> {
-			static int push_sized(lua_State* L, const char* str, std::size_t len) {
-				lua_pushlstring(L, str, len);
-				return 1;
-			}
-
-			static int push(lua_State* L, const char* str) {
-				if (str == nullptr)
-					return stack::push(L, lua_nil);
-				return push_sized(L, str, std::char_traits<char>::length(str));
-			}
-
-			static int push(lua_State* L, const char* strb, const char* stre) {
-				return push_sized(L, strb, stre - strb);
-			}
-
-			static int push(lua_State* L, const char* str, std::size_t len) {
-				return push_sized(L, str, len);
-			}
-		};
-
-		template<size_t N>
-		struct pusher<char[N]> {
-			static int push(lua_State* L, const char(&str)[N]) {
-				lua_pushlstring(L, str, N - 1);
-				return 1;
-			}
-
-			static int push(lua_State* L, const char(&str)[N], std::size_t sz) {
-				lua_pushlstring(L, str, sz);
-				return 1;
-			}
-		};
-
-		template <>
-		struct pusher<char> {
-			static int push(lua_State* L, char c) {
-				const char str[2] = { c, '\0' };
-				return stack::push(L, str, 1);
-			}
-		};
-
-		template<>
-		struct pusher<std::string> {
-			static int push(lua_State* L, const std::string& str) {
-				lua_pushlstring(L, str.c_str(), str.size());
-				return 1;
-			}
-
-			static int push(lua_State* L, const std::string& str, std::size_t sz) {
-				lua_pushlstring(L, str.c_str(), sz);
-				return 1;
-			}
-		};
-
-		template<>
-		struct pusher<meta_function> {
-			static int push(lua_State* L, meta_function m) {
-				const std::string& str = to_string(m);
-				lua_pushlstring(L, str.c_str(), str.size());
-				return 1;
-			}
-		};
-
-#ifdef SOL_CODECVT_SUPPORT
-		template<>
-		struct pusher<const wchar_t*> {
-			static int push(lua_State* L, const wchar_t* wstr) {
-				return push(L, wstr, std::char_traits<wchar_t>::length(wstr));
-			}
-
-			static int push(lua_State* L, const wchar_t* wstr, std::size_t sz) {
-				return push(L, wstr, wstr + sz);
-			}
-
-			static int push(lua_State* L, const wchar_t* strb, const wchar_t* stre) {
-				if (sizeof(wchar_t) == 2) {
-					static std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> convert;
-					std::string u8str = convert.to_bytes(strb, stre);
-					return stack::push(L, u8str);
-				}
-				static std::wstring_convert<std::codecvt_utf8<wchar_t>> convert;
-				std::string u8str = convert.to_bytes(strb, stre);
-				return stack::push(L, u8str);
-			}
-		};
-
-		template<>
-		struct pusher<const char16_t*> {
-			static int push(lua_State* L, const char16_t* u16str) {
-				return push(L, u16str, std::char_traits<char16_t>::length(u16str));
-			}
-
-			static int push(lua_State* L, const char16_t* u16str, std::size_t sz) {
-				return push(L, u16str, u16str + sz);
-			}
-
-			static int push(lua_State* L, const char16_t* strb, const char16_t* stre) {
-#ifdef _MSC_VER
-				static std::wstring_convert<std::codecvt_utf8_utf16<int16_t>, int16_t> convert;
-				std::string u8str = convert.to_bytes(reinterpret_cast<const int16_t*>(strb), reinterpret_cast<const int16_t*>(stre));
-#else
-				static std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-				std::string u8str = convert.to_bytes(strb, stre);
-#endif // VC++ is a shit
-				return stack::push(L, u8str);
-			}
-		};
-
-		template<>
-		struct pusher<const char32_t*> {
-			static int push(lua_State* L, const char32_t* u32str) {
-				return push(L, u32str, u32str + std::char_traits<char32_t>::length(u32str));
-			}
-
-			static int push(lua_State* L, const char32_t* u32str, std::size_t sz) {
-				return push(L, u32str, u32str + sz);
-			}
-
-			static int push(lua_State* L, const char32_t* strb, const char32_t* stre) {
-#ifdef _MSC_VER
-				static std::wstring_convert<std::codecvt_utf8<int32_t>, int32_t> convert;
-				std::string u8str = convert.to_bytes(reinterpret_cast<const int32_t*>(strb), reinterpret_cast<const int32_t*>(stre));
-#else
-				static std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
-				std::string u8str = convert.to_bytes(strb, stre);
-#endif // VC++ is a shit
-				return stack::push(L, u8str);
-			}
-		};
-
-		template<size_t N>
-		struct pusher<wchar_t[N]> {
-			static int push(lua_State* L, const wchar_t(&str)[N]) {
-				return push(L, str, N - 1);
-			}
-
-			static int push(lua_State* L, const wchar_t(&str)[N], std::size_t sz) {
-				return stack::push<const wchar_t*>(L, str, str + sz);
-			}
-		};
-
-		template<size_t N>
-		struct pusher<char16_t[N]> {
-			static int push(lua_State* L, const char16_t(&str)[N]) {
-				return push(L, str, N - 1);
-			}
-
-			static int push(lua_State* L, const char16_t(&str)[N], std::size_t sz) {
-				return stack::push<const char16_t*>(L, str, str + sz);
-			}
-		};
-
-		template<size_t N>
-		struct pusher<char32_t[N]> {
-			static int push(lua_State* L, const char32_t(&str)[N]) {
-				return push(L, str, N - 1);
-			}
-
-			static int push(lua_State* L, const char32_t(&str)[N], std::size_t sz) {
-				return stack::push<const char32_t*>(L, str, str + sz);
-			}
-		};
-
-		template <>
-		struct pusher<wchar_t> {
-			static int push(lua_State* L, wchar_t c) {
-				const wchar_t str[2] = { c, '\0' };
-				return stack::push(L, str, 1);
-			}
-		};
-
-		template <>
-		struct pusher<char16_t> {
-			static int push(lua_State* L, char16_t c) {
-				const char16_t str[2] = { c, '\0' };
-				return stack::push(L, str, 1);
-			}
-		};
-
-		template <>
-		struct pusher<char32_t> {
-			static int push(lua_State* L, char32_t c) {
-				const char32_t str[2] = { c, '\0' };
-				return stack::push(L, str, 1);
-			}
-		};
-
-		template<>
-		struct pusher<std::wstring> {
-			static int push(lua_State* L, const std::wstring& wstr) {
-				return push(L, wstr.data(), wstr.size());
-			}
-
-			static int push(lua_State* L, const std::wstring& wstr, std::size_t sz) {
-				return stack::push(L, wstr.data(), wstr.data() + sz);
-			}
-		};
-
-		template<>
-		struct pusher<std::u16string> {
-			static int push(lua_State* L, const std::u16string& u16str) {
-				return push(L, u16str, u16str.size());
-			}
-			
-			static int push(lua_State* L, const std::u16string& u16str, std::size_t sz) {
-				return stack::push(L, u16str.data(), u16str.data() + sz);
-			}
-		};
-
-		template<>
-		struct pusher<std::u32string> {
-			static int push(lua_State* L, const std::u32string& u32str) {
-				return push(L, u32str, u32str.size());
-			}
-
-			static int push(lua_State* L, const std::u32string& u32str, std::size_t sz) {
-				return stack::push(L, u32str.data(), u32str.data() + sz);
-			}
-		};
-#endif // codecvt Header Support
-
-		template<typename... Args>
-		struct pusher<std::tuple<Args...>> {
-			template <std::size_t... I, typename T>
-			static int push(std::index_sequence<I...>, lua_State* L, T&& t) {
-				int pushcount = 0;
-				(void)detail::swallow{ 0, (pushcount += stack::push(L,
-					  detail::forward_get<I>(t)
-				), 0)... };
-				return pushcount;
-			}
-
-			template <typename T>
-			static int push(lua_State* L, T&& t) {
-				return push(std::index_sequence_for<Args...>(), L, std::forward<T>(t));
-			}
-		};
-
-		template<typename A, typename B>
-		struct pusher<std::pair<A, B>> {
-			template <typename T>
-			static int push(lua_State* L, T&& t) {
-				int pushcount = stack::push(L, detail::forward_get<0>(t));
-				pushcount += stack::push(L, detail::forward_get<1>(t));
-				return pushcount;
-			}
-		};
-
-		template<typename O>
-		struct pusher<optional<O>> {
-			template <typename T>
-			static int push(lua_State* L, T&& t) {
-				if (t == nullopt) {
-					return stack::push(L, nullopt);
-				}
-				return stack::push(L, t.value());
-			}
-		};
-
-		template<>
-		struct pusher<nullopt_t> {
-			static int push(lua_State* L, nullopt_t) {
-				return stack::push(L, lua_nil);
-			}
-		};
-
-		template<>
-		struct pusher<std::nullptr_t> {
-			static int push(lua_State* L, std::nullptr_t) {
-				return stack::push(L, lua_nil);
-			}
-		};
-
-		template<>
-		struct pusher<this_state> {
-			static int push(lua_State*, const this_state&) {
-				return 0;
-			}
-		};
-
-		template<>
-		struct pusher<new_table> {
-			static int push(lua_State* L, const new_table& nt) {
-				lua_createtable(L, nt.sequence_hint, nt.map_hint);
-				return 1;
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_push.hpp
-
-// beginning of sol/stack_pop.hpp
-
-namespace sol {
-	namespace stack {
-		template <typename T, typename>
-		struct popper {
-			inline static decltype(auto) pop(lua_State* L) {
-				record tracking{};
-				decltype(auto) r = get<T>(L, -lua_size<T>::value, tracking);
-				lua_pop(L, tracking.used);
-				return r;
-			}
-		};
-
-		template <typename T>
-		struct popper<T, std::enable_if_t<std::is_base_of<stack_reference, meta::unqualified_t<T>>::value>> {
-			static_assert(meta::neg<std::is_base_of<stack_reference, meta::unqualified_t<T>>>::value, "You cannot pop something that derives from stack_reference: it will not remain on the stack and thusly will go out of scope!");
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_pop.hpp
-
-// beginning of sol/stack_field.hpp
-
-namespace sol {
-	namespace stack {
-		template <typename T, bool, bool, typename>
-		struct field_getter {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int tableindex = -2) {
-				push(L, std::forward<Key>(key));
-				lua_gettable(L, tableindex);
-			}
-		};
-
-		template <typename T, bool global, typename C>
-		struct field_getter<T, global, true, C> {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int tableindex = -2) {
-				push(L, std::forward<Key>(key));
-				lua_rawget(L, tableindex);
-			}
-		};
-
-		template <bool b, bool raw, typename C>
-		struct field_getter<metatable_t, b, raw, C> {
-			void get(lua_State* L, metatable_t, int tableindex = -1) {
-				if (lua_getmetatable(L, tableindex) == 0)
-					push(L, lua_nil);
-			}
-		};
-
-		template <bool b, bool raw, typename C>
-		struct field_getter<env_t, b, raw, C> {
-			void get(lua_State* L, env_t, int tableindex = -1) {
-#if SOL_LUA_VERSION < 502
-				// Use lua_setfenv
-				lua_getfenv(L, tableindex);
-#else
-				// Use upvalues as explained in Lua 5.2 and beyond's manual
-				if (lua_getupvalue(L, tableindex, 1) == nullptr) {
-					push(L, lua_nil);
-				}
-#endif
-			}
-		};
-
-		template <typename T, bool raw>
-		struct field_getter<T, true, raw, std::enable_if_t<meta::is_c_str<T>::value>> {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int = -1) {
-				lua_getglobal(L, &key[0]);
-			}
-		};
-
-		template <typename T>
-		struct field_getter<T, false, false, std::enable_if_t<meta::is_c_str<T>::value>> {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int tableindex = -1) {
-				lua_getfield(L, tableindex, &key[0]);
-			}
-		};
-
-#if SOL_LUA_VERSION >= 503
-		template <typename T>
-		struct field_getter<T, false, false, std::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>> {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int tableindex = -1) {
-				lua_geti(L, tableindex, static_cast<lua_Integer>(key));
-			}
-		};
-#endif // Lua 5.3.x
-
-#if SOL_LUA_VERSION >= 502
-		template <typename C>
-		struct field_getter<void*, false, true, C> {
-			void get(lua_State* L, void* key, int tableindex = -1) {
-				lua_rawgetp(L, tableindex, key);
-			}
-		};
-#endif // Lua 5.3.x
-
-		template <typename T>
-		struct field_getter<T, false, true, std::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>> {
-			template <typename Key>
-			void get(lua_State* L, Key&& key, int tableindex = -1) {
-				lua_rawgeti(L, tableindex, static_cast<lua_Integer>(key));
-			}
-		};
-
-		template <typename... Args, bool b, bool raw, typename C>
-		struct field_getter<std::tuple<Args...>, b, raw, C> {
-			template <std::size_t... I, typename Keys>
-			void apply(std::index_sequence<0, I...>, lua_State* L, Keys&& keys, int tableindex) {
-				get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
-				void(detail::swallow{ (get_field<false, raw>(L, detail::forward_get<I>(keys)), 0)... });
-				reference saved(L, -1);
-				lua_pop(L, static_cast<int>(sizeof...(I)));
-				saved.push();
-			}
-
-			template <typename Keys>
-			void get(lua_State* L, Keys&& keys) {
-				apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), lua_absindex(L, -1));
-			}
-
-			template <typename Keys>
-			void get(lua_State* L, Keys&& keys, int tableindex) {
-				apply(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), tableindex);
-			}
-		};
-
-		template <typename A, typename B, bool b, bool raw, typename C>
-		struct field_getter<std::pair<A, B>, b, raw, C> {
-			template <typename Keys>
-			void get(lua_State* L, Keys&& keys, int tableindex) {
-				get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
-				get_field<false, raw>(L, detail::forward_get<1>(keys));
-				reference saved(L, -1);
-				lua_pop(L, static_cast<int>(2));
-				saved.push();
-			}
-
-			template <typename Keys>
-			void get(lua_State* L, Keys&& keys) {
-				get_field<b, raw>(L, detail::forward_get<0>(keys));
-				get_field<false, raw>(L, detail::forward_get<1>(keys));
-				reference saved(L, -1);
-				lua_pop(L, static_cast<int>(2));
-				saved.push();
-			}
-		};
-
-		template <typename T, bool, bool, typename>
-		struct field_setter {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int tableindex = -3) {
-				push(L, std::forward<Key>(key));
-				push(L, std::forward<Value>(value));
-				lua_settable(L, tableindex);
-			}
-		};
-
-		template <typename T, bool b, typename C>
-		struct field_setter<T, b, true, C> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int tableindex = -3) {
-				push(L, std::forward<Key>(key));
-				push(L, std::forward<Value>(value));
-				lua_rawset(L, tableindex);
-			}
-		};
-
-		template <bool b, bool raw, typename C>
-		struct field_setter<metatable_t, b, raw, C> {
-			template <typename Value>
-			void set(lua_State* L, metatable_t, Value&& value, int tableindex = -2) {
-				push(L, std::forward<Value>(value));
-				lua_setmetatable(L, tableindex);
-			}
-		};
-
-		template <typename T, bool raw>
-		struct field_setter<T, true, raw, std::enable_if_t<meta::is_c_str<T>::value>> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int = -2) {
-				push(L, std::forward<Value>(value));
-				lua_setglobal(L, &key[0]);
-			}
-		};
-
-		template <typename T>
-		struct field_setter<T, false, false, std::enable_if_t<meta::is_c_str<T>::value>> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
-				push(L, std::forward<Value>(value));
-				lua_setfield(L, tableindex, &key[0]);
-			}
-		};
-
-#if SOL_LUA_VERSION >= 503
-		template <typename T>
-		struct field_setter<T, false, false, std::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
-				push(L, std::forward<Value>(value));
-				lua_seti(L, tableindex, static_cast<lua_Integer>(key));
-			}
-		};
-#endif // Lua 5.3.x
-
-		template <typename T>
-		struct field_setter<T, false, true, std::enable_if_t<std::is_integral<T>::value && !std::is_same<bool, T>::value>> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, Key&& key, Value&& value, int tableindex = -2) {
-				push(L, std::forward<Value>(value));
-				lua_rawseti(L, tableindex, static_cast<lua_Integer>(key));
-			}
-		};
-
-#if SOL_LUA_VERSION >= 502
-		template <typename C>
-		struct field_setter<void*, false, true, C> {
-			template <typename Key, typename Value>
-			void set(lua_State* L, void* key, Value&& value, int tableindex = -2) {
-				push(L, std::forward<Value>(value));
-				lua_rawsetp(L, tableindex, key);
-			}
-		};
-#endif // Lua 5.2.x
-
-		template <typename... Args, bool b, bool raw, typename C>
-		struct field_setter<std::tuple<Args...>, b, raw, C> {
-			template <bool g, std::size_t I, typename Key, typename Value>
-			void apply(std::index_sequence<I>, lua_State* L, Key&& keys, Value&& value, int tableindex) {
-				I < 1 ?
-					set_field<g, raw>(L, detail::forward_get<I>(keys), std::forward<Value>(value), tableindex) :
-					set_field<g, raw>(L, detail::forward_get<I>(keys), std::forward<Value>(value));
-			}
-
-			template <bool g, std::size_t I0, std::size_t I1, std::size_t... I, typename Keys, typename Value>
-			void apply(std::index_sequence<I0, I1, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
-				I0 < 1 ? get_field<g, raw>(L, detail::forward_get<I0>(keys), tableindex) : get_field<g, raw>(L, detail::forward_get<I0>(keys), -1);
-				apply<false>(std::index_sequence<I1, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), -1);
-			}
-
-			template <bool g, std::size_t I0, std::size_t... I, typename Keys, typename Value>
-			void top_apply(std::index_sequence<I0, I...>, lua_State* L, Keys&& keys, Value&& value, int tableindex) {
-				apply<g>(std::index_sequence<I0, I...>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
-				lua_pop(L, static_cast<int>(sizeof...(I)));
-			}
-
-			template <typename Keys, typename Value>
-			void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -3) {
-				top_apply<b>(std::make_index_sequence<sizeof...(Args)>(), L, std::forward<Keys>(keys), std::forward<Value>(value), tableindex);
-			}
-		};
-
-		template <typename A, typename B, bool b, bool raw, typename C>
-		struct field_setter<std::pair<A, B>, b, raw, C> {
-			template <typename Keys, typename Value>
-			void set(lua_State* L, Keys&& keys, Value&& value, int tableindex = -1) {
-				get_field<b, raw>(L, detail::forward_get<0>(keys), tableindex);
-				set_field<false, raw>(L, detail::forward_get<1>(keys), std::forward<Value>(value));
-				lua_pop(L, 1);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_field.hpp
-
-// beginning of sol/stack_probe.hpp
-
-namespace sol {
-	namespace stack {
-		template <typename T, bool b, bool raw, typename>
-		struct probe_field_getter {
-			template <typename Key>
-			probe get(lua_State* L, Key&& key, int tableindex = -2) {
-				if (!b && !maybe_indexable(L, tableindex)) {
-					return probe(false, 0);
-				}
-				get_field<b, raw>(L, std::forward<Key>(key), tableindex);
-				return probe(!check<lua_nil_t>(L), 1);
-			}
-		};
-
-		template <typename A, typename B, bool b, bool raw, typename C>
-		struct probe_field_getter<std::pair<A, B>, b, raw, C> {
-			template <typename Keys>
-			probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
-				if (!b && !maybe_indexable(L, tableindex)) {
-					return probe(false, 0);
-				}
-				get_field<b, raw>(L, std::get<0>(keys), tableindex);
-				if (!maybe_indexable(L)) {
-					return probe(false, 1);
-				}
-				get_field<false, raw>(L, std::get<1>(keys), tableindex);
-				return probe(!check<lua_nil_t>(L), 2);
-			}
-		};
-
-		template <typename... Args, bool b, bool raw, typename C>
-		struct probe_field_getter<std::tuple<Args...>, b, raw, C> {
-			template <std::size_t I, typename Keys>
-			probe apply(std::index_sequence<I>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
-				get_field < I < 1 && b, raw>(L, std::get<I>(keys), tableindex);
-				return probe(!check<lua_nil_t>(L), sofar);
-			}
-
-			template <std::size_t I, std::size_t I1, std::size_t... In, typename Keys>
-			probe apply(std::index_sequence<I, I1, In...>, int sofar, lua_State* L, Keys&& keys, int tableindex) {
-				get_field < I < 1 && b, raw>(L, std::get<I>(keys), tableindex);
-				if (!maybe_indexable(L)) {
-					return probe(false, sofar);
-				}
-				return apply(std::index_sequence<I1, In...>(), sofar + 1, L, std::forward<Keys>(keys), -1);
-			}
-
-			template <typename Keys>
-			probe get(lua_State* L, Keys&& keys, int tableindex = -2) {
-				if (!b && !maybe_indexable(L, tableindex)) {
-					return probe(false, 0);
-				}
-				return apply(std::index_sequence_for<Args...>(), 1, L, std::forward<Keys>(keys), tableindex);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/stack_probe.hpp
-
-#include <cstring>
-
-namespace sol {
-	namespace stack {
-		namespace stack_detail {
-			template<typename T>
-			inline int push_as_upvalues(lua_State* L, T& item) {
-				typedef std::decay_t<T> TValue;
-				const static std::size_t itemsize = sizeof(TValue);
-				const static std::size_t voidsize = sizeof(void*);
-				const static std::size_t voidsizem1 = voidsize - 1;
-				const static std::size_t data_t_count = (sizeof(TValue) + voidsizem1) / voidsize;
-				typedef std::array<void*, data_t_count> data_t;
-
-				data_t data{ {} };
-				std::memcpy(&data[0], std::addressof(item), itemsize);
-				int pushcount = 0;
-				for (auto&& v : data) {
-					pushcount += push(L, lightuserdata_value(v));
-				}
-				return pushcount;
-			}
-
-			template<typename T>
-			inline std::pair<T, int> get_as_upvalues(lua_State* L, int index = 2) {
-				const static std::size_t data_t_count = (sizeof(T) + (sizeof(void*) - 1)) / sizeof(void*);
-				typedef std::array<void*, data_t_count> data_t;
-				data_t voiddata{ {} };
-				for (std::size_t i = 0, d = 0; d < sizeof(T); ++i, d += sizeof(void*)) {
-					voiddata[i] = get<lightuserdata_value>(L, upvalue_index(index++));
-				}
-				return std::pair<T, int>(*reinterpret_cast<T*>(static_cast<void*>(voiddata.data())), index);
-			}
-
-			struct evaluator {
-				template <typename Fx, typename... Args>
-				static decltype(auto) eval(types<>, std::index_sequence<>, lua_State*, int, record&, Fx&& fx, Args&&... args) {
-					return std::forward<Fx>(fx)(std::forward<Args>(args)...);
-				}
-				
-				template <typename Fx, typename Arg, typename... Args, std::size_t I, std::size_t... Is, typename... FxArgs>
-				static decltype(auto) eval(types<Arg, Args...>, std::index_sequence<I, Is...>, lua_State* L, int start, record& tracking, Fx&& fx, FxArgs&&... fxargs) {
-					return eval(types<Args...>(), std::index_sequence<Is...>(), L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)..., stack_detail::unchecked_get<Arg>(L, start + tracking.used, tracking));
-				}
-			};
-
-			template <bool checkargs = default_check_arguments, std::size_t... I, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-			inline decltype(auto) call(types<R>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-#ifndef _MSC_VER
-				static_assert(meta::all<meta::is_not_move_only<Args>...>::value, "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");
-#endif // This compiler make me so fucking sad
-				multi_check<checkargs, Args...>(L, start, type_panic);
-				record tracking{};
-				return evaluator{}.eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-			}
-
-			template <bool checkargs = default_check_arguments, std::size_t... I, typename... Args, typename Fx, typename... FxArgs>
-			inline void call(types<void>, types<Args...> ta, std::index_sequence<I...> tai, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-#ifndef _MSC_VER
-				static_assert(meta::all<meta::is_not_move_only<Args>...>::value, "One of the arguments being bound is a move-only type, and it is not being taken by reference: this will break your code. Please take a reference and std::move it manually if this was your intention.");
-#endif // This compiler make me so fucking sad
-				multi_check<checkargs, Args...>(L, start, type_panic);
-				record tracking{};
-				evaluator{}.eval(ta, tai, L, start, tracking, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-			}
-		} // stack_detail
-
-		template <typename T>
-		int set_ref(lua_State* L, T&& arg, int tableindex = -2) {
-			push(L, std::forward<T>(arg));
-			return luaL_ref(L, tableindex);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-			typedef std::make_index_sequence<sizeof...(Args)> args_indices;
-			return stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-		inline decltype(auto) call(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-			return call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-		inline void call(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... args) {
-			typedef std::make_index_sequence<sizeof...(Args)> args_indices;
-			stack_detail::call<check_args>(tr, ta, args_indices(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-		inline void call(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-			call<check_args>(tr, ta, L, 1, std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename R, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
-		inline decltype(auto) call_from_top(types<R> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-			return call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template <bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-		inline void call_from_top(types<void> tr, types<Args...> ta, lua_State* L, Fx&& fx, FxArgs&&... args) {
-			call<check_args>(tr, ta, L, static_cast<int>(lua_gettop(L) - sizeof...(Args)), std::forward<Fx>(fx), std::forward<FxArgs>(args)...);
-		}
-
-		template<bool check_args = stack_detail::default_check_arguments, typename... Args, typename Fx, typename... FxArgs>
-		inline int call_into_lua(types<void> tr, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
-			call<check_args>(tr, ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
-			lua_settop(L, 0);
-			return 0;
-		}
-
-		template<bool check_args = stack_detail::default_check_arguments, typename Ret0, typename... Ret, typename... Args, typename Fx, typename... FxArgs, typename = std::enable_if_t<meta::neg<std::is_void<Ret0>>::value>>
-		inline int call_into_lua(types<Ret0, Ret...>, types<Args...> ta, lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
-			decltype(auto) r = call<check_args>(types<meta::return_type_t<Ret0, Ret...>>(), ta, L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
-			lua_settop(L, 0);
-			return push_reference(L, std::forward<decltype(r)>(r));
-		}
-
-		template<bool check_args = stack_detail::default_check_arguments, typename Fx, typename... FxArgs>
-		inline int call_lua(lua_State* L, int start, Fx&& fx, FxArgs&&... fxargs) {
-			typedef lua_bind_traits<meta::unqualified_t<Fx>> traits_type;
-			typedef typename traits_type::args_list args_list;
-			typedef typename traits_type::returns_list returns_list;
-			return call_into_lua(returns_list(), args_list(), L, start, std::forward<Fx>(fx), std::forward<FxArgs>(fxargs)...);
-		}
-
-		inline call_syntax get_call_syntax(lua_State* L, const std::string& key, int index) {
-			if (lua_gettop(L) == 0) {
-				return call_syntax::dot;
-			}
-			luaL_getmetatable(L, key.c_str());
-			auto pn = pop_n(L, 1);
-			if (lua_compare(L, -1, index, LUA_OPEQ) != 1) {
-				return call_syntax::dot;
-			}
-			return call_syntax::colon;
-		}
-
-		inline void script(lua_State* L, const std::string& code) {
-			if (luaL_dostring(L, code.c_str())) {
-				lua_error(L);
-			}
-		}
-
-		inline void script_file(lua_State* L, const std::string& filename) {
-			if (luaL_dofile(L, filename.c_str())) {
-				lua_error(L);
-			}
-		}
-
-		inline void luajit_exception_handler(lua_State* L, int(*handler)(lua_State*, lua_CFunction) = detail::c_trampoline) {
-#ifdef SOL_LUAJIT
-			lua_pushlightuserdata(L, (void*)handler);
-			auto pn = pop_n(L, 1);
-			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_ON);
-#else
-			(void)L;
-			(void)handler;
-#endif
-		}
-
-		inline void luajit_exception_off(lua_State* L) {
-#ifdef SOL_LUAJIT
-			luaJIT_setmode(L, -1, LUAJIT_MODE_WRAPCFUNC | LUAJIT_MODE_OFF);
-#else
-			(void)L;
-#endif
-		}
-	} // stack
-} // sol
-
-// end of sol/stack.hpp
-
-// beginning of sol/object_base.hpp
-
-namespace sol {
-
-	template <typename base_t>
-	class basic_object_base : public base_t {
-	private:
-		template<typename T>
-		decltype(auto) as_stack(std::true_type) const {
-			return stack::get<T>(base_t::lua_state(), base_t::stack_index());
-		}
-
-		template<typename T>
-		decltype(auto) as_stack(std::false_type) const {
-			base_t::push();
-			return stack::pop<T>(base_t::lua_state());
-		}
-
-		template<typename T>
-		bool is_stack(std::true_type) const {
-			return stack::check<T>(base_t::lua_state(), base_t::stack_index(), no_panic);
-		}
-
-		template<typename T>
-		bool is_stack(std::false_type) const {
-			int r = base_t::registry_index();
-			if (r == LUA_REFNIL)
-				return meta::any_same<meta::unqualified_t<T>, lua_nil_t, nullopt_t, std::nullptr_t>::value ? true : false;
-			if (r == LUA_NOREF)
-				return false;
-			auto pp = stack::push_pop(*this);
-			return stack::check<T>(base_t::lua_state(), -1, no_panic);
-		}
-
-	public:
-		basic_object_base() noexcept = default;
-		basic_object_base(const basic_object_base&) = default;
-		basic_object_base(basic_object_base&&) = default;
-		basic_object_base& operator=(const basic_object_base&) = default;
-		basic_object_base& operator=(basic_object_base&&) = default;
-		template <typename T, typename... Args, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object_base>>> = meta::enabler>
-		basic_object_base(T&& arg, Args&&... args) : base_t(std::forward<T>(arg), std::forward<Args>(args)...) { }
-
-		template<typename T>
-		decltype(auto) as() const {
-			return as_stack<T>(std::is_same<base_t, stack_reference>());
-		}
-
-		template<typename T>
-		bool is() const {
-			return is_stack<T>(std::is_same<base_t, stack_reference>());
-		}
-	};
-} // sol
-
-// end of sol/object_base.hpp
-
-// beginning of sol/userdata.hpp
-
-namespace sol {
-	template <typename base_type>
-	class basic_userdata : public basic_table<base_type> {
-		typedef basic_table<base_type> base_t;
-	public:
-		basic_userdata() noexcept = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_userdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_userdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_userdata<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				type_assert(base_t::lua_state(), -1, type::userdata);
-			}
-#endif // Safety
-		}
-		basic_userdata(const basic_userdata&) = default;
-		basic_userdata(basic_userdata&&) = default;
-		basic_userdata& operator=(const basic_userdata&) = default;
-		basic_userdata& operator=(basic_userdata&&) = default;
-		basic_userdata(const stack_reference& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
-		basic_userdata(stack_reference&& r) : basic_userdata(r.lua_state(), r.stack_index()) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
-		basic_userdata(lua_State* L, T&& r) : basic_userdata(L, sol::ref_index(r.registry_index())) {}
-		basic_userdata(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_userdata>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_userdata(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_userdata>(L, index, type_panic);
-#endif // Safety
-		}
-	};
-
-	template <typename base_type>
-	class basic_lightuserdata : public basic_object_base<base_type> {
-		typedef basic_object_base<base_type> base_t;
-	public:
-		basic_lightuserdata() noexcept = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_lightuserdata>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_lightuserdata(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_lightuserdata<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				type_assert(base_t::lua_state(), -1, type::lightuserdata);
-			}
-#endif // Safety
-		}
-		basic_lightuserdata(const basic_lightuserdata&) = default;
-		basic_lightuserdata(basic_lightuserdata&&) = default;
-		basic_lightuserdata& operator=(const basic_lightuserdata&) = default;
-		basic_lightuserdata& operator=(basic_lightuserdata&&) = default;
-		basic_lightuserdata(const stack_reference& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
-		basic_lightuserdata(stack_reference&& r) : basic_lightuserdata(r.lua_state(), r.stack_index()) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
-		basic_lightuserdata(lua_State* L, T&& r) : basic_lightuserdata(L, sol::ref_index(r.registry_index())) {}
-		basic_lightuserdata(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_lightuserdata>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_lightuserdata(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_lightuserdata>(L, index, type_panic);
-#endif // Safety
-		}
-	};
-
-} // sol
-
-// end of sol/userdata.hpp
-
-// beginning of sol/as_args.hpp
-
-namespace sol {
-	template <typename T>
-	struct to_args_t {
-		T src;
-	};
-
-	template <typename Source>
-	auto as_args(Source&& source) {
-		return to_args_t<Source>{ std::forward<Source>(source) };
-	}
-
-	namespace stack {
-		template <typename T>
-		struct pusher<to_args_t<T>> {
-			int push(lua_State* L, const to_args_t<T>& e) {
-				int p = 0;
-				for (const auto& i : e.src) {
-					p += stack::push(L, i);
-				}
-				return p;
-			}
-		};
-	}
-} // sol
-
-// end of sol/as_args.hpp
-
-// beginning of sol/variadic_args.hpp
-
-// beginning of sol/stack_proxy.hpp
-
-// beginning of sol/function.hpp
-
-// beginning of sol/function_result.hpp
-
-// beginning of sol/proxy_base.hpp
-
-namespace sol {
-	struct proxy_base_tag {};
-
-	template <typename Super>
-	struct proxy_base : proxy_base_tag {
-		operator std::string() const {
-			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
-			return super.template get<std::string>();
-		}
-
-		template<typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, is_proxy_primitive<meta::unqualified_t<T>>> = meta::enabler>
-		operator T () const {
-			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
-			return super.template get<T>();
-		}
-
-		template<typename T, meta::enable<meta::neg<meta::is_string_constructible<T>>, meta::neg<is_proxy_primitive<meta::unqualified_t<T>>>> = meta::enabler>
-		operator T& () const {
-			const Super& super = *static_cast<const Super*>(static_cast<const void*>(this));
-			return super.template get<T&>();
-		}
-	};
-} // sol
-
-// end of sol/proxy_base.hpp
-
-#include <cstdint>
-
-namespace sol {
-	struct function_result : public proxy_base<function_result> {
-	private:
-		lua_State* L;
-		int index;
-		int returncount;
-
-	public:
-		function_result() = default;
-		function_result(lua_State* Ls, int idx = -1, int retnum = 0) : L(Ls), index(idx), returncount(retnum) {
-
-		}
-		function_result(const function_result&) = default;
-		function_result& operator=(const function_result&) = default;
-		function_result(function_result&& o) : L(o.L), index(o.index), returncount(o.returncount) {
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-		}
-		function_result& operator=(function_result&& o) {
-			L = o.L;
-			index = o.index;
-			returncount = o.returncount;
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-			return *this;
-		}
-
-		template<typename T>
-		decltype(auto) get() const {
-			return stack::get<T>(L, index);
-		}
-
-		call_status status() const noexcept {
-			return call_status::ok;
-		}
-
-		bool valid() const noexcept {
-			return status() == call_status::ok || status() == call_status::yielded;
-		}
-
-		lua_State* lua_state() const { return L; };
-		int stack_index() const { return index; };
-
-		~function_result() {
-			lua_pop(L, returncount);
-		}
-	};
-} // sol
-
-// end of sol/function_result.hpp
-
-// beginning of sol/function_types.hpp
-
-// beginning of sol/function_types_core.hpp
-
-// beginning of sol/wrapper.hpp
-
-namespace sol {
-
-	template <typename F, typename = void>
-	struct wrapper {
-		typedef lua_bind_traits<F> traits_type;
-		typedef typename traits_type::args_list args_list;
-		typedef typename traits_type::args_list free_args_list;
-		typedef typename traits_type::returns_list returns_list;
-
-		template <typename... Args>
-		static decltype(auto) call(F& f, Args&&... args) {
-			return f(std::forward<Args>(args)...);
-		}
-
-		struct caller {
-			template <typename... Args>
-			decltype(auto) operator()(F& fx, Args&&... args) const {
-				return call(fx, std::forward<Args>(args)...);
-			}
-		};
-	};
-
-	template <typename F>
-	struct wrapper<F, std::enable_if_t<std::is_function<meta::unqualified_t<std::remove_pointer_t<F>>>::value>> {
-		typedef lua_bind_traits<F> traits_type;
-		typedef typename traits_type::args_list args_list;
-		typedef typename traits_type::args_list free_args_list;
-		typedef typename traits_type::returns_list returns_list;
-
-		template <F fx, typename... Args>
-		static decltype(auto) invoke(Args&&... args) {
-			return fx(std::forward<Args>(args)...);
-		}
-
-		template <typename... Args>
-		static decltype(auto) call(F& fx, Args&&... args) {
-			return fx(std::forward<Args>(args)...);
-		}
-
-		struct caller {
-			template <typename... Args>
-			decltype(auto) operator()(F& fx, Args&&... args) const {
-				return call(fx, std::forward<Args>(args)...);
-			}
-		};
-
-		template <F fx>
-		struct invoker {
-			template <typename... Args>
-			decltype(auto) operator()(Args&&... args) const {
-				return invoke<fx>(std::forward<Args>(args)...);
-			}
-		};
-	};
-
-	template <typename F>
-	struct wrapper<F, std::enable_if_t<std::is_member_object_pointer<meta::unqualified_t<F>>::value>> {
-		typedef lua_bind_traits<F> traits_type;
-		typedef typename traits_type::object_type object_type;
-		typedef typename traits_type::return_type return_type;
-		typedef typename traits_type::args_list args_list;
-		typedef types<object_type&, return_type> free_args_list;
-		typedef typename traits_type::returns_list returns_list;
-
-		template <F fx>
-		static decltype(auto) invoke(object_type& mem) {
-			return mem.*fx;
-		}
-
-		template <F fx, typename Arg, typename... Args>
-		static decltype(auto) invoke(object_type& mem, Arg&& arg, Args&&...) {
-			return mem.*fx = std::forward<Arg>(arg);
-		}
-
-		template <typename Fx>
-		static decltype(auto) call(Fx&& fx, object_type& mem) {
-			return (mem.*fx);
-		}
-
-		template <typename Fx, typename Arg, typename... Args>
-		static void call(Fx&& fx, object_type& mem, Arg&& arg, Args&&...) {
-			(mem.*fx) = std::forward<Arg>(arg);
-		}
-
-		struct caller {
-			template <typename Fx, typename... Args>
-			decltype(auto) operator()(Fx&& fx, object_type& mem, Args&&... args) const {
-				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
-			}
-		};
-
-		template <F fx>
-		struct invoker {
-			template <typename... Args>
-			decltype(auto) operator()(Args&&... args) const {
-				return invoke<fx>(std::forward<Args>(args)...);
-			}
-		};
-	};
-
-	template <typename F, typename R, typename O, typename... FArgs>
-	struct member_function_wrapper {
-		typedef O object_type;
-		typedef lua_bind_traits<F> traits_type;
-		typedef typename traits_type::args_list args_list;
-		typedef types<object_type&, FArgs...> free_args_list;
-		typedef meta::tuple_types<R> returns_list;
-
-		template <F fx, typename... Args>
-		static R invoke(O& mem, Args&&... args) {
-			return (mem.*fx)(std::forward<Args>(args)...);
-		}
-
-		template <typename Fx, typename... Args>
-		static R call(Fx&& fx, O& mem, Args&&... args) {
-			return (mem.*fx)(std::forward<Args>(args)...);
-		}
-
-		struct caller {
-			template <typename Fx, typename... Args>
-			decltype(auto) operator()(Fx&& fx, O& mem, Args&&... args) const {
-				return call(std::forward<Fx>(fx), mem, std::forward<Args>(args)...);
-			}
-		};
-
-		template <F fx>
-		struct invoker {
-			template <typename... Args>
-			decltype(auto) operator()(O& mem, Args&&... args) const {
-				return invoke<fx>(mem, std::forward<Args>(args)...);
-			}
-		};
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...)> : public member_function_wrapper<R(O:: *)(Args...), R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const> : public member_function_wrapper<R(O:: *)(Args...) const, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const volatile> : public member_function_wrapper<R(O:: *)(Args...) const volatile, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) &> : public member_function_wrapper<R(O:: *)(Args...) &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const &> : public member_function_wrapper<R(O:: *)(Args...) const &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const volatile &> : public member_function_wrapper<R(O:: *)(Args...) const volatile &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) &> : public member_function_wrapper<R(O:: *)(Args..., ...) &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) const &> : public member_function_wrapper<R(O:: *)(Args..., ...) const &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) const volatile &> : public member_function_wrapper<R(O:: *)(Args..., ...) const volatile &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) && > : public member_function_wrapper<R(O:: *)(Args...) &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const &&> : public member_function_wrapper<R(O:: *)(Args...) const &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args...) const volatile &&> : public member_function_wrapper<R(O:: *)(Args...) const volatile &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) && > : public member_function_wrapper<R(O:: *)(Args..., ...) &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) const &&> : public member_function_wrapper<R(O:: *)(Args..., ...) const &, R, O, Args...> {
-
-	};
-
-	template <typename R, typename O, typename... Args>
-	struct wrapper<R(O:: *)(Args..., ...) const volatile &&> : public member_function_wrapper<R(O:: *)(Args..., ...) const volatile &, R, O, Args...> {
-
-	};
-
-} // sol
-
-// end of sol/wrapper.hpp
-
-namespace sol {
-	namespace function_detail {
-		template <typename Fx, int start = 1>
-		inline int call(lua_State* L) {
-			Fx& fx = stack::get<user<Fx>>(L, upvalue_index(start));
-			return fx(L);
-		}
-	} // function_detail
-} // sol
-
-// end of sol/function_types_core.hpp
-
-// beginning of sol/function_types_templated.hpp
-
-// beginning of sol/call.hpp
-
-// beginning of sol/protect.hpp
-
-namespace sol {
-	
-	template <typename T>
-	struct protect_t {
-		T value;
-
-		template <typename Arg, typename... Args, meta::disable<std::is_same<protect_t, meta::unqualified_t<Arg>>> = meta::enabler>
-		protect_t(Arg&& arg, Args&&... args) : value(std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-
-		protect_t(const protect_t&) = default;
-		protect_t(protect_t&&) = default;
-		protect_t& operator=(const protect_t&) = default;
-		protect_t& operator=(protect_t&&) = default;
-
-	};
-
-	template <typename T>
-	auto protect(T&& value) {
-		return protect_t<std::decay_t<T>>(std::forward<T>(value));
-	}
-
-} // sol
-
-// end of sol/protect.hpp
-
-// beginning of sol/property.hpp
-
-namespace sol {
-
-	struct no_prop { };
-
-	template <typename R, typename W>
-	struct property_wrapper {
-		typedef std::integral_constant<bool, !std::is_void<R>::value> can_read;
-		typedef std::integral_constant<bool, !std::is_void<W>::value> can_write;
-		typedef std::conditional_t<can_read::value, R, no_prop> Read;
-		typedef std::conditional_t<can_write::value, W, no_prop> Write;
-		Read read;
-		Write write;
-
-		template <typename Rx, typename Wx>
-		property_wrapper(Rx&& r, Wx&& w) : read(std::forward<Rx>(r)), write(std::forward<Wx>(w)) {}
-	};
-
-	namespace property_detail {
-		template <typename R, typename W>
-		inline decltype(auto) property(std::true_type, R&& read, W&& write) {
-			return property_wrapper<std::decay_t<R>, std::decay_t<W>>(std::forward<R>(read), std::forward<W>(write));
-		}
-		template <typename W, typename R>
-		inline decltype(auto) property(std::false_type, W&& write, R&& read) {
-			return property_wrapper<std::decay_t<R>, std::decay_t<W>>(std::forward<R>(read), std::forward<W>(write));
-		}
-		template <typename R>
-		inline decltype(auto) property(std::true_type, R&& read) {
-			return property_wrapper<std::decay_t<R>, void>(std::forward<R>(read), no_prop());
-		}
-		template <typename W>
-		inline decltype(auto) property(std::false_type, W&& write) {
-			return property_wrapper<void, std::decay_t<W>>(no_prop(), std::forward<W>(write));
-		}
-	} // property_detail
-
-	template <typename F, typename G>
-	inline decltype(auto) property(F&& f, G&& g) {
-		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
-		typedef lua_bind_traits<meta::unqualified_t<G>> right_traits;
-		return property_detail::property(meta::boolean<(left_traits::free_arity < right_traits::free_arity)>(), std::forward<F>(f), std::forward<G>(g));
-	}
-
-	template <typename F>
-	inline decltype(auto) property(F&& f) {
-		typedef lua_bind_traits<meta::unqualified_t<F>> left_traits;
-		return property_detail::property(meta::boolean<(left_traits::free_arity < 2)>(), std::forward<F>(f));
-	}
-
-	template <typename F>
-	inline decltype(auto) readonly_property(F&& f) {
-		return property_detail::property(std::true_type(), std::forward<F>(f));
-	}
-
-	template <typename F>
-	inline decltype(auto) writeonly_property(F&& f) {
-		return property_detail::property(std::false_type(), std::forward<F>(f));
-	}
-
-	template <typename T>
-	struct readonly_wrapper {
-		T v;
-
-		readonly_wrapper(T v) : v(std::move(v)) {}
-
-		operator T& () {
-			return v;
-		}
-		operator const T& () const {
-			return v;
-		}
-	};
-
-	// Allow someone to make a member variable readonly (const)
-	template <typename R, typename T>
-	inline auto readonly(R T::* v) {
-		return readonly_wrapper<meta::unqualified_t<decltype(v)>>(v);
-	}
-
-	template <typename T>
-	struct var_wrapper {
-		T value;
-		template <typename... Args>
-		var_wrapper(Args&&... args) : value(std::forward<Args>(args)...) {}
-		var_wrapper(const var_wrapper&) = default;
-		var_wrapper(var_wrapper&&) = default;
-		var_wrapper& operator=(const var_wrapper&) = default;
-		var_wrapper& operator=(var_wrapper&&) = default;
-	};
-
-	template <typename V>
-	inline auto var(V&& v) {
-		typedef meta::unqualified_t<V> T;
-		return var_wrapper<T>(std::forward<V>(v));
-	}
-
-	namespace meta {
-		template <typename T>
-		struct is_member_object : std::is_member_object_pointer<T> {};
-
-		template <typename T>
-		struct is_member_object<readonly_wrapper<T>> : std::true_type {};
-	}
-
-} // sol
-
-// end of sol/property.hpp
-
-namespace sol {
-	namespace function_detail {
-		inline int no_construction_error(lua_State* L) {
-			return luaL_error(L, "sol: cannot call this constructor (tagged as non-constructible)");
-		}
-	}
-
-	namespace call_detail {
-
-		template <typename R, typename W>
-		inline auto& pick(std::true_type, property_wrapper<R, W>& f) {
-			return f.read;
-		}
-
-		template <typename R, typename W>
-		inline auto& pick(std::false_type, property_wrapper<R, W>& f) {
-			return f.write;
-		}
-
-		template <typename T, typename List>
-		struct void_call : void_call<T, meta::function_args_t<List>> {};
-
-		template <typename T, typename... Args>
-		struct void_call<T, types<Args...>> {
-			static void call(Args...) {}
-		};
-
-		template <typename T>
-		struct constructor_match {
-			T* obj;
-
-			constructor_match(T* o) : obj(o) {}
-
-			template <typename Fx, std::size_t I, typename... R, typename... Args>
-			int operator()(types<Fx>, index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start) const {
-				detail::default_construct func{};
-				return stack::call_into_lua<stack::stack_detail::default_check_arguments>(r, a, L, start, func, obj);
-			}
-		};
-
-		namespace overload_detail {
-			template <std::size_t... M, typename Match, typename... Args>
-			inline int overload_match_arity(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&&, lua_State* L, int, int, Args&&...) {
-				return luaL_error(L, "sol: no matching function call takes this number of arguments and the specified types");
-			}
-
-			template <typename Fx, typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match, typename... Args>
-			inline int overload_match_arity(types<Fx, Fxs...>, std::index_sequence<I, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
-				typedef meta::tuple_types<typename traits::return_type> return_types;
-				typedef typename traits::free_args_list args_list;
-				// compile-time eliminate any functions that we know ahead of time are of improper arity
-				if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
-					return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
-					return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				stack::record tracking{};
-				if (!stack::stack_detail::check_types<true>{}.check(args_list(), L, start, no_panic, tracking)) {
-					return overload_match_arity(types<Fxs...>(), std::index_sequence<In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
-			}
-
-			template <std::size_t... M, typename Match, typename... Args>
-			inline int overload_match_arity_single(types<>, std::index_sequence<>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-				return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, std::size_t I, std::size_t... M, typename Match, typename... Args>
-			inline int overload_match_arity_single(types<Fx>, std::index_sequence<I>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
-				typedef meta::tuple_types<typename traits::return_type> return_types;
-				typedef typename traits::free_args_list args_list;
-				// compile-time eliminate any functions that we know ahead of time are of improper arity
-				if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
-					return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
-					return overload_match_arity(types<>(), std::index_sequence<>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename Fx1, typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match, typename... Args>
-			inline int overload_match_arity_single(types<Fx, Fx1, Fxs...>, std::index_sequence<I, I1, In...>, std::index_sequence<M...>, Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-				typedef lua_bind_traits<meta::unwrap_unqualified_t<Fx>> traits;
-				typedef meta::tuple_types<typename traits::return_type> return_types;
-				typedef typename traits::free_args_list args_list;
-				// compile-time eliminate any functions that we know ahead of time are of improper arity
-				if (meta::find_in_pack_v<index_value<traits::free_arity>, index_value<M>...>::value) {
-					return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				if (!traits::runtime_variadics_t::value && traits::free_arity != fxarity) {
-					return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<traits::free_arity, M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				stack::record tracking{};
-				if (!stack::stack_detail::check_types<true>{}.check(args_list(), L, start, no_panic, tracking)) {
-					return overload_match_arity(types<Fx1, Fxs...>(), std::index_sequence<I1, In...>(), std::index_sequence<M...>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-				}
-				return matchfx(types<Fx>(), index_value<I>(), return_types(), args_list(), L, fxarity, start, std::forward<Args>(args)...);
-			}
-		} // overload_detail
-
-		template <typename... Functions, typename Match, typename... Args>
-		inline int overload_match_arity(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-			return overload_detail::overload_match_arity_single(types<Functions...>(), std::make_index_sequence<sizeof...(Functions)>(), std::index_sequence<>(), std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-		}
-
-		template <typename... Functions, typename Match, typename... Args>
-		inline int overload_match(Match&& matchfx, lua_State* L, int start, Args&&... args) {
-			int fxarity = lua_gettop(L) - (start - 1);
-			return overload_match_arity<Functions...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-		}
-
-		template <typename T, typename... TypeLists, typename Match, typename... Args>
-		inline int construct_match(Match&& matchfx, lua_State* L, int fxarity, int start, Args&&... args) {
-			// use same overload resolution matching as all other parts of the framework
-			return overload_match_arity<decltype(void_call<T, TypeLists>::call)...>(std::forward<Match>(matchfx), L, fxarity, start, std::forward<Args>(args)...);
-		}
-
-		template <typename T, typename... TypeLists>
-		inline int construct(lua_State* L) {
-			static const auto& meta = usertype_traits<T>::metatable();
-			int argcount = lua_gettop(L);
-			call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1) : call_syntax::dot;
-			argcount -= static_cast<int>(syntax);
-
-			T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
-			T*& referencepointer = *pointerpointer;
-			T* obj = reinterpret_cast<T*>(pointerpointer + 1);
-			referencepointer = obj;
-			reference userdataref(L, -1);
-			userdataref.pop();
-
-			construct_match<T, TypeLists...>(constructor_match<T>(obj), L, argcount, 1 + static_cast<int>(syntax));
-
-			userdataref.push();
-			luaL_getmetatable(L, &meta[0]);
-			if (type_of(L, -1) == type::lua_nil) {
-				lua_pop(L, 1);
-				return luaL_error(L, "sol: unable to get usertype metatable");
-			}
-
-			lua_setmetatable(L, -2);
-			return 1;
-		}
-
-		template <typename F, bool is_index, bool is_variable, bool checked, int boost, typename = void>
-		struct agnostic_lua_call_wrapper {
-			template <typename Fx, typename... Args>
-			static int call(lua_State* L, Fx&& f, Args&&... args) {
-				typedef wrapper<meta::unqualified_t<F>> wrap;
-				typedef typename wrap::returns_list returns_list;
-				typedef typename wrap::free_args_list args_list;
-				typedef typename wrap::caller caller;
-				return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + 1, caller(), std::forward<Fx>(f), std::forward<Args>(args)...);
-			}
-		};
-
-		template <typename T, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<var_wrapper<T>, true, is_variable, checked, boost, C> {
-			template <typename F>
-			static int call(lua_State* L, F&& f) {
-				return stack::push_reference(L, detail::unwrap(f.value));
-			}
-		};
-
-		template <typename T, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<var_wrapper<T>, false, is_variable, checked, boost, C> {
-			template <typename V>
-			static int call_assign(std::true_type, lua_State* L, V&& f) {
-				detail::unwrap(f.value) = stack::get<meta::unwrapped_t<T>>(L, boost + (is_variable ? 3 : 1));
-				return 0;
-			}
-
-			template <typename... Args>
-			static int call_assign(std::false_type, lua_State* L, Args&&...) {
-				return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
-			}
-
-			template <typename... Args>
-			static int call_const(std::false_type, lua_State* L, Args&&... args) {
-				typedef meta::unwrapped_t<T> R;
-				return call_assign(std::is_assignable<std::add_lvalue_reference_t<meta::unqualified_t<R>>, R>(), L, std::forward<Args>(args)...);
-			}
-
-			template <typename... Args>
-			static int call_const(std::true_type, lua_State* L, Args&&...) {
-				return luaL_error(L, "sol: cannot write to a readonly (const) variable");
-			}
-
-			template <typename V>
-			static int call(lua_State* L, V&& f) {
-				return call_const(std::is_const<meta::unwrapped_t<T>>(), L, f);
-			}
-		};
-
-		template <bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<lua_r_CFunction, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State* L, lua_r_CFunction f) {
-				return f(L);
-			}
-		};
-
-		template <bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<lua_CFunction, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State* L, lua_CFunction f) {
-				return f(L);
-			}
-		};
-
-		template <bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<no_prop, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State* L, const no_prop&) {
-				return luaL_error(L, is_index ? "sol: cannot read from a writeonly property" : "sol: cannot write to a readonly property");
-			}
-		};
-
-		template <bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<no_construction, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State* L, const no_construction&) {
-				return function_detail::no_construction_error(L);
-			}
-		};
-
-		template <typename... Args, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<bases<Args...>, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State*, const bases<Args...>&) {
-				// Uh. How did you even call this, lul
-				return 0;
-			}
-		};
-
-		template <typename T, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct agnostic_lua_call_wrapper<std::reference_wrapper<T>, is_index, is_variable, checked, boost, C> {
-			static int call(lua_State* L, std::reference_wrapper<T> f) {
-				return agnostic_lua_call_wrapper<T, is_index, is_variable, checked, boost>{}.call(L, f.get());
-			}
-		};
-
-		template <typename T, typename F, bool is_index, bool is_variable, bool checked = stack::stack_detail::default_check_arguments, int boost = 0, typename = void>
-		struct lua_call_wrapper : agnostic_lua_call_wrapper<F, is_index, is_variable, checked, boost> {};
-
-		template <typename T, typename F, bool is_index, bool is_variable, bool checked, int boost>
-		struct lua_call_wrapper<T, F, is_index, is_variable, checked, boost, std::enable_if_t<std::is_member_function_pointer<F>::value>> {
-			typedef wrapper<meta::unqualified_t<F>> wrap;
-			typedef typename wrap::object_type object_type;
-
-			template <typename Fx>
-			static int call(lua_State* L, Fx&& f, object_type& o) {
-				typedef typename wrap::returns_list returns_list;
-				typedef typename wrap::args_list args_list;
-				typedef typename wrap::caller caller;
-				return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + ( is_variable ? 3 : 2 ), caller(), std::forward<Fx>(f), o);
-			}
-
-			template <typename Fx>
-			static int call(lua_State* L, Fx&& f) {
-				typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
-				auto maybeo = stack::check_get<Ta*>(L, 1);
-				if (!maybeo || maybeo.value() == nullptr) {
-					return luaL_error(L, "sol: received nil for 'self' argument (use ':' for accessing member functions, make sure member variables are preceeded by the actual object with '.' syntax)");
-				}
-				object_type* o = static_cast<object_type*>(maybeo.value());
-				return call(L, std::forward<Fx>(f), *o);
-#else
-				object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
-				return call(L, std::forward<Fx>(f), o);
-#endif // Safety
-			}
-		};
-
-		template <typename T, typename F, bool is_variable, bool checked, int boost>
-		struct lua_call_wrapper<T, F, false, is_variable, checked, boost, std::enable_if_t<std::is_member_object_pointer<F>::value>> {
-			typedef lua_bind_traits<F> traits_type;
-			typedef wrapper<meta::unqualified_t<F>> wrap;
-			typedef typename wrap::object_type object_type;
-
-			template <typename V>
-			static int call_assign(std::true_type, lua_State* L, V&& f, object_type& o) {
-				typedef typename wrap::args_list args_list;
-				typedef typename wrap::caller caller;
-				return stack::call_into_lua<checked>(types<void>(), args_list(), L, boost + ( is_variable ? 3 : 2 ), caller(), f, o);
-			}
-
-			template <typename V>
-			static int call_assign(std::true_type, lua_State* L, V&& f) {
-				typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
-				auto maybeo = stack::check_get<Ta*>(L, 1);
-				if (!maybeo || maybeo.value() == nullptr) {
-					if (is_variable) {
-						return luaL_error(L, "sol: received nil for 'self' argument (bad '.' access?)");
-					}
-					return luaL_error(L, "sol: received nil for 'self' argument (pass 'self' as first argument)");
-				}
-				object_type* o = static_cast<object_type*>(maybeo.value());
-				return call_assign(std::true_type(), L, f, *o);
-#else
-				object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
-				return call_assign(std::true_type(), L, f, o);
-#endif // Safety
-			}
-
-			template <typename... Args>
-			static int call_assign(std::false_type, lua_State* L, Args&&...) {
-				return luaL_error(L, "sol: cannot write to this variable: copy assignment/constructor not available");
-			}
-
-			template <typename... Args>
-			static int call_const(std::false_type, lua_State* L, Args&&... args) {
-				typedef typename traits_type::return_type R;
-				return call_assign(std::is_copy_assignable<meta::unqualified_t<R>>(), L, std::forward<Args>(args)...);
-			}
-
-			template <typename... Args>
-			static int call_const(std::true_type, lua_State* L, Args&&...) {
-				return luaL_error(L, "sol: cannot write to a readonly (const) variable");
-			}
-
-			template <typename V>
-			static int call(lua_State* L, V&& f) {
-				return call_const(std::is_const<typename traits_type::return_type>(), L, std::forward<V>(f));
-			}
-
-			template <typename V>
-			static int call(lua_State* L, V&& f, object_type& o) {
-				return call_const(std::is_const<typename traits_type::return_type>(), L, std::forward<V>(f), o);
-			}
-		};
-
-		template <typename T, typename F, bool is_variable, bool checked, int boost>
-		struct lua_call_wrapper<T, F, true, is_variable, checked, boost, std::enable_if_t<std::is_member_object_pointer<F>::value>> {
-			typedef lua_bind_traits<F> traits_type;
-			typedef wrapper<meta::unqualified_t<F>> wrap;
-			typedef typename wrap::object_type object_type;
-
-			template <typename V>
-			static int call(lua_State* L, V&& v, object_type& o) {
-				typedef typename wrap::returns_list returns_list;
-				typedef typename wrap::caller caller;
-				F f(std::forward<V>(v));
-				return stack::call_into_lua<checked>(returns_list(), types<>(), L, boost + ( is_variable ? 3 : 2 ), caller(), f, o);
-			}
-
-			template <typename V>
-			static int call(lua_State* L, V&& f) {
-				typedef std::conditional_t<std::is_void<T>::value, object_type, T> Ta;
-#ifdef SOL_SAFE_USERTYPE
-				auto maybeo = stack::check_get<Ta*>(L, 1);
-				if (!maybeo || maybeo.value() == nullptr) {
-					if (is_variable) {
-						return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
-					}
-					return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
-				}
-				object_type* o = static_cast<object_type*>(maybeo.value());
-				return call(L, f, *o);
-#else
-				object_type& o = static_cast<object_type&>(*stack::get<non_null<Ta*>>(L, 1));
-				return call(L, f, o);
-#endif // Safety
-			}
-		};
-
-		template <typename T, typename F, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, readonly_wrapper<F>, false, is_variable, checked, boost, C> {
-			typedef lua_bind_traits<F> traits_type;
-			typedef wrapper<meta::unqualified_t<F>> wrap;
-			typedef typename wrap::object_type object_type;
-
-			template <typename V>
-			static int call(lua_State* L, V&&) {
-				return luaL_error(L, "sol: cannot write to a sol::readonly variable");
-			}
-
-			template <typename V>
-			static int call(lua_State* L, V&&, object_type&) {
-				return luaL_error(L, "sol: cannot write to a sol::readonly variable");
-			}
-		};
-
-		template <typename T, typename F, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, readonly_wrapper<F>, true, is_variable, checked, boost, C> : lua_call_wrapper<T, F, true, is_variable, checked, boost, C> {
-			
-		};
-
-		template <typename T, typename... Args, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, constructor_list<Args...>, is_index, is_variable, checked, boost, C> {
-			typedef constructor_list<Args...> F;
-
-			static int call(lua_State* L, F&) {
-				const auto& metakey = usertype_traits<T>::metatable();
-				int argcount = lua_gettop(L);
-				call_syntax syntax = argcount > 0 ? stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1) : call_syntax::dot;
-				argcount -= static_cast<int>(syntax);
-
-				T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
-				reference userdataref(L, -1);
-				T*& referencepointer = *pointerpointer;
-				T* obj = reinterpret_cast<T*>(pointerpointer + 1);
-				referencepointer = obj;
-
-				construct_match<T, Args...>(constructor_match<T>(obj), L, argcount, boost + 1 + static_cast<int>(syntax));
-
-				userdataref.push();
-				luaL_getmetatable(L, &metakey[0]);
-				if (type_of(L, -1) == type::lua_nil) {
-					lua_pop(L, 1);
-					return luaL_error(L, "sol: unable to get usertype metatable");
-				}
-
-				lua_setmetatable(L, -2);
-				return 1;
-			}
-		};
-
-		template <typename T, typename... Cxs, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, constructor_wrapper<Cxs...>, is_index, is_variable, checked, boost, C> {
-			typedef constructor_wrapper<Cxs...> F;
-
-			struct onmatch {
-				template <typename Fx, std::size_t I, typename... R, typename... Args>
-				int operator()(types<Fx>, index_value<I>, types<R...> r, types<Args...> a, lua_State* L, int, int start, F& f) {
-					const auto& metakey = usertype_traits<T>::metatable();
-					T** pointerpointer = reinterpret_cast<T**>(lua_newuserdata(L, sizeof(T*) + sizeof(T)));
-					reference userdataref(L, -1);
-					T*& referencepointer = *pointerpointer;
-					T* obj = reinterpret_cast<T*>(pointerpointer + 1);
-					referencepointer = obj;
-
-					auto& func = std::get<I>(f.functions);
-					stack::call_into_lua<checked>(r, a, L, boost + start, func, detail::implicit_wrapper<T>(obj));
-
-					userdataref.push();
-					luaL_getmetatable(L, &metakey[0]);
-					if (type_of(L, -1) == type::lua_nil) {
-						lua_pop(L, 1);
-						std::string err = "sol: unable to get usertype metatable for ";
-						err += usertype_traits<T>::name();
-						return luaL_error(L, err.c_str());
-					}
-					lua_setmetatable(L, -2);
-
-					return 1;
-				}
-			};
-
-			static int call(lua_State* L, F& f) {
-				call_syntax syntax = stack::get_call_syntax(L, &usertype_traits<T>::user_metatable()[0], 1);
-				int syntaxval = static_cast<int>(syntax);
-				int argcount = lua_gettop(L) - syntaxval;
-				return construct_match<T, meta::pop_front_type_t<meta::function_args_t<Cxs>>...>(onmatch(), L, argcount, 1 + syntaxval, f);
-			}
-
-		};
-
-		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost>
-		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, std::enable_if_t<std::is_void<Fx>::value>> {
-			typedef destructor_wrapper<Fx> F;
-
-			static int call(lua_State* L, const F&) {
-				return detail::usertype_alloc_destroy<T>(L);
-			}
-		};
-
-		template <typename T, typename Fx, bool is_index, bool is_variable, bool checked, int boost>
-		struct lua_call_wrapper<T, destructor_wrapper<Fx>, is_index, is_variable, checked, boost, std::enable_if_t<!std::is_void<Fx>::value>> {
-			typedef destructor_wrapper<Fx> F;
-
-			static int call(lua_State* L, const F& f) {
-				T& obj = stack::get<T>(L);
-				f.fx(detail::implicit_wrapper<T>(obj));
-				return 0;
-			}
-		};
-
-		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, overload_set<Fs...>, is_index, is_variable, checked, boost, C> {
-			typedef overload_set<Fs...> F;
-
-			struct on_match {
-				template <typename Fx, std::size_t I, typename... R, typename... Args>
-				int operator()(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
-					auto& f = std::get<I>(fx.functions);
-					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
-				}
-			};
-
-			static int call(lua_State* L, F& fx) {
-				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L), 1, fx);
-			}
-		};
-
-		template <typename T, typename... Fs, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, factory_wrapper<Fs...>, is_index, is_variable, checked, boost, C> {
-			typedef factory_wrapper<Fs...> F;
-
-			struct on_match {
-				template <typename Fx, std::size_t I, typename... R, typename... Args>
-				int operator()(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int, F& fx) {
-					auto& f = std::get<I>(fx.functions);
-					return lua_call_wrapper<T, Fx, is_index, is_variable, checked, boost>{}.call(L, f);
-				}
-			};
-
-			static int call(lua_State* L, F& fx) {
-				return overload_match_arity<Fs...>(on_match(), L, lua_gettop(L) - boost, 1 + boost, fx);
-			}
-		};
-
-		template <typename T, typename R, typename W, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, property_wrapper<R, W>, is_index, is_variable, checked, boost, C> {
-			typedef std::conditional_t<is_index, R, W> P;
-			typedef meta::unqualified_t<P> U;
-			typedef wrapper<U> wrap;
-			typedef lua_bind_traits<U> traits_type;
-			typedef meta::unqualified_t<typename traits_type::template arg_at<0>> object_type;
-
-			template <typename F>
-			static int self_call(std::true_type, lua_State* L, F&& f) {
-				// The type being void means we don't have any arguments, so it might be a free functions?
-				typedef typename traits_type::free_args_list args_list;
-				typedef typename wrap::returns_list returns_list;
-				typedef typename wrap::caller caller;
-				return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), f);
-			}
-
-			template <typename F>
-			static int self_call(std::false_type, lua_State* L, F&& f) {
-				typedef meta::pop_front_type_t<typename traits_type::free_args_list> args_list;
-				typedef T Ta;
-#ifdef SOL_SAFE_USERTYPE
-				auto maybeo = stack::check_get<Ta*>(L, 1);
-				if (!maybeo || maybeo.value() == nullptr) {
-					if (is_variable) {
-						return luaL_error(L, "sol: 'self' argument is lua_nil (bad '.' access?)");
-					}
-					return luaL_error(L, "sol: 'self' argument is lua_nil (pass 'self' as first argument)");
-				}
-				object_type* o = static_cast<object_type*>(maybeo.value());
-#else
-				object_type* o = static_cast<object_type*>(stack::get<non_null<Ta*>>(L, 1));
-#endif // Safety
-				typedef typename wrap::returns_list returns_list;
-				typedef typename wrap::caller caller;
-				return stack::call_into_lua<checked>(returns_list(), args_list(), L, boost + (is_variable ? 3 : 2), caller(), f, *o);
-			}
-
-			template <typename F, typename... Args>
-			static int defer_call(std::false_type, lua_State* L, F&& f, Args&&... args) {
-				return self_call(meta::any<std::is_void<object_type>, meta::boolean<lua_type_of<meta::unwrap_unqualified_t<object_type>>::value != type::userdata>>(), L, pick(meta::boolean<is_index>(), f), std::forward<Args>(args)...);
-			}
-
-			template <typename F, typename... Args>
-			static int defer_call(std::true_type, lua_State* L, F&& f, Args&&... args) {
-				auto& p = pick(meta::boolean<is_index>(), std::forward<F>(f));
-				return lua_call_wrapper<T, meta::unqualified_t<decltype(p)>, is_index, is_variable, checked, boost>{}.call(L, p, std::forward<Args>(args)...);
-			}
-
-			template <typename F, typename... Args>
-			static int call(lua_State* L, F&& f, Args&&... args) {
-				typedef meta::any<
-					std::is_void<U>,
-					std::is_same<U, no_prop>,
-					meta::is_specialization_of<var_wrapper, U>,
-					meta::is_specialization_of<constructor_wrapper, U>,
-					meta::is_specialization_of<constructor_list, U>,
-					std::is_member_pointer<U>
-				> is_specialized;
-				return defer_call(is_specialized(), L, std::forward<F>(f), std::forward<Args>(args)...);
-			}
-		};
-
-		template <typename T, typename V, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, protect_t<V>, is_index, is_variable, checked, boost, C> {
-			typedef protect_t<V> F;
-
-			template <typename... Args>
-			static int call(lua_State* L, F& fx, Args&&... args) {
-				return lua_call_wrapper<T, V, is_index, is_variable, true, boost>{}.call(L, fx.value, std::forward<Args>(args)...);
-			}
-		};
-
-		template <typename T, typename Sig, typename P, bool is_index, bool is_variable, bool checked, int boost, typename C>
-		struct lua_call_wrapper<T, function_arguments<Sig, P>, is_index, is_variable, checked, boost, C> {
-			template <typename F>
-			static int call(lua_State* L, F&& f) {
-				return lua_call_wrapper<T, meta::unqualified_t<P>, is_index, is_variable, stack::stack_detail::default_check_arguments, boost>{}.call(L, std::get<0>(f.arguments));
-			}
-		};
-
-		template <typename T, bool is_index, bool is_variable, int boost = 0, typename Fx, typename... Args>
-		inline int call_wrapped(lua_State* L, Fx&& fx, Args&&... args) {
-			return lua_call_wrapper<T, meta::unqualified_t<Fx>, is_index, is_variable, stack::stack_detail::default_check_arguments, boost>{}.call(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-		}
-
-		template <typename T, bool is_index, bool is_variable, typename F, int start = 1>
-		inline int call_user(lua_State* L) {
-			auto& fx = stack::get<user<F>>(L, upvalue_index(start));
-			return call_wrapped<T, is_index, is_variable>(L, fx);
-		}
-
-		template <typename T, typename = void>
-		struct is_var_bind : std::false_type {};
-
-		template <typename T>
-		struct is_var_bind<T, std::enable_if_t<std::is_member_object_pointer<T>::value>> : std::true_type {};
-
-		template <>
-		struct is_var_bind<no_prop> : std::true_type {};
-
-		template <typename R, typename W>
-		struct is_var_bind<property_wrapper<R, W>> : std::true_type {};
-
-		template <typename T>
-		struct is_var_bind<var_wrapper<T>> : std::true_type {};
-
-		template <typename T>
-		struct is_var_bind<readonly_wrapper<T>> : is_var_bind<T> {};
-	} // call_detail
-
-	template <typename T>
-	struct is_variable_binding : call_detail::is_var_bind<meta::unqualified_t<T>> {};
-
-	template <typename T>
-	struct is_function_binding : meta::neg<is_variable_binding<T>> {};
-
-} // sol
-
-// end of sol/call.hpp
-
-namespace sol {
-	namespace function_detail {
-		template <typename F, F fx>
-		inline int call_wrapper_variable(std::false_type, lua_State* L) {
-			typedef meta::bind_traits<meta::unqualified_t<F>> traits_type;
-			typedef typename traits_type::args_list args_list;
-			typedef meta::tuple_types<typename traits_type::return_type> return_type;
-			return stack::call_into_lua(return_type(), args_list(), L, 1, fx);
-		}
-
-		template <typename R, typename V, V, typename T>
-		inline int call_set_assignable(std::false_type, T&&, lua_State* L) {
-			return luaL_error(L, "cannot write to this type: copy assignment/constructor not available");
-		}
-
-		template <typename R, typename V, V variable, typename T>
-		inline int call_set_assignable(std::true_type, lua_State* L, T&& mem) {
-			(mem.*variable) = stack::get<R>(L, 2);
-			return 0;
-		}
-
-		template <typename R, typename V, V, typename T>
-		inline int call_set_variable(std::false_type, lua_State* L, T&&) {
-			return luaL_error(L, "cannot write to a const variable");
-		}
-
-		template <typename R, typename V, V variable, typename T>
-		inline int call_set_variable(std::true_type, lua_State* L, T&& mem) {
-			return call_set_assignable<R, V, variable>(std::is_assignable<std::add_lvalue_reference_t<R>, R>(), L, std::forward<T>(mem));
-		}
-
-		template <typename V, V variable>
-		inline int call_wrapper_variable(std::true_type, lua_State* L) {
-			typedef meta::bind_traits<meta::unqualified_t<V>> traits_type;
-			typedef typename traits_type::object_type T;
-			typedef typename traits_type::return_type R;
-			auto& mem = stack::get<T>(L, 1);
-			switch (lua_gettop(L)) {
-			case 1: {
-				decltype(auto) r = (mem.*variable);
-				stack::push_reference(L, std::forward<decltype(r)>(r));
-				return 1; }
-			case 2:
-				return call_set_variable<R, V, variable>(meta::neg<std::is_const<R>>(), L, mem);
-			default:
-				return luaL_error(L, "incorrect number of arguments to member variable function call");
-			}
-		}
-
-		template <typename F, F fx>
-		inline int call_wrapper_function(std::false_type, lua_State* L) {
-			return call_wrapper_variable<F, fx>(std::is_member_object_pointer<F>(), L);
-		}
-
-		template <typename F, F fx>
-		inline int call_wrapper_function(std::true_type, lua_State* L) {
-			return call_detail::call_wrapped<void, false, false>(L, fx);
-		}
-
-		template <typename F, F fx>
-		int call_wrapper_entry(lua_State* L) {
-			return call_wrapper_function<F, fx>(std::is_member_function_pointer<meta::unqualified_t<F>>(), L);
-		}
-
-		template <typename... Fxs>
-		struct c_call_matcher {
-			template <typename Fx, std::size_t I, typename R, typename... Args>
-			int operator()(types<Fx>, index_value<I>, types<R>, types<Args...>, lua_State* L, int, int) const {
-				typedef meta::at_in_pack_t<I, Fxs...> target;
-				return target::call(L);
-			}
-		};
-
-	} // function_detail
-
-	template <typename F, F fx>
-	inline int c_call(lua_State* L) {
-#ifdef __clang__
-		return detail::trampoline(L, function_detail::call_wrapper_entry<F, fx>);
-#else
-		return detail::static_trampoline<(&function_detail::call_wrapper_entry<F, fx>)>(L);
-#endif // fuck you clang :c
-	}
-
-	template <typename F, F f>
-	struct wrap {
-		typedef F type;
-
-		static int call(lua_State* L) {
-			return c_call<type, f>(L);
-		}
-	};
-
-	template <typename... Fxs>
-	inline int c_call(lua_State* L) {
-		if (sizeof...(Fxs) < 2) {
-			return meta::at_in_pack_t<0, Fxs...>::call(L);
-		}
-		else {
-			return call_detail::overload_match_arity<typename Fxs::type...>(function_detail::c_call_matcher<Fxs...>(), L, lua_gettop(L), 1);
-		}
-	}
-
-} // sol
-
-// end of sol/function_types_templated.hpp
-
-// beginning of sol/function_types_stateless.hpp
-
-namespace sol {
-	namespace function_detail {
-		template<typename Function>
-		struct upvalue_free_function {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				auto udata = stack::stack_detail::get_as_upvalues<function_type*>(L);
-				function_type* fx = udata.first;
-				return call_detail::call_wrapped<void, true, false>(L, fx);
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_member_function {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member function pointer
-				// idx n + 1: is the object's void pointer
-				// We don't need to store the size, because the other side is templated
-				// with the same member function pointer type
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
-				function_type& memfx = memberdata.first;
-				auto& item = *objdata.first;
-				return call_detail::call_wrapped<T, true, false, -1>(L, memfx, item);
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_member_variable {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member variable pointer
-				// idx n + 1: is the object's void pointer
-				// We don't need to store the size, because the other side is templated
-				// with the same member function pointer type
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
-				auto& mem = *objdata.first;
-				function_type& var = memberdata.first;
-				switch (lua_gettop(L)) {
-				case 0:
-					return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
-				case 1:
-					return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
-				default:
-					return luaL_error(L, "sol: incorrect number of arguments to member variable function");
-				}
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_member_variable<T, readonly_wrapper<Function>> {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member variable pointer
-				// idx n + 1: is the object's void pointer
-				// We don't need to store the size, because the other side is templated
-				// with the same member function pointer type
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				auto objdata = stack::stack_detail::get_as_upvalues<T*>(L, memberdata.second);
-				auto& mem = *objdata.first;
-				function_type& var = memberdata.first;
-				switch (lua_gettop(L)) {
-				case 0:
-					return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
-				default:
-					return luaL_error(L, "sol: incorrect number of arguments to member variable function");
-				}
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_this_member_function {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member variable pointer
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				function_type& memfx = memberdata.first;
-				return call_detail::call_wrapped<T, false, false>(L, memfx);
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_this_member_variable {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member variable pointer
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				function_type& var = memberdata.first;
-				switch (lua_gettop(L)) {
-				case 1:
-					return call_detail::call_wrapped<T, true, false>(L, var);
-				case 2:
-					return call_detail::call_wrapped<T, false, false>(L, var);
-				default:
-					return luaL_error(L, "sol: incorrect number of arguments to member variable function");
-				}
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct upvalue_this_member_variable<T, readonly_wrapper<Function>> {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef lua_bind_traits<function_type> traits_type;
-
-			static int real_call(lua_State* L) {
-				// Layout:
-				// idx 1...n: verbatim data of member variable pointer
-				auto memberdata = stack::stack_detail::get_as_upvalues<function_type>(L);
-				function_type& var = memberdata.first;
-				switch (lua_gettop(L)) {
-				case 1:
-					return call_detail::call_wrapped<T, true, false>(L, var);
-				default:
-					return luaL_error(L, "sol: incorrect number of arguments to member variable function");
-				}
-			}
-
-			static int call(lua_State* L) {
-				return detail::static_trampoline<(&real_call)>(L);
-			}
-
-			int operator()(lua_State* L) {
-				return call(L);
-			}
-		};
-	} // function_detail
-} // sol
-
-// end of sol/function_types_stateless.hpp
-
-// beginning of sol/function_types_stateful.hpp
-
-namespace sol {
-	namespace function_detail {
-		template<typename Func>
-		struct functor_function {
-			typedef meta::unwrapped_t<meta::unqualified_t<Func>> Function;
-			Function fx;
-
-			template<typename... Args>
-			functor_function(Function f, Args&&... args) : fx(std::move(f), std::forward<Args>(args)...) {}
-
-			int call(lua_State* L) {
-				return call_detail::call_wrapped<void, true, false>(L, fx);
-			}
-
-			int operator()(lua_State* L) {
-				auto f = [&](lua_State*) -> int { return this->call(L); };
-				return detail::trampoline(L, f);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct member_function {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef meta::function_return_t<function_type> return_type;
-			typedef meta::function_args_t<function_type> args_lists;
-			function_type invocation;
-			T member;
-
-			template<typename... Args>
-			member_function(function_type f, Args&&... args) : invocation(std::move(f)), member(std::forward<Args>(args)...) {}
-
-			int call(lua_State* L) {
-				return call_detail::call_wrapped<T, true, false, -1>(L, invocation, detail::unwrap(detail::deref(member)));
-			}
-
-			int operator()(lua_State* L) {
-				auto f = [&](lua_State*) -> int { return this->call(L); };
-				return detail::trampoline(L, f);
-			}
-		};
-
-		template<typename T, typename Function>
-		struct member_variable {
-			typedef std::remove_pointer_t<std::decay_t<Function>> function_type;
-			typedef typename meta::bind_traits<function_type>::return_type return_type;
-			typedef typename meta::bind_traits<function_type>::args_list args_lists;
-			function_type var;
-			T member;
-			typedef std::add_lvalue_reference_t<meta::unwrapped_t<std::remove_reference_t<decltype(detail::deref(member))>>> M;
-
-			template<typename... Args>
-			member_variable(function_type v, Args&&... args) : var(std::move(v)), member(std::forward<Args>(args)...) {}
-
-			int call(lua_State* L) {
-				M mem = detail::unwrap(detail::deref(member));
-				switch (lua_gettop(L)) {
-				case 0:
-					return call_detail::call_wrapped<T, true, false, -1>(L, var, mem);
-				case 1:
-					return call_detail::call_wrapped<T, false, false, -1>(L, var, mem);
-				default:
-					return luaL_error(L, "sol: incorrect number of arguments to member variable function");
-				}
-			}
-
-			int operator()(lua_State* L) {
-				auto f = [&](lua_State*) -> int { return this->call(L); };
-				return detail::trampoline(L, f);
-			}
-		};
-	} // function_detail
-} // sol
-
-// end of sol/function_types_stateful.hpp
-
-// beginning of sol/function_types_overloaded.hpp
-
-namespace sol {
-	namespace function_detail {
-		template <int start_skew = 0, typename... Functions>
-		struct overloaded_function {
-			typedef std::tuple<Functions...> overload_list;
-			typedef std::make_index_sequence<sizeof...(Functions)> indices;
-			overload_list overloads;
-
-			overloaded_function(overload_list set)
-				: overloads(std::move(set)) {}
-
-			overloaded_function(Functions... fxs)
-				: overloads(fxs...) {
-
-			}
-
-			template <typename Fx, std::size_t I, typename... R, typename... Args>
-			int call(types<Fx>, index_value<I>, types<R...>, types<Args...>, lua_State* L, int, int) {
-				auto& func = std::get<I>(overloads);
-				return call_detail::call_wrapped<void, true, false, start_skew>(L, func);
-			}
-
-			int operator()(lua_State* L) {
-				auto mfx = [&](auto&&... args) { return this->call(std::forward<decltype(args)>(args)...); };
-				return call_detail::overload_match<Functions...>(mfx, L, 1 + start_skew);
-			}
-		};
-	} // function_detail
-} // sol
-
-// end of sol/function_types_overloaded.hpp
-
-// beginning of sol/resolve.hpp
-
-namespace sol {
-	
-#ifndef __clang__
-	// constexpr is fine for not-clang
-
-	namespace detail {
-		template<typename R, typename... Args, typename F, typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
-		inline constexpr auto resolve_i(types<R(Args...)>, F&&)->R(meta::unqualified_t<F>::*)(Args...) {
-			using Sig = R(Args...);
-			typedef meta::unqualified_t<F> Fu;
-			return static_cast<Sig Fu::*>(&Fu::operator());
-		}
-
-		template<typename F, typename U = meta::unqualified_t<F>>
-		inline constexpr auto resolve_f(std::true_type, F&& f)
-			-> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
-			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
-		}
-
-		template<typename F>
-		inline constexpr void resolve_f(std::false_type, F&&) {
-			static_assert(meta::has_deducible_signature<F>::value,
-				"Cannot use no-template-parameter call with an overloaded functor: specify the signature");
-		}
-
-		template<typename F, typename U = meta::unqualified_t<F>>
-		inline constexpr auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
-			return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
-		}
-
-		template<typename... Args, typename F, typename R = std::result_of_t<F&(Args...)>>
-		inline constexpr auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
-			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
-		}
-
-		template<typename Sig, typename C>
-		inline constexpr Sig C::* resolve_v(std::false_type, Sig C::* mem_func_ptr) {
-			return mem_func_ptr;
-		}
-
-		template<typename Sig, typename C>
-		inline constexpr Sig C::* resolve_v(std::true_type, Sig C::* mem_variable_ptr) {
-			return mem_variable_ptr;
-		}
-	} // detail
-
-	template<typename... Args, typename R>
-	inline constexpr auto resolve(R fun_ptr(Args...))->R(*)(Args...) {
-		return fun_ptr;
-	}
-
-	template<typename Sig>
-	inline constexpr Sig* resolve(Sig* fun_ptr) {
-		return fun_ptr;
-	}
-
-	template<typename... Args, typename R, typename C>
-	inline constexpr auto resolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...) {
-		return mem_ptr;
-	}
-
-	template<typename Sig, typename C>
-	inline constexpr Sig C::* resolve(Sig C::* mem_ptr) {
-		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
-	}
-
-	template<typename... Sig, typename F, meta::disable<std::is_function<meta::unqualified_t<F>>> = meta::enabler>
-	inline constexpr auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
-		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
-	}
-#else
-
-	// Clang has distinct problems with constexpr arguments,
-	// so don't use the constexpr versions inside of clang.
-
-	namespace detail {
-		template<typename R, typename... Args, typename F, typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
-		inline auto resolve_i(types<R(Args...)>, F&&)->R(meta::unqualified_t<F>::*)(Args...) {
-			using Sig = R(Args...);
-			typedef meta::unqualified_t<F> Fu;
-			return static_cast<Sig Fu::*>(&Fu::operator());
-		}
-
-		template<typename F, typename U = meta::unqualified_t<F>>
-		inline auto resolve_f(std::true_type, F&& f)
-			-> decltype(resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f))) {
-			return resolve_i(types<meta::function_signature_t<decltype(&U::operator())>>(), std::forward<F>(f));
-		}
-
-		template<typename F>
-		inline void resolve_f(std::false_type, F&&) {
-			static_assert(meta::has_deducible_signature<F>::value,
-				"Cannot use no-template-parameter call with an overloaded functor: specify the signature");
-		}
-
-		template<typename F, typename U = meta::unqualified_t<F>>
-		inline auto resolve_i(types<>, F&& f) -> decltype(resolve_f(meta::has_deducible_signature<U>(), std::forward<F>(f))) {
-			return resolve_f(meta::has_deducible_signature<U> {}, std::forward<F>(f));
-		}
-
-		template<typename... Args, typename F, typename R = std::result_of_t<F&(Args...)>>
-		inline auto resolve_i(types<Args...>, F&& f) -> decltype(resolve_i(types<R(Args...)>(), std::forward<F>(f))) {
-			return resolve_i(types<R(Args...)>(), std::forward<F>(f));
-		}
-
-		template<typename Sig, typename C>
-		inline Sig C::* resolve_v(std::false_type, Sig C::* mem_func_ptr) {
-			return mem_func_ptr;
-		}
-
-		template<typename Sig, typename C>
-		inline Sig C::* resolve_v(std::true_type, Sig C::* mem_variable_ptr) {
-			return mem_variable_ptr;
-		}
-	} // detail
-
-	template<typename... Args, typename R>
-	inline auto resolve(R fun_ptr(Args...))->R(*)(Args...) {
-		return fun_ptr;
-	}
-
-	template<typename Sig>
-	inline Sig* resolve(Sig* fun_ptr) {
-		return fun_ptr;
-	}
-
-	template<typename... Args, typename R, typename C>
-	inline auto resolve(R(C::*mem_ptr)(Args...))->R(C::*)(Args...) {
-		return mem_ptr;
-	}
-
-	template<typename Sig, typename C>
-	inline Sig C::* resolve(Sig C::* mem_ptr) {
-		return detail::resolve_v(std::is_member_object_pointer<Sig C::*>(), mem_ptr);
-	}
-
-	template<typename... Sig, typename F>
-	inline auto resolve(F&& f) -> decltype(detail::resolve_i(types<Sig...>(), std::forward<F>(f))) {
-		return detail::resolve_i(types<Sig...>(), std::forward<F>(f));
-	}
-
-#endif
-
-} // sol
-
-// end of sol/resolve.hpp
-
-namespace sol {
-	namespace function_detail {
-		template<typename T>
-		struct class_indicator {};
-
-		struct call_indicator {};
-	}
-	namespace stack {
-		template<typename... Sigs>
-		struct pusher<function_sig<Sigs...>> {
-			template <typename... Sig, typename Fx, typename... Args>
-			static void select_convertible(std::false_type, types<Sig...>, lua_State* L, Fx&& fx, Args&&... args) {
-				typedef std::remove_pointer_t<std::decay_t<Fx>> clean_fx;
-				typedef function_detail::functor_function<clean_fx> F;
-				set_fx<F>(L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename R, typename... A, typename Fx, typename... Args>
-			static void select_convertible(std::true_type, types<R(A...)>, lua_State* L, Fx&& fx, Args&&... args) {
-				using fx_ptr_t = R(*)(A...);
-				fx_ptr_t fxptr = detail::unwrap(std::forward<Fx>(fx));
-				select_function(std::true_type(), L, fxptr, std::forward<Args>(args)...);
-			}
-
-			template <typename R, typename... A, typename Fx, typename... Args>
-			static void select_convertible(types<R(A...)> t, lua_State* L, Fx&& fx, Args&&... args) {
-				typedef std::decay_t<meta::unwrap_unqualified_t<Fx>> raw_fx_t;
-				typedef R(*fx_ptr_t)(A...);
-				typedef std::is_convertible<raw_fx_t, fx_ptr_t> is_convertible;
-				select_convertible(is_convertible(), t, L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename... Args>
-			static void select_convertible(types<>, lua_State* L, Fx&& fx, Args&&... args) {
-				typedef meta::function_signature_t<meta::unwrap_unqualified_t<Fx>> Sig;
-				select_convertible(types<Sig>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename T, typename... Args>
-			static void select_reference_member_variable(std::false_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef std::remove_pointer_t<std::decay_t<Fx>> clean_fx;
-				typedef function_detail::member_variable<meta::unwrap_unqualified_t<T>, clean_fx> F;
-				set_fx<F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename T, typename... Args>
-			static void select_reference_member_variable(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef std::decay_t<Fx> dFx;
-				dFx memfxptr(std::forward<Fx>(fx));
-				auto userptr = detail::ptr(std::forward<T>(obj), std::forward<Args>(args)...);
-				lua_CFunction freefunc = &function_detail::upvalue_member_variable<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>>::call;
-
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
-				upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx, typename... Args>
-			static void select_member_variable(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
-				select_convertible(types<Sigs...>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename T, typename... Args, meta::disable<meta::is_specialization_of<function_detail::class_indicator, meta::unqualified_t<T>>> = meta::enabler>
-			static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef meta::boolean<meta::is_specialization_of<std::reference_wrapper, meta::unqualified_t<T>>::value || std::is_pointer<T>::value> is_reference;
-				select_reference_member_variable(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename C>
-			static void select_member_variable(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) {
-				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::call;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx>
-			static void select_member_variable(std::true_type, lua_State* L, Fx&& fx) {
-				typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
-				lua_CFunction freefunc = &function_detail::upvalue_this_member_variable<C, Fx>::call;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx, typename T, typename... Args>
-			static void select_reference_member_function(std::false_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef std::decay_t<Fx> clean_fx;
-				typedef function_detail::member_function<meta::unwrap_unqualified_t<T>, clean_fx> F;
-				set_fx<F>(L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename T, typename... Args>
-			static void select_reference_member_function(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef std::decay_t<Fx> dFx;
-				dFx memfxptr(std::forward<Fx>(fx));
-				auto userptr = detail::ptr(std::forward<T>(obj), std::forward<Args>(args)...);
-				lua_CFunction freefunc = &function_detail::upvalue_member_function<std::decay_t<decltype(*userptr)>, meta::unqualified_t<Fx>>::call;
-
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, memfxptr);
-				upvalues += stack::push(L, lightuserdata_value(static_cast<void*>(userptr)));
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx, typename... Args>
-			static void select_member_function(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
-				select_member_variable(meta::is_member_object<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename T, typename... Args, meta::disable<meta::is_specialization_of<function_detail::class_indicator, meta::unqualified_t<T>>> = meta::enabler>
-			static void select_member_function(std::true_type, lua_State* L, Fx&& fx, T&& obj, Args&&... args) {
-				typedef meta::boolean<meta::is_specialization_of<std::reference_wrapper, meta::unqualified_t<T>>::value || std::is_pointer<T>::value> is_reference;
-				select_reference_member_function(is_reference(), L, std::forward<Fx>(fx), std::forward<T>(obj), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename C>
-			static void select_member_function(std::true_type, lua_State* L, Fx&& fx, function_detail::class_indicator<C>) {
-				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx>::call;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx>
-			static void select_member_function(std::true_type, lua_State* L, Fx&& fx) {
-				typedef typename meta::bind_traits<meta::unqualified_t<Fx>>::object_type C;
-				lua_CFunction freefunc = &function_detail::upvalue_this_member_function<C, Fx>::call;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, fx);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template <typename Fx, typename... Args>
-			static void select_function(std::false_type, lua_State* L, Fx&& fx, Args&&... args) {
-				select_member_function(std::is_member_function_pointer<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, typename... Args>
-			static void select_function(std::true_type, lua_State* L, Fx&& fx, Args&&... args) {
-				std::decay_t<Fx> target(std::forward<Fx>(fx), std::forward<Args>(args)...);
-				lua_CFunction freefunc = &function_detail::upvalue_free_function<Fx>::call;
-
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::stack_detail::push_as_upvalues(L, target);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			static void select_function(std::true_type, lua_State* L, lua_CFunction f) {
-				stack::push(L, f);
-			}
-
-			template <typename Fx, typename... Args, meta::disable<meta::any<std::is_base_of<reference, meta::unqualified_t<Fx>>, std::is_base_of<stack_reference, meta::unqualified_t<Fx>>>> = meta::enabler>
-			static void select(lua_State* L, Fx&& fx, Args&&... args) {
-				select_function(std::is_function<meta::unqualified_t<Fx>>(), L, std::forward<Fx>(fx), std::forward<Args>(args)...);
-			}
-
-			template <typename Fx, meta::enable<meta::any<std::is_base_of<reference, meta::unqualified_t<Fx>>, std::is_base_of<stack_reference, meta::unqualified_t<Fx>>>> = meta::enabler>
-			static void select(lua_State* L, Fx&& fx) {
-				stack::push(L, std::forward<Fx>(fx));
-			}
-
-			template <typename Fx, typename... Args>
-			static void set_fx(lua_State* L, Args&&... args) {
-				lua_CFunction freefunc = function_detail::call<meta::unqualified_t<Fx>, 2>;
-
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push<user<Fx>>(L, std::forward<Args>(args)...);
-				stack::push(L, c_closure(freefunc, upvalues));
-			}
-
-			template<typename... Args>
-			static int push(lua_State* L, Args&&... args) {
-				// Set will always place one thing (function) on the stack
-				select(L, std::forward<Args>(args)...);
-				return 1;
-			}
-		};
-
-		template<typename T, typename... Args>
-		struct pusher<function_arguments<T, Args...>> {
-			template <std::size_t... I, typename FP>
-			static int push_func(std::index_sequence<I...>, lua_State* L, FP&& fp) {
-				return stack::push<T>(L, detail::forward_get<I>(fp.arguments)...);
-			}
-
-			static int push(lua_State* L, const function_arguments<T, Args...>& fp) {
-				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, fp);
-			}
-
-			static int push(lua_State* L, function_arguments<T, Args...>&& fp) {
-				return push_func(std::make_index_sequence<sizeof...(Args)>(), L, std::move(fp));
-			}
-		};
-
-		template<typename Signature>
-		struct pusher<std::function<Signature>> {
-			static int push(lua_State* L, const std::function<Signature>& fx) {
-				return pusher<function_sig<Signature>>{}.push(L, fx);
-			}
-
-			static int push(lua_State* L, std::function<Signature>&& fx) {
-				return pusher<function_sig<Signature>>{}.push(L, std::move(fx));
-			}
-		};
-
-		template<typename Signature>
-		struct pusher<Signature, std::enable_if_t<std::is_member_pointer<Signature>::value>> {
-			template <typename F, typename... Args>
-			static int push(lua_State* L, F&& f, Args&&... args) {
-				return pusher<function_sig<>>{}.push(L, std::forward<F>(f), std::forward<Args>(args)...);
-			}
-		};
-
-		template<typename Signature>
-		struct pusher<Signature, std::enable_if_t<meta::all<std::is_function<Signature>, meta::neg<std::is_same<Signature, lua_CFunction>>, meta::neg<std::is_same<Signature, std::remove_pointer_t<lua_CFunction>>>>::value>> {
-			template <typename F>
-			static int push(lua_State* L, F&& f) {
-				return pusher<function_sig<>>{}.push(L, std::forward<F>(f));
-			}
-		};
-
-		template<typename... Functions>
-		struct pusher<overload_set<Functions...>> {
-			static int push(lua_State* L, overload_set<Functions...>&& set) {
-				typedef function_detail::overloaded_function<0, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, std::move(set.functions));
-				return 1;
-			}
-
-			static int push(lua_State* L, const overload_set<Functions...>& set) {
-				typedef function_detail::overloaded_function<0, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, set.functions);
-				return 1;
-			}
-		};
-
-		template <typename T>
-		struct pusher<protect_t<T>> {
-			static int push(lua_State* L, protect_t<T>&& pw) {
-				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push<user<protect_t<T>>>(L, std::move(pw.value));
-				return stack::push(L, c_closure(cf, upvalues));
-			}
-
-			static int push(lua_State* L, const protect_t<T>& pw) {
-				lua_CFunction cf = call_detail::call_user<void, false, false, protect_t<T>, 2>;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push<user<protect_t<T>>>(L, pw.value);
-				return stack::push(L, c_closure(cf, upvalues));
-			}
-		};
-
-		template <typename F, typename G>
-		struct pusher<property_wrapper<F, G>, std::enable_if_t<!std::is_void<F>::value && !std::is_void<G>::value>> {
-			static int push(lua_State* L, property_wrapper<F, G>&& pw) {
-				return stack::push(L, sol::overload(std::move(pw.read), std::move(pw.write)));
-			}
-			static int push(lua_State* L, const property_wrapper<F, G>& pw) {
-				return stack::push(L, sol::overload(pw.read, pw.write));
-			}
-		};
-
-		template <typename F>
-		struct pusher<property_wrapper<F, void>> {
-			static int push(lua_State* L, property_wrapper<F, void>&& pw) {
-				return stack::push(L, std::move(pw.read));
-			}
-			static int push(lua_State* L, const property_wrapper<F, void>& pw) {
-				return stack::push(L, pw.read);
-			}
-		};
-
-		template <typename F>
-		struct pusher<property_wrapper<void, F>> {
-			static int push(lua_State* L, property_wrapper<void, F>&& pw) {
-				return stack::push(L, std::move(pw.write));
-			}
-			static int push(lua_State* L, const property_wrapper<void, F>& pw) {
-				return stack::push(L, pw.write);
-			}
-		};
-
-		template <typename T>
-		struct pusher<var_wrapper<T>> {
-			static int push(lua_State* L, var_wrapper<T>&& vw) {
-				return stack::push(L, std::move(vw.value));
-			}
-			static int push(lua_State* L, const var_wrapper<T>& vw) {
-				return stack::push(L, vw.value);
-			}
-		};
-
-		template <typename... Functions>
-		struct pusher<factory_wrapper<Functions...>> {
-			static int push(lua_State* L, const factory_wrapper<Functions...>& fw) {
-				typedef function_detail::overloaded_function<0, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, fw.functions);
-				return 1;
-			}
-
-			static int push(lua_State* L, factory_wrapper<Functions...>&& fw) {
-				typedef function_detail::overloaded_function<0, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, std::move(fw.functions));
-				return 1;
-			}
-
-			static int push(lua_State* L, const factory_wrapper<Functions...>& set, function_detail::call_indicator) {
-				typedef function_detail::overloaded_function<1, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, set.functions);
-				return 1;
-			}
-
-			static int push(lua_State* L, factory_wrapper<Functions...>&& set, function_detail::call_indicator) {
-				typedef function_detail::overloaded_function<1, Functions...> F;
-				pusher<function_sig<>>{}.set_fx<F>(L, std::move(set.functions));
-				return 1;
-			}
-		};
-
-		template <>
-		struct pusher<no_construction> {
-			static int push(lua_State* L, no_construction) {
-				lua_CFunction cf = &function_detail::no_construction_error;
-				return stack::push(L, cf);
-			}
-
-			static int push(lua_State* L, no_construction c, function_detail::call_indicator) {
-				return push(L, c);
-			}
-		};
-
-		template <typename T, typename... Lists>
-		struct pusher<detail::tagged<T, constructor_list<Lists...>>> {
-			static int push(lua_State* L, detail::tagged<T, constructor_list<Lists...>>) {
-				lua_CFunction cf = call_detail::construct<T, Lists...>;
-				return stack::push(L, cf);
-			}
-		};
-
-		template <typename T, typename... Fxs>
-		struct pusher<detail::tagged<T, constructor_wrapper<Fxs...>>> {
-			template <typename C>
-			static int push(lua_State* L, C&& c) {
-				lua_CFunction cf = call_detail::call_user<T, false, false, constructor_wrapper<Fxs...>, 2>;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push<user<constructor_wrapper<Fxs...>>>(L, std::forward<C>(c));
-				return stack::push(L, c_closure(cf, upvalues));
-			}
-		};
-
-		template <typename T>
-		struct pusher<detail::tagged<T, destructor_wrapper<void>>> {
-			static int push(lua_State* L, destructor_wrapper<void>) {
-				lua_CFunction cf = detail::usertype_alloc_destroy<T>;
-				return stack::push(L, cf);
-			}
-		};
-
-		template <typename T, typename Fx>
-		struct pusher<detail::tagged<T, destructor_wrapper<Fx>>> {
-			static int push(lua_State* L, destructor_wrapper<Fx> c) {
-				lua_CFunction cf = call_detail::call_user<T, false, false, destructor_wrapper<Fx>, 2>;
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push<user<T>>(L, std::move(c));
-				return stack::push(L, c_closure(cf, upvalues));
-			}
-		};
-
-	} // stack
-} // sol
-
-// end of sol/function_types.hpp
-
-namespace sol {
-	template <typename base_t>
-	class basic_function : public base_t {
-	private:
-		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount) const {
-			lua_callk(base_t::lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), 0, nullptr);
-		}
-
-		template<std::size_t... I, typename... Ret>
-		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) const {
-			luacall(n, lua_size<std::tuple<Ret...>>::value);
-			return stack::pop<std::tuple<Ret...>>(base_t::lua_state());
-		}
-
-		template<std::size_t I, typename Ret>
-		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) const {
-			luacall(n, lua_size<Ret>::value);
-			return stack::pop<Ret>(base_t::lua_state());
-		}
-
-		template <std::size_t I>
-		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) const {
-			luacall(n, 0);
-		}
-
-		function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) const {
-			int stacksize = lua_gettop(base_t::lua_state());
-			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
-			luacall(n, LUA_MULTRET);
-			int poststacksize = lua_gettop(base_t::lua_state());
-			int returncount = poststacksize - (firstreturn - 1);
-			return function_result(base_t::lua_state(), firstreturn, returncount);
-		}
-
-	public:
-		basic_function() = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_function>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
-		basic_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_function<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				stack::check<basic_function>(base_t::lua_state(), -1, type_panic);
-			}
-#endif // Safety
-		}
-		basic_function(const basic_function&) = default;
-		basic_function& operator=(const basic_function&) = default;
-		basic_function(basic_function&&) = default;
-		basic_function& operator=(basic_function&&) = default;
-		basic_function(const stack_reference& r) : basic_function(r.lua_state(), r.stack_index()) {}
-		basic_function(stack_reference&& r) : basic_function(r.lua_state(), r.stack_index()) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
-		basic_function(lua_State* L, T&& r) : basic_function(L, sol::ref_index(r.registry_index())) {}
-		basic_function(lua_State* L, int index = -1) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_function>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_function(lua_State* L, ref_index index) : base_t(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_function>(L, -1, type_panic);
-#endif // Safety
-		}
-
-		template<typename... Args>
-		function_result operator()(Args&&... args) const {
-			return call<>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
-			return call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) const {
-			base_t::push();
-			int pushcount = stack::multi_push_reference(base_t::lua_state(), std::forward<Args>(args)...);
-			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
-		}
-	};
-
-	namespace stack {
-		template<typename Signature>
-		struct getter<std::function<Signature>> {
-			typedef meta::bind_traits<Signature> fx_t;
-			typedef typename fx_t::args_list args_lists;
-			typedef meta::tuple_types<typename fx_t::return_type> return_types;
-
-			template<typename... Args, typename... Ret>
-			static std::function<Signature> get_std_func(types<Ret...>, types<Args...>, lua_State* L, int index) {
-				sol::function f(L, index);
-				auto fx = [f, L, index](Args&&... args) -> meta::return_type_t<Ret...> {
-					return f.call<Ret...>(std::forward<Args>(args)...);
-				};
-				return std::move(fx);
-			}
-
-			template<typename... FxArgs>
-			static std::function<Signature> get_std_func(types<void>, types<FxArgs...>, lua_State* L, int index) {
-				sol::function f(L, index);
-				auto fx = [f, L, index](FxArgs&&... args) -> void {
-					f(std::forward<FxArgs>(args)...);
-				};
-				return std::move(fx);
-			}
-
-			template<typename... FxArgs>
-			static std::function<Signature> get_std_func(types<>, types<FxArgs...> t, lua_State* L, int index) {
-				return get_std_func(types<void>(), t, L, index);
-			}
-
-			static std::function<Signature> get(lua_State* L, int index, record& tracking) {
-				tracking.last = 1;
-				tracking.used += 1;
-				type t = type_of(L, index);
-				if (t == type::none || t == type::lua_nil) {
-					return nullptr;
-				}
-				return get_std_func(return_types(), args_lists(), L, index);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/function.hpp
-
-// beginning of sol/protected_function.hpp
-
-// beginning of sol/protected_function_result.hpp
-
-namespace sol {
-	struct protected_function_result : public proxy_base<protected_function_result> {
-	private:
-		lua_State* L;
-		int index;
-		int returncount;
-		int popcount;
-		call_status err;
-
-		template <typename T>
-		decltype(auto) tagged_get(types<optional<T>>) const {
-			if (!valid()) {
-				return optional<T>(nullopt);
-			}
-			return stack::get<optional<T>>(L, index);
-		}
-
-		template <typename T>
-		decltype(auto) tagged_get(types<T>) const {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!valid()) {
-				type_panic(L, index, type_of(L, index), type::none);
-			}
-#endif // Check Argument Safety
-			return stack::get<T>(L, index);
-		}
-
-		optional<error> tagged_get(types<optional<error>>) const {
-			if (valid()) {
-				return nullopt;
-			}
-			return error(detail::direct_error, stack::get<std::string>(L, index));
-		}
-
-		error tagged_get(types<error>) const {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (valid()) {
-				type_panic(L, index, type_of(L, index), type::none);
-			}
-#endif // Check Argument Safety
-			return error(detail::direct_error, stack::get<std::string>(L, index));
-		}
-
-	public:
-		protected_function_result() = default;
-		protected_function_result(lua_State* Ls, int idx = -1, int retnum = 0, int popped = 0, call_status pferr = call_status::ok) noexcept : L(Ls), index(idx), returncount(retnum), popcount(popped), err(pferr) {
-
-		}
-		protected_function_result(const protected_function_result&) = default;
-		protected_function_result& operator=(const protected_function_result&) = default;
-		protected_function_result(protected_function_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but we will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-			o.popcount = 0;
-			o.err = call_status::runtime;
-		}
-		protected_function_result& operator=(protected_function_result&& o) noexcept {
-			L = o.L;
-			index = o.index;
-			returncount = o.returncount;
-			popcount = o.popcount;
-			err = o.err;
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but we will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-			o.popcount = 0;
-			o.err = call_status::runtime;
-			return *this;
-		}
-
-		call_status status() const noexcept {
-			return err;
-		}
-
-		bool valid() const noexcept {
-			return status() == call_status::ok || status() == call_status::yielded;
-		}
-
-		template<typename T>
-		decltype(auto) get() const {
-			return tagged_get(types<meta::unqualified_t<T>>());
-		}
-
-		lua_State* lua_state() const noexcept { return L; };
-		int stack_index() const noexcept { return index; };
-
-		~protected_function_result() {
-			stack::remove(L, index, popcount);
-		}
-	};
-} // sol
-
-// end of sol/protected_function_result.hpp
-
-#include <algorithm>
-
-namespace sol {
-	namespace detail {
-		inline reference& handler_storage() {
-			static sol::reference h;
-			return h;
-		}
-
-		struct handler {
-			const reference& target;
-			int stackindex;
-			handler(const reference& target) : target(target), stackindex(0) {
-				if (target.valid()) {
-					stackindex = lua_gettop(target.lua_state()) + 1;
-					target.push();
-				}
-			}
-			bool valid() const { return stackindex != 0; }
-			~handler() {
-				if (valid()) {
-					lua_remove(target.lua_state(), stackindex);
-				}
-			}
-		};
-	}
-	
-	template <typename base_t>
-	class basic_protected_function : public base_t {
-	public:
-		static reference& get_default_handler() {
-			return detail::handler_storage();
-		}
-
-		static void set_default_handler(const reference& ref) {
-			detail::handler_storage() = ref;
-		}
-
-		static void set_default_handler(reference&& ref) {
-			detail::handler_storage() = std::move(ref);
-		}
-
-	private:
-		call_status luacall(std::ptrdiff_t argcount, std::ptrdiff_t resultcount, detail::handler& h) const {
-			return static_cast<call_status>(lua_pcallk(base_t::lua_state(), static_cast<int>(argcount), static_cast<int>(resultcount), h.stackindex, 0, nullptr));
-		}
-
-		template<std::size_t... I, typename... Ret>
-		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n, detail::handler& h) const {
-			luacall(n, sizeof...(Ret), h);
-			return stack::pop<std::tuple<Ret...>>(base_t::lua_state());
-		}
-
-		template<std::size_t I, typename Ret>
-		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n, detail::handler& h) const {
-			luacall(n, 1, h);
-			return stack::pop<Ret>(base_t::lua_state());
-		}
-
-		template <std::size_t I>
-		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n, detail::handler& h) const {
-			luacall(n, 0, h);
-		}
-
-		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n, detail::handler& h) const {
-			int stacksize = lua_gettop(base_t::lua_state());
-			int poststacksize = stacksize;
-			int firstreturn = 1;
-			int returncount = 0;
-			call_status code = call_status::ok;
-#ifndef SOL_NO_EXCEPTIONS
-			auto onexcept = [&](const char* error) {
-				h.stackindex = 0;
-				if (h.target.valid()) {
-					h.target.push();
-					stack::push(base_t::lua_state(), error);
-					lua_call(base_t::lua_state(), 1, 1);
-				}
-				else {
-					stack::push(base_t::lua_state(), error);
-				}
-			};
-			try {
-#endif // No Exceptions
-				firstreturn = (std::max)(1, static_cast<int>(stacksize - n - static_cast<int>(h.valid())));
-				code = luacall(n, LUA_MULTRET, h);
-				poststacksize = lua_gettop(base_t::lua_state()) - static_cast<int>(h.valid());
-				returncount = poststacksize - (firstreturn - 1);
-#ifndef SOL_NO_EXCEPTIONS
-			}
-			// Handle C++ errors thrown from C++ functions bound inside of lua
-			catch (const char* error) {
-				onexcept(error);
-				firstreturn = lua_gettop(base_t::lua_state());
-				return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
-			}
-			catch (const std::exception& error) {
-				onexcept(error.what());
-				firstreturn = lua_gettop(base_t::lua_state());
-				return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
-			}
-			catch (...) {
-				onexcept("caught (...) unknown error during protected_function call");
-				firstreturn = lua_gettop(base_t::lua_state());
-				return protected_function_result(base_t::lua_state(), firstreturn, 0, 1, call_status::runtime);
-			}
-#endif // No Exceptions
-			return protected_function_result(base_t::lua_state(), firstreturn, returncount, returncount, code);
-		}
-
-	public:
-		reference error_handler;
-
-		basic_protected_function() = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_protected_function>>, meta::neg<std::is_same<base_t, stack_reference>>, std::is_base_of<base_t, meta::unqualified_t<T>>> = meta::enabler>
-		basic_protected_function(T&& r) noexcept : base_t(std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_function<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				stack::check<basic_protected_function>(base_t::lua_state(), -1, type_panic);
-			}
-#endif // Safety
-		}
-		basic_protected_function(const basic_protected_function&) = default;
-		basic_protected_function& operator=(const basic_protected_function&) = default;
-		basic_protected_function(basic_protected_function&&) = default;
-		basic_protected_function& operator=(basic_protected_function&&) = default;
-		basic_protected_function(const basic_function<base_t>& b, reference eh = get_default_handler()) : base_t(b), error_handler(std::move(eh)) {}
-		basic_protected_function(basic_function<base_t>&& b, reference eh = get_default_handler()) : base_t(std::move(b)), error_handler(std::move(eh)) {}
-		basic_protected_function(const stack_reference& r, reference eh = get_default_handler()) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {}
-		basic_protected_function(stack_reference&& r, reference eh = get_default_handler()) : basic_protected_function(r.lua_state(), r.stack_index(), std::move(eh)) {}
-		template <typename Super>
-		basic_protected_function(proxy_base<Super>&& p, reference eh = get_default_handler()) : basic_protected_function(p.operator basic_function<base_t>(), std::move(eh)) {}
-		template <typename Super>
-		basic_protected_function(const proxy_base<Super>& p, reference eh = get_default_handler()) : basic_protected_function(p.operator basic_function<base_t>(), std::move(eh)) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
-		basic_protected_function(lua_State* L, T&& r, reference eh) : basic_protected_function(L, sol::ref_index(r.registry_index()), std::move(eh)) {}
-		basic_protected_function(lua_State* L, int index = -1, reference eh = get_default_handler()) : base_t(L, index), error_handler(std::move(eh)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_protected_function>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_protected_function(lua_State* L, ref_index index, reference eh = get_default_handler()) : base_t(L, index), error_handler(std::move(eh)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_protected_function>(L, -1, type_panic);
-#endif // Safety
-		}
-
-		template<typename... Args>
-		protected_function_result operator()(Args&&... args) const {
-			return call<>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) operator()(types<Ret...>, Args&&... args) const {
-			return call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) const {
-			detail::handler h(error_handler);
-			base_t::push();
-			int pushcount = stack::multi_push_reference(base_t::lua_state(), std::forward<Args>(args)...);
-			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount, h);
-		}
-	};
-} // sol
-
-// end of sol/protected_function.hpp
-
-namespace sol {
-	struct stack_proxy : public proxy_base<stack_proxy> {
-	private:
-		lua_State* L;
-		int index;
-
-	public:
-		stack_proxy() : L(nullptr), index(0) {}
-		stack_proxy(lua_State* L, int index) : L(L), index(index) {}
-
-		template<typename T>
-		decltype(auto) get() const {
-			return stack::get<T>(L, stack_index());
-		}
-
-		int push() const {
-			return push(L);
-		}
-
-		int push(lua_State* Ls) const {
-			lua_pushvalue(Ls, index);
-			return 1;
-		}
-
-		lua_State* lua_state() const { return L; }
-		int stack_index() const { return index; }
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) {
-			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Args>
-		decltype(auto) operator()(Args&&... args) {
-			return call<>(std::forward<Args>(args)...);
-		}
-	};
-
-	namespace stack {
-		template <>
-		struct getter<stack_proxy> {
-			static stack_proxy get(lua_State* L, int index = -1) {
-				return stack_proxy(L, index);
-			}
-		};
-
-		template <>
-		struct pusher<stack_proxy> {
-			static int push(lua_State*, const stack_proxy& ref) {
-				return ref.push();
-			}
-		};
-	} // stack
-
-	namespace detail {
-		template <>
-		struct is_speshul<function_result> : std::true_type {};
-		template <>
-		struct is_speshul<protected_function_result> : std::true_type {};
-
-		template <std::size_t I, typename... Args, typename T>
-		stack_proxy get(types<Args...>, index_value<0>, index_value<I>, const T& fr) {
-			return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
-		}
-
-		template <std::size_t I, std::size_t N, typename Arg, typename... Args, typename T, meta::enable<meta::boolean<(N > 0)>> = meta::enabler>
-		stack_proxy get(types<Arg, Args...>, index_value<N>, index_value<I>, const T& fr) {
-			return get(types<Args...>(), index_value<N - 1>(), index_value<I + lua_size<Arg>::value>(), fr);
-		}
-	}
-
-	template <>
-	struct tie_size<function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
-
-	template <std::size_t I>
-	stack_proxy get(const function_result& fr) {
-		return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
-	}
-
-	template <std::size_t I, typename... Args>
-	stack_proxy get(types<Args...> t, const function_result& fr) {
-		return detail::get(t, index_value<I>(), index_value<0>(), fr);
-	}
-
-	template <>
-	struct tie_size<protected_function_result> : std::integral_constant<std::size_t, SIZE_MAX> {};
-
-	template <std::size_t I>
-	stack_proxy get(const protected_function_result& fr) {
-		return stack_proxy(fr.lua_state(), static_cast<int>(fr.stack_index() + I));
-	}
-
-	template <std::size_t I, typename... Args>
-	stack_proxy get(types<Args...> t, const protected_function_result& fr) {
-		return detail::get(t, index_value<I>(), index_value<0>(), fr);
-	}
-} // sol
-
-// end of sol/stack_proxy.hpp
-
-#include <limits>
-
-namespace sol {
-	template <bool is_const>
-	struct va_iterator : std::iterator<std::random_access_iterator_tag, std::conditional_t<is_const, const stack_proxy, stack_proxy>, std::ptrdiff_t, std::conditional_t<is_const, const stack_proxy*, stack_proxy*>, std::conditional_t<is_const, const stack_proxy, stack_proxy>> {
-		typedef std::iterator<std::random_access_iterator_tag, std::conditional_t<is_const, const stack_proxy, stack_proxy>, std::ptrdiff_t, std::conditional_t<is_const, const stack_proxy*, stack_proxy*>, std::conditional_t<is_const, const stack_proxy, stack_proxy>> base_t;
-		typedef typename base_t::reference reference;
-		typedef typename base_t::pointer pointer;
-		typedef typename base_t::value_type value_type;
-		typedef typename base_t::difference_type difference_type;
-		typedef typename base_t::iterator_category iterator_category;
-		lua_State* L;
-		int index;
-		int stacktop;
-		stack_proxy sp;
-
-		va_iterator() : L(nullptr), index((std::numeric_limits<int>::max)()), stacktop((std::numeric_limits<int>::max)()) {}
-		va_iterator(lua_State* luastate, int idx, int topidx) : L(luastate), index(idx), stacktop(topidx), sp(luastate, idx) {}
-
-		reference operator*() {
-			return stack_proxy(L, index);
-		}
-
-		pointer operator->() {
-			sp = stack_proxy(L, index);
-			return &sp;
-		}
-
-		va_iterator& operator++ () {
-			++index;
-			return *this;
-		}
-
-		va_iterator operator++ (int) {
-			auto r = *this;
-			this->operator ++();
-			return r;
-		}
-
-		va_iterator& operator-- () {
-			--index;
-			return *this;
-		}
-
-		va_iterator operator-- (int) {
-			auto r = *this;
-			this->operator --();
-			return r;
-		}
-
-		va_iterator& operator+= (difference_type idx) {
-			index += static_cast<int>(idx);
-			return *this;
-		}
-
-		va_iterator& operator-= (difference_type idx) {
-			index -= static_cast<int>(idx);
-			return *this;
-		}
-
-		difference_type operator- (const va_iterator& r) const {
-			return index - r.index;
-		}
-
-		va_iterator operator+ (difference_type idx) const {
-			va_iterator r = *this;
-			r += idx;
-			return r;
-		}
-
-		reference operator[](difference_type idx) {
-			return stack_proxy(L, index + static_cast<int>(idx));
-		}
-
-		bool operator==(const va_iterator& r) const {
-			if (stacktop == (std::numeric_limits<int>::max)()) {
-				return r.index == r.stacktop;
-			}
-			else if (r.stacktop == (std::numeric_limits<int>::max)()) {
-				return index == stacktop;
-			}
-			return index == r.index;
-		}
-
-		bool operator != (const va_iterator& r) const {
-			return !(this->operator==(r));
-		}
-
-		bool operator < (const va_iterator& r) const {
-			return index < r.index;
-		}
-
-		bool operator > (const va_iterator& r) const {
-			return index > r.index;
-		}
-
-		bool operator <= (const va_iterator& r) const {
-			return index <= r.index;
-		}
-
-		bool operator >= (const va_iterator& r) const {
-			return index >= r.index;
-		}
-	};
-
-	template <bool is_const>
-	inline va_iterator<is_const> operator+(typename va_iterator<is_const>::difference_type n, const va_iterator<is_const>& r) {
-		return r + n;
-	}
-
-	struct variadic_args {
-	private:
-		lua_State* L;
-		int index;
-		int stacktop;
-
-	public:
-		typedef stack_proxy reference_type;
-		typedef stack_proxy value_type;
-		typedef stack_proxy* pointer;
-		typedef std::ptrdiff_t difference_type;
-		typedef std::size_t size_type;
-		typedef va_iterator<false> iterator;
-		typedef va_iterator<true> const_iterator;
-		typedef std::reverse_iterator<iterator> reverse_iterator;
-		typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-
-		variadic_args() = default;
-		variadic_args(lua_State* luastate, int stackindex = -1) : L(luastate), index(lua_absindex(luastate, stackindex)), stacktop(lua_gettop(luastate)) {}
-		variadic_args(const variadic_args&) = default;
-		variadic_args& operator=(const variadic_args&) = default;
-		variadic_args(variadic_args&& o) : L(o.L), index(o.index), stacktop(o.stacktop) {
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.stacktop = 0;
-		}
-		variadic_args& operator=(variadic_args&& o) {
-			L = o.L;
-			index = o.index;
-			stacktop = o.stacktop;
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.stacktop = 0;
-			return *this;
-		}
-
-		iterator begin() { return iterator(L, index, stacktop + 1); }
-		iterator end() { return iterator(L, stacktop + 1, stacktop + 1); }
-		const_iterator begin() const { return const_iterator(L, index, stacktop + 1); }
-		const_iterator end() const { return const_iterator(L, stacktop + 1, stacktop + 1); }
-		const_iterator cbegin() const { return begin(); }
-		const_iterator cend() const { return end(); }
-
-		reverse_iterator rbegin() { return std::reverse_iterator<iterator>(begin()); }
-		reverse_iterator rend() { return std::reverse_iterator<iterator>(end()); }
-		const_reverse_iterator rbegin() const { return std::reverse_iterator<const_iterator>(begin()); }
-		const_reverse_iterator rend() const { return std::reverse_iterator<const_iterator>(end()); }
-		const_reverse_iterator crbegin() const { return std::reverse_iterator<const_iterator>(cbegin()); }
-		const_reverse_iterator crend() const { return std::reverse_iterator<const_iterator>(cend()); }
-
-		int push() const {
-			return push(L);
-		}
-
-		int push(lua_State* target) const {
-			int pushcount = 0;
-			for (int i = index; i <= stacktop; ++i) {
-				lua_pushvalue(L, i);
-				pushcount += 1;
-			}
-			if (target != L) {
-				lua_xmove(L, target, pushcount);
-			}
-			return pushcount;
-		}
-
-		template<typename T>
-		decltype(auto) get(difference_type start = 0) const {
-			return stack::get<T>(L, index + static_cast<int>(start));
-		}
-
-		stack_proxy operator[](difference_type start) const {
-			return stack_proxy(L, index + static_cast<int>(start));
-		}
-
-		lua_State* lua_state() const { return L; };
-		int stack_index() const { return index; };
-		int leftover_count() const { return stacktop - (index - 1); }
-		int top() const { return stacktop; }
-	};
-
-	namespace stack {
-		template <>
-		struct getter<variadic_args> {
-			static variadic_args get(lua_State* L, int index, record& tracking) {
-				tracking.last = 0;
-				return variadic_args(L, index);
-			}
-		};
-
-		template <>
-		struct pusher<variadic_args> {
-			static int push(lua_State* L, const variadic_args& ref) {
-				return ref.push(L);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/variadic_args.hpp
-
-namespace sol {
-
-	template <typename R = reference, bool should_pop = !std::is_base_of<stack_reference, R>::value, typename T>
-	R make_reference(lua_State* L, T&& value) {
-		int backpedal = stack::push(L, std::forward<T>(value));
-		R r = stack::get<R>(L, -backpedal);
-		if (should_pop) {
-			lua_pop(L, backpedal);
-		}
-		return r;
-	}
-
-	template <typename T, typename R = reference, bool should_pop = !std::is_base_of<stack_reference, R>::value, typename... Args>
-	R make_reference(lua_State* L, Args&&... args) {
-		int backpedal = stack::push<T>(L, std::forward<Args>(args)...);
-		R r = stack::get<R>(L, -backpedal);
-		if (should_pop) {
-			lua_pop(L, backpedal);
-		}
-		return r;
-	}
-
-	template <typename base_type>
-	class basic_object : public basic_object_base<base_type> {
-	private:
-		typedef basic_object_base<base_type> base_t;
-
-		template <bool invert_and_pop = false>
-		basic_object(std::integral_constant<bool, invert_and_pop>, lua_State* L, int index = -1) noexcept : base_t(L, index) {
-			if (invert_and_pop) {
-				lua_pop(L, -index);
-			}
-		}
-
-	public:
-		basic_object() noexcept = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, basic_object>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_object(T&& r) : base_t(std::forward<T>(r)) {}
-		basic_object(lua_nil_t r) : base_t(r) {}
-		basic_object(const basic_object&) = default;
-		basic_object(basic_object&&) = default;
-		basic_object(const stack_reference& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {}
-		basic_object(stack_reference&& r) noexcept : basic_object(r.lua_state(), r.stack_index()) {}
-		template <typename Super>
-		basic_object(const proxy_base<Super>& r) noexcept : basic_object(r.operator basic_object()) {}
-		template <typename Super>
-		basic_object(proxy_base<Super>&& r) noexcept : basic_object(r.operator basic_object()) {}
-		basic_object(lua_State* L, int index = -1) noexcept : base_t(L, index) {}
-		basic_object(lua_State* L, ref_index index) noexcept : base_t(L, index) {}
-		template <typename T, typename... Args>
-		basic_object(lua_State* L, in_place_type_t<T>, Args&&... args) noexcept : basic_object(std::integral_constant<bool, !std::is_base_of<stack_reference, base_t>::value>(), L, -stack::push<T>(L, std::forward<Args>(args)...)) {}
-		template <typename T, typename... Args>
-		basic_object(lua_State* L, in_place_t, T&& arg, Args&&... args) noexcept : basic_object(L, in_place<T>, std::forward<T>(arg), std::forward<Args>(args)...) {}
-		basic_object& operator=(const basic_object&) = default;
-		basic_object& operator=(basic_object&&) = default;
-		basic_object& operator=(const base_type& b) { base_t::operator=(b); return *this; }
-		basic_object& operator=(base_type&& b) { base_t::operator=(std::move(b)); return *this; }
-		template <typename Super>
-		basic_object& operator=(const proxy_base<Super>& r) { this->operator=(r.operator basic_object()); return *this; }
-		template <typename Super>
-		basic_object& operator=(proxy_base<Super>&& r) { this->operator=(r.operator basic_object()); return *this; }
-	};
-
-	template <typename T>
-	object make_object(lua_State* L, T&& value) {
-		return make_reference<object, true>(L, std::forward<T>(value));
-	}
-
-	template <typename T, typename... Args>
-	object make_object(lua_State* L, Args&&... args) {
-		return make_reference<T, object, true>(L, std::forward<Args>(args)...);
-	}
-} // sol
-
-// end of sol/object.hpp
-
-namespace sol {
-	template<typename Table, typename Key>
-	struct proxy : public proxy_base<proxy<Table, Key>> {
-	private:
-		typedef meta::condition<meta::is_specialization_of<std::tuple, Key>, Key, std::tuple<meta::condition<std::is_array<meta::unqualified_t<Key>>, Key&, meta::unqualified_t<Key>>>> key_type;
-
-		template<typename T, std::size_t... I>
-		decltype(auto) tuple_get(std::index_sequence<I...>) const {
-			return tbl.template traverse_get<T>(std::get<I>(key)...);
-		}
-
-		template<std::size_t... I, typename T>
-		void tuple_set(std::index_sequence<I...>, T&& value) {
-			tbl.traverse_set(std::get<I>(key)..., std::forward<T>(value));
-		}
-
-	public:
-		Table tbl;
-		key_type key;
-
-		template<typename T>
-		proxy(Table table, T&& k) : tbl(table), key(std::forward<T>(k)) {}
-
-		template<typename T>
-		proxy& set(T&& item) {
-			tuple_set(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>(), std::forward<T>(item));
-			return *this;
-		}
-
-		template<typename... Args>
-		proxy& set_function(Args&&... args) {
-			tbl.set_function(key, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename U, meta::enable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler>
-		proxy& operator=(U&& other) {
-			return set_function(std::forward<U>(other));
-		}
-
-		template<typename U, meta::disable<meta::neg<is_lua_reference<meta::unwrap_unqualified_t<U>>>, meta::is_callable<meta::unwrap_unqualified_t<U>>> = meta::enabler>
-		proxy& operator=(U&& other) {
-			return set(std::forward<U>(other));
-		}
-
-		template<typename T>
-		decltype(auto) get() const {
-			return tuple_get<T>(std::make_index_sequence<std::tuple_size<meta::unqualified_t<key_type>>::value>());
-		}
-
-		template<typename T>
-		decltype(auto) get_or(T&& otherwise) const {
-			typedef decltype(get<T>()) U;
-			optional<U> option = get<optional<U>>();
-			if (option) {
-				return static_cast<U>(option.value());
-			}
-			return static_cast<U>(std::forward<T>(otherwise));
-		}
-
-		template<typename T, typename D>
-		decltype(auto) get_or(D&& otherwise) const {
-			optional<T> option = get<optional<T>>();
-			if (option) {
-				return static_cast<T>(option.value());
-			}
-			return static_cast<T>(std::forward<D>(otherwise));
-		}
-
-		template <typename K>
-		decltype(auto) operator[](K&& k) const {
-			auto keys = meta::tuplefy(key, std::forward<K>(k));
-			return proxy<Table, decltype(keys)>(tbl, std::move(keys));
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) {
-			return get<function>().template call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Args>
-		decltype(auto) operator()(Args&&... args) {
-			return call<>(std::forward<Args>(args)...);
-		}
-
-		bool valid() const {
-			auto pp = stack::push_pop(tbl);
-			auto p = stack::probe_get_field<std::is_same<meta::unqualified_t<Table>, global_table>::value>(tbl.lua_state(), key, lua_gettop(tbl.lua_state()));
-			lua_pop(tbl.lua_state(), p.levels);
-			return p;
-		}
-	};
-
-	template<typename Table, typename Key, typename T>
-	inline bool operator==(T&& left, const proxy<Table, Key>& right) {
-		typedef decltype(stack::get<T>(nullptr, 0)) U;
-		return right.template get<optional<U>>() == left;
-	}
-
-	template<typename Table, typename Key, typename T>
-	inline bool operator==(const proxy<Table, Key>& right, T&& left) {
-		typedef decltype(stack::get<T>(nullptr, 0)) U;
-		return right.template get<optional<U>>() == left;
-	}
-
-	template<typename Table, typename Key, typename T>
-	inline bool operator!=(T&& left, const proxy<Table, Key>& right) {
-		typedef decltype(stack::get<T>(nullptr, 0)) U;
-		return right.template get<optional<U>>() == left;
-	}
-
-	template<typename Table, typename Key, typename T>
-	inline bool operator!=(const proxy<Table, Key>& right, T&& left) {
-		typedef decltype(stack::get<T>(nullptr, 0)) U;
-		return right.template get<optional<U>>() == left;
-	}
-
-	template<typename Table, typename Key>
-	inline bool operator==(lua_nil_t, const proxy<Table, Key>& right) {
-		return !right.valid();
-	}
-
-	template<typename Table, typename Key>
-	inline bool operator==(const proxy<Table, Key>& right, lua_nil_t) {
-		return !right.valid();
-	}
-
-	template<typename Table, typename Key>
-	inline bool operator!=(lua_nil_t, const proxy<Table, Key>& right) {
-		return right.valid();
-	}
-
-	template<typename Table, typename Key>
-	inline bool operator!=(const proxy<Table, Key>& right, lua_nil_t) {
-		return right.valid();
-	}
-
-	namespace stack {
-		template <typename Table, typename Key>
-		struct pusher<proxy<Table, Key>> {
-			static int push(lua_State* L, const proxy<Table, Key>& p) {
-				sol::reference r = p;
-				return r.push(L);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/proxy.hpp
-
-// beginning of sol/usertype.hpp
-
-// beginning of sol/usertype_metatable.hpp
-
-// beginning of sol/deprecate.hpp
-
-#ifndef SOL_DEPRECATED
-    #ifdef _MSC_VER
-        #define SOL_DEPRECATED __declspec(deprecated)
-    #elif __GNUC__
-        #define SOL_DEPRECATED __attribute__((deprecated)) 
-    #else
-        #define SOL_DEPRECATED [[deprecated]]
-    #endif // compilers
-#endif // SOL_DEPRECATED
-
-namespace sol {
-	namespace detail {
-		template <typename T>
-		struct SOL_DEPRECATED deprecate_type {
-			using type = T;
-		};
-	} // detail
-} // sol
-
-// end of sol/deprecate.hpp
-
-#include <unordered_map>
-#include <cstdio>
-
-namespace sol {
-	namespace usertype_detail {
-		const int metatable_index = 2;
-		const int metatable_core_index = 3;
-		const int filler_index = 4;
-		const int magic_index = 5;
-
-		const int simple_metatable_index = 2;
-		const int index_function_index = 3;
-		const int newindex_function_index = 4;
-
-		typedef void(*base_walk)(lua_State*, bool&, int&, string_detail::string_shim&);
-		typedef int(*member_search)(lua_State*, void*, int);
-
-		struct call_information {
-			member_search index;
-			member_search new_index;
-			int runtime_target;
-
-			call_information(member_search index, member_search newindex) : call_information(index, newindex, -1) {}
-			call_information(member_search index, member_search newindex, int runtimetarget) : index(index), new_index(newindex), runtime_target(runtimetarget) {}
-		};
-
-		typedef std::unordered_map<std::string, call_information> mapping_t;
-		
-		struct variable_wrapper {
-			virtual int index(lua_State* L) = 0;
-			virtual int new_index(lua_State* L) = 0;
-			virtual ~variable_wrapper() {};
-		};
-
-		template <typename T, typename F>
-		struct callable_binding : variable_wrapper {
-			F fx;
-
-			template <typename Arg>
-			callable_binding(Arg&& arg) : fx(std::forward<Arg>(arg)) {}
-
-			virtual int index(lua_State* L) override {
-				return call_detail::call_wrapped<T, true, true>(L, fx);
-			}
-
-			virtual int new_index(lua_State* L) override {
-				return call_detail::call_wrapped<T, false, true>(L, fx);
-			}
-		};
-
-		typedef std::unordered_map<std::string, std::unique_ptr<variable_wrapper>> variable_map;
-		typedef std::unordered_map<std::string, object> function_map;
-
-		struct simple_map {
-			const char* metakey;
-			variable_map variables;
-			function_map functions;
-			object index;
-			object newindex;
-			base_walk indexbaseclasspropogation;
-			base_walk newindexbaseclasspropogation;
-
-			simple_map(const char* mkey, base_walk index, base_walk newindex, object i, object ni, variable_map&& vars, function_map&& funcs) 
-			: metakey(mkey), variables(std::move(vars)), functions(std::move(funcs)), 
-			index(std::move(i)), newindex(std::move(ni)),
-			indexbaseclasspropogation(index), newindexbaseclasspropogation(newindex) {}
-		};
-	}
-
-	struct usertype_metatable_core {
-		usertype_detail::mapping_t mapping;
-		lua_CFunction indexfunc;
-		lua_CFunction newindexfunc;
-		std::vector<object> runtime;
-		bool mustindex;
-
-		usertype_metatable_core(lua_CFunction ifx, lua_CFunction nifx) :
-			mapping(), indexfunc(ifx),
-			newindexfunc(nifx), runtime(), mustindex(false)
-		{
-
-		}
-
-		usertype_metatable_core(const usertype_metatable_core&) = default;
-		usertype_metatable_core(usertype_metatable_core&&) = default;
-		usertype_metatable_core& operator=(const usertype_metatable_core&) = default;
-		usertype_metatable_core& operator=(usertype_metatable_core&&) = default;
-
-	};
-
-	namespace usertype_detail {
-		const lua_Integer toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1);
-
-		struct add_destructor_tag {};
-		struct check_destructor_tag {};
-		struct verified_tag {} const verified{};
-
-		template <typename T>
-		struct is_non_factory_constructor : std::false_type {};
-
-		template <typename... Args>
-		struct is_non_factory_constructor<constructors<Args...>> : std::true_type {};
-
-		template <typename... Args>
-		struct is_non_factory_constructor<constructor_wrapper<Args...>> : std::true_type {};
-
-		template <>
-		struct is_non_factory_constructor<no_construction> : std::true_type {};
-
-		template <typename T>
-		struct is_constructor : is_non_factory_constructor<T> {};
-
-		template <typename... Args>
-		struct is_constructor<factory_wrapper<Args...>> : std::true_type {};
-
-		template <typename... Args>
-		using has_constructor = meta::any<is_constructor<meta::unqualified_t<Args>>...>;
-
-		template <typename T>
-		struct is_destructor : std::false_type {};
-
-		template <typename Fx>
-		struct is_destructor<destructor_wrapper<Fx>> : std::true_type {};
-
-		template <typename... Args>
-		using has_destructor = meta::any<is_destructor<meta::unqualified_t<Args>>...>;
-
-		struct no_comp {
-			template <typename A, typename B>
-			bool operator()(A&&, B&&) const {
-				return false;
-			}
-		};
-
-		inline int is_indexer(string_detail::string_shim s) {
-			if (s == to_string(meta_function::index)) {
-				return 1;
-			}
-			else if (s == to_string(meta_function::new_index)) {
-				return 2;
-			}
-			return  0;
-		}
-
-		inline int is_indexer(meta_function mf) {
-			if (mf == meta_function::index) {
-				return 1;
-			}
-			else if (mf == meta_function::new_index) {
-				return 2;
-			}
-			return 0;
-		}
-
-		inline int is_indexer(call_construction) {
-			return 0;
-		}
-
-		inline int is_indexer(base_classes_tag) {
-			return 0;
-		}
-
-		inline auto make_shim(string_detail::string_shim s) {
-			return s;
-		}
-
-		inline auto make_shim(call_construction) {
-			return string_detail::string_shim(to_string(meta_function::call_function));
-		}
-
-		inline auto make_shim(meta_function mf) {
-			return string_detail::string_shim(to_string(mf));
-		}
-
-		inline auto make_shim(base_classes_tag) {
-			return string_detail::string_shim(detail::base_class_cast_key());
-		}
-
-		template <typename Arg>
-		inline std::string make_string(Arg&& arg) {
-			string_detail::string_shim s = make_shim(arg);
-			return std::string(s.c_str(), s.size());
-		}
-
-		template <typename N>
-		inline luaL_Reg make_reg(N&& n, lua_CFunction f) {
-			luaL_Reg l{ make_shim(std::forward<N>(n)).c_str(), f };
-			return l;
-		}
-
-		struct registrar {
-			registrar() = default;
-			registrar(const registrar&) = default;
-			registrar(registrar&&) = default;
-			registrar& operator=(const registrar&) = default;
-			registrar& operator=(registrar&&) = default;
-			virtual int push_um(lua_State* L) = 0;
-			virtual ~registrar() {}
-		};
-
-		inline bool is_toplevel(lua_State* L, int index = magic_index) {
-			int isnum = 0;
-			lua_Integer magic = lua_tointegerx(L, upvalue_index(index), &isnum);
-			return isnum != 0 && magic == toplevel_magic;
-		}
-
-		inline int runtime_object_call(lua_State* L, void*, int runtimetarget) {
-			usertype_metatable_core& umc = stack::get<light<usertype_metatable_core>>(L, upvalue_index(metatable_core_index));
-			std::vector<object>& runtime = umc.runtime;
-			object& runtimeobj = runtime[runtimetarget];
-			return stack::push(L, runtimeobj);
-		}
-
-		template <typename T, bool is_index>
-		inline int indexing_fail(lua_State* L) {
-			if (is_index) {
-#if 0//def SOL_SAFE_USERTYPE
-				auto maybeaccessor = stack::get<optional<string_detail::string_shim>>(L, is_index ? -1 : -2);
-				string_detail::string_shim accessor = maybeaccessor.value_or(string_detail::string_shim("(unknown)"));
-				return luaL_error(L, "sol: attempt to index (get) nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.c_str());
-#else
-				if (is_toplevel(L)) {
-					if (lua_getmetatable(L, 1) == 1) {
-						int metatarget = lua_gettop(L);
-						stack::get_field(L, stack_reference(L, raw_index(2)), metatarget);
-						return 1;
-					}
-				}
-				// With runtime extensibility, we can't hard-error things. They have to return nil, like regular table types, unfortunately...
-				return stack::push(L, lua_nil);
-#endif
-			}
-			else {
-				auto maybeaccessor = stack::get<optional<string_detail::string_shim>>(L, is_index ? -1 : -2);
-				string_detail::string_shim accessor = maybeaccessor.value_or(string_detail::string_shim("(unknown)"));
-				return luaL_error(L, "sol: attempt to index (set) nil value \"%s\" on userdata (bad (misspelled?) key name or does not exist)", accessor.c_str());
-			}
-		}
-
-		int runtime_new_index(lua_State* L, void*, int runtimetarget);
-
-		template <typename T, bool is_simple>
-		inline int metatable_newindex(lua_State* L) {
-			if (is_toplevel(L)) {
-				auto non_indexable = [&L]() {
-					if (is_simple) {
-						simple_map& sm = stack::get<user<simple_map>>(L, upvalue_index(simple_metatable_index));
-						function_map& functions = sm.functions;
-						optional<std::string> maybeaccessor = stack::get<optional<std::string>>(L, 2);
-						if (!maybeaccessor) {
-							return;
-						}
-						std::string& accessor = maybeaccessor.value();
-						auto preexistingit = functions.find(accessor);
-						if (preexistingit == functions.cend()) {
-							functions.emplace_hint(preexistingit, std::move(accessor), sol::object(L, 3));
-						}
-						else {
-							preexistingit->second = sol::object(L, 3);
-						}
-						return;
-					}
-					usertype_metatable_core& umc = stack::get<light<usertype_metatable_core>>(L, upvalue_index(metatable_core_index));
-					bool mustindex = umc.mustindex;
-					if (!mustindex)
-						return;
-					optional<std::string> maybeaccessor = stack::get<optional<std::string>>(L, 2);
-					if (!maybeaccessor) {
-						return;
-					}
-					std::string& accessor = maybeaccessor.value();
-					mapping_t& mapping = umc.mapping;
-					std::vector<object>& runtime = umc.runtime;
-					int target = static_cast<int>(runtime.size());
-					auto preexistingit = mapping.find(accessor);
-					if (preexistingit == mapping.cend()) {
-						runtime.emplace_back(L, 3);
-						mapping.emplace_hint(mapping.cend(), accessor, call_information(&runtime_object_call, &runtime_new_index, target));
-					}
-					else {
-						target = preexistingit->second.runtime_target;
-						runtime[target] = sol::object(L, 3);
-						preexistingit->second = call_information(&runtime_object_call, &runtime_new_index, target);
-					}
-				};
-				non_indexable();
-				for (std::size_t i = 0; i < 4; lua_settop(L, 3), ++i) {
-					const char* metakey = nullptr;
-					switch (i) {
-					case 0:
-						metakey = &usertype_traits<T*>::metatable()[0];
-						luaL_getmetatable(L, metakey);
-						break;
-					case 1:
-						metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
-						luaL_getmetatable(L, metakey);
-						break;
-					case 2:
-						metakey = &usertype_traits<T>::metatable()[0];
-						luaL_getmetatable(L, metakey);
-						break;
-					case 3:
-					default:
-						metakey = &usertype_traits<T>::user_metatable()[0];
-						{
-							luaL_getmetatable(L, metakey);
-							lua_getmetatable(L, -1);
-						}
-						break;
-					}
-					int tableindex = lua_gettop(L);
-					if (type_of(L, tableindex) == type::lua_nil) {
-						continue;
-					}
-					stack::set_field<false, true>(L, stack_reference(L, raw_index(2)), stack_reference(L, raw_index(3)), tableindex);
-				}
-				lua_settop(L, 0);
-				return 0;
-			}
-			return indexing_fail<T, false>(L);
-		}
-		
-		inline int runtime_new_index(lua_State* L, void*, int runtimetarget) {
-			usertype_metatable_core& umc = stack::get<light<usertype_metatable_core>>(L, upvalue_index(metatable_core_index));
-			std::vector<object>& runtime = umc.runtime;
-			object& runtimeobj = runtime[runtimetarget];
-			runtimeobj = object(L, 3);
-			return 0;
-		}
-
-		template <bool is_index, typename Base>
-		static void walk_single_base(lua_State* L, bool& found, int& ret, string_detail::string_shim&) {
-			if (found)
-				return;
-			const char* metakey = &usertype_traits<Base>::metatable()[0];
-			const char* gcmetakey = &usertype_traits<Base>::gc_table()[0];
-			const char* basewalkkey = is_index ? detail::base_class_index_propogation_key() : detail::base_class_new_index_propogation_key();
-
-			luaL_getmetatable(L, metakey);
-			if (type_of(L, -1) == type::lua_nil) {
-				lua_pop(L, 1);
-				return;
-			}
-			
-			stack::get_field(L, basewalkkey);
-			if (type_of(L, -1) == type::lua_nil) {
-				lua_pop(L, 2);
-				return;
-			}
-			lua_CFunction basewalkfunc = stack::pop<lua_CFunction>(L);
-			lua_pop(L, 1);
-
-			stack::get_field<true>(L, gcmetakey);
-			int value = basewalkfunc(L);
-			if (value > -1) {
-				found = true;
-				ret = value;
-			}
-		}
-
-		template <bool is_index, typename... Bases>
-		static void walk_all_bases(lua_State* L, bool& found, int& ret, string_detail::string_shim& accessor) {
-			(void)L;
-			(void)found;
-			(void)ret;
-			(void)accessor;
-			(void)detail::swallow{ 0, (walk_single_base<is_index, Bases>(L, found, ret, accessor), 0)... };
-		}
-
-		template <typename T, typename Op>
-		inline int operator_wrap(lua_State* L) {
-			auto maybel = stack::check_get<T>(L, 1);
-			if (maybel) {
-				auto mayber = stack::check_get<T>(L, 2);
-				if (mayber) {
-					auto& l = *maybel;
-					auto& r = *mayber;
-					if (std::is_same<no_comp, Op>::value) {
-						return stack::push(L, detail::ptr(l) == detail::ptr(r));
-					}
-					else {
-						Op op;
-						return stack::push(L, (detail::ptr(l) == detail::ptr(r)) || op(detail::deref(l), detail::deref(r)));
-					}
-				}
-			}
-			return stack::push(L, false);
-		}
-
-		template <typename T, typename Op, typename Supports, typename Regs, meta::enable<Supports> = meta::enabler>
-		inline void make_reg_op(Regs& l, int& index, const char* name) {
-			l[index] = { name, &operator_wrap<T, Op> };
-			++index;
-		}
-
-		template <typename T, typename Op, typename Supports, typename Regs, meta::disable<Supports> = meta::enabler>
-		inline void make_reg_op(Regs&, int&, const char*) {
-			// Do nothing if there's no support
-		}
-	} // usertype_detail
-
-	template <typename T>
-	struct clean_type {
-		typedef std::conditional_t<std::is_array<meta::unqualified_t<T>>::value, T&, std::decay_t<T>> type;
-	};
-
-	template <typename T>
-	using clean_type_t = typename clean_type<T>::type;
-
-	template <typename T, typename IndexSequence, typename... Tn>
-	struct usertype_metatable : usertype_detail::registrar {};
-
-	template <typename T, std::size_t... I, typename... Tn>
-	struct usertype_metatable<T, std::index_sequence<I...>, Tn...> : usertype_metatable_core, usertype_detail::registrar {
-		typedef std::make_index_sequence<sizeof...(I) * 2> indices;
-		typedef std::index_sequence<I...> half_indices;
-		typedef std::array<luaL_Reg, sizeof...(Tn) / 2 + 1 + 3> regs_t;
-		typedef std::tuple<Tn...> RawTuple;
-		typedef std::tuple<clean_type_t<Tn> ...> Tuple;
-		template <std::size_t Idx>
-		struct check_binding : is_variable_binding<meta::unqualified_tuple_element_t<Idx, Tuple>> {};
-		Tuple functions;
-		lua_CFunction destructfunc;
-		lua_CFunction callconstructfunc;
-		lua_CFunction indexbase;
-		lua_CFunction newindexbase;
-		usertype_detail::base_walk indexbaseclasspropogation;
-		usertype_detail::base_walk newindexbaseclasspropogation;
-		void* baseclasscheck;
-		void* baseclasscast;
-		bool secondarymeta;
-		bool hasequals;
-		bool hasless;
-		bool haslessequals;
-
-		template <std::size_t Idx, meta::enable<std::is_same<lua_CFunction, meta::unqualified_tuple_element<Idx + 1, RawTuple>>> = meta::enabler>
-		lua_CFunction make_func() const {
-			return std::get<Idx + 1>(functions);
-		}
-
-		template <std::size_t Idx, meta::disable<std::is_same<lua_CFunction, meta::unqualified_tuple_element<Idx + 1, RawTuple>>> = meta::enabler>
-		lua_CFunction make_func() const {
-			const auto& name = std::get<Idx>(functions);
-			return (usertype_detail::make_shim(name) == "__newindex") ? &call<Idx + 1, false> : &call<Idx + 1, true>;
-		}
-
-		static bool contains_variable() {
-			typedef meta::any<check_binding<(I * 2 + 1)>...> has_variables;
-			return has_variables::value;
-		}
-
-		bool contains_index() const {
-			bool idx = false;
-			(void)detail::swallow{ 0, ((idx |= (usertype_detail::is_indexer(std::get<I * 2>(functions)) != 0)), 0) ... };
-			return idx;
-		}
-
-		int finish_regs(regs_t& l, int& index) {
-			if (!hasless) {
-				const char* name = to_string(meta_function::less_than).c_str();
-				usertype_detail::make_reg_op<T, std::less<>, meta::supports_op_less<T>>(l, index, name);
-			}
-			if (!haslessequals) {
-				const char* name = to_string(meta_function::less_than_or_equal_to).c_str();
-				usertype_detail::make_reg_op<T, std::less_equal<>, meta::supports_op_less_equal<T>>(l, index, name);
-			}
-			if (!hasequals) {
-				const char* name = to_string(meta_function::equal_to).c_str();
-				usertype_detail::make_reg_op<T, std::conditional_t<meta::supports_op_equal<T>::value, std::equal_to<>, usertype_detail::no_comp>, std::true_type>(l, index, name);
-			}
-			if (destructfunc != nullptr) {
-				l[index] = { to_string(meta_function::garbage_collect).c_str(), destructfunc };
-				++index;
-			}
-			return index;
-		}
-
-		template <std::size_t Idx, typename F>
-		void make_regs(regs_t&, int&, call_construction, F&&) {
-			callconstructfunc = call<Idx + 1>;
-			secondarymeta = true;
-		}
-
-		template <std::size_t, typename... Bases>
-		void make_regs(regs_t&, int&, base_classes_tag, bases<Bases...>) {
-			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
-			if (sizeof...(Bases) < 1) {
-				return;
-			}
-			mustindex = true;
-			(void)detail::swallow{ 0, ((detail::has_derived<Bases>::value = true), 0)... };
-
-			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function), "The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");
-			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function), "The size of this data pointer is too small to fit the inheritance checking function: file a bug report.");
-			baseclasscheck = (void*)&detail::inheritance<T, Bases...>::type_check;
-			baseclasscast = (void*)&detail::inheritance<T, Bases...>::type_cast;
-			indexbaseclasspropogation = usertype_detail::walk_all_bases<true, Bases...>;
-			newindexbaseclasspropogation = usertype_detail::walk_all_bases<false, Bases...>;
-		}
-
-		template <std::size_t Idx, typename N, typename F, typename = std::enable_if_t<!meta::any_same<meta::unqualified_t<N>, base_classes_tag, call_construction>::value>>
-		void make_regs(regs_t& l, int& index, N&& n, F&&) {
-			if (is_variable_binding<meta::unqualified_t<F>>::value) {
-				return;
-			}
-			luaL_Reg reg = usertype_detail::make_reg(std::forward<N>(n), make_func<Idx>());
-			// Returnable scope
-			// That would be a neat keyword for C++
-			// returnable { ... };
-			if (reg.name == to_string(meta_function::equal_to)) {
-				hasequals = true;
-			}
-			if (reg.name == to_string(meta_function::less_than)) {
-				hasless = true;
-			}
-			if (reg.name == to_string(meta_function::less_than_or_equal_to)) {
-				haslessequals = true;
-			}
-			if (reg.name == to_string(meta_function::garbage_collect)) {
-				destructfunc = reg.func;
-				return;
-			}
-			else if (reg.name == to_string(meta_function::index)) {
-				indexfunc = reg.func;
-				mustindex = true;
-				return;
-			}
-			else if (reg.name == to_string(meta_function::new_index)) {
-				newindexfunc = reg.func;
-				mustindex = true;
-				return;
-			}
-			l[index] = reg;
-			++index;
-		}
-
-		template <typename... Args, typename = std::enable_if_t<sizeof...(Args) == sizeof...(Tn)>>
-		usertype_metatable(Args&&... args) : usertype_metatable_core(&usertype_detail::indexing_fail<T, true>, &usertype_detail::metatable_newindex<T, false>), usertype_detail::registrar(),
-		functions(std::forward<Args>(args)...),
-		destructfunc(nullptr), callconstructfunc(nullptr),
-		indexbase(&core_indexing_call<true>), newindexbase(&core_indexing_call<false>),
-		indexbaseclasspropogation(usertype_detail::walk_all_bases<true>), newindexbaseclasspropogation(usertype_detail::walk_all_bases<false>),
-		baseclasscheck(nullptr), baseclasscast(nullptr),
-		secondarymeta(contains_variable()),
-		hasequals(false), hasless(false), haslessequals(false) {
-			std::initializer_list<typename usertype_detail::mapping_t::value_type> ilist{ {
-				std::pair<std::string, usertype_detail::call_information>( usertype_detail::make_string(std::get<I * 2>(functions)),
-					usertype_detail::call_information(&usertype_metatable::real_find_call<I * 2, I * 2 + 1, true>,
-						&usertype_metatable::real_find_call<I * 2, I * 2 + 1, false>)
-					)
-			}... };
-			this->mapping.insert(ilist);
-			for (const auto& n : meta_function_names()) {
-				this->mapping.erase(n);
-			}
-			this->mustindex = contains_variable() || contains_index();
-		}
-
-		usertype_metatable(const usertype_metatable&) = default;
-		usertype_metatable(usertype_metatable&&) = default;
-		usertype_metatable& operator=(const usertype_metatable&) = default;
-		usertype_metatable& operator=(usertype_metatable&&) = default;
-
-		template <std::size_t I0, std::size_t I1, bool is_index>
-		static int real_find_call(lua_State* L, void* um, int) {
-			auto& f = *static_cast<usertype_metatable*>(um);
-			if (is_variable_binding<decltype(std::get<I1>(f.functions))>::value) {
-				return real_call_with<I1, is_index, true>(L, f);
-			}
-			// set up upvalues
-			// for a chained call
-			int upvalues = 0;
-			upvalues += stack::push(L, nullptr);
-			upvalues += stack::push(L, light<usertype_metatable>(f));
-			auto cfunc = &call<I1, is_index>;
-			return stack::push(L, c_closure(cfunc, upvalues));
-		}
-
-		template <bool is_index>
-		static int real_meta_call(lua_State* L, void* um, int) {
-			auto& f = *static_cast<usertype_metatable*>(um);
-			return is_index ? f.indexfunc(L) : f.newindexfunc(L);
-		}
-
-		template <bool is_index, bool toplevel = false>
-		static int core_indexing_call(lua_State* L) {
-			usertype_metatable& f = toplevel 
-				? stack::get<light<usertype_metatable>>(L, upvalue_index(usertype_detail::metatable_index))
-				: stack::pop<light<usertype_metatable>>(L);
-			static const int keyidx = -2 + static_cast<int>(is_index);
-			if (toplevel && stack::get<type>(L, keyidx) != type::string) {
-				return is_index ? f.indexfunc(L) : f.newindexfunc(L);
-			}
-			std::string name = stack::get<std::string>(L, keyidx);
-			auto memberit = f.mapping.find(name);
-			if (memberit != f.mapping.cend()) {
-				const usertype_detail::call_information& ci = memberit->second;
-				const usertype_detail::member_search& member = is_index ? ci.index: ci.new_index;
-				return (member)(L, static_cast<void*>(&f), ci.runtime_target);
-			}
-			string_detail::string_shim accessor = name;
-			int ret = 0;
-			bool found = false;
-			// Otherwise, we need to do propagating calls through the bases
-			if (is_index)
-				f.indexbaseclasspropogation(L, found, ret, accessor);
-			else
-				f.newindexbaseclasspropogation(L, found, ret, accessor);
-			if (found) {
-				return ret;
-			}
-			return toplevel ? (is_index ? f.indexfunc(L) : f.newindexfunc(L)) : -1;
-		}
-
-		static int real_index_call(lua_State* L) {
-			return core_indexing_call<true, true>(L);
-		}
-
-		static int real_new_index_call(lua_State* L) {
-			return core_indexing_call<false, true>(L);
-		}
-
-		template <std::size_t Idx, bool is_index = true, bool is_variable = false>
-		static int real_call(lua_State* L) {
-			usertype_metatable& f = stack::get<light<usertype_metatable>>(L, upvalue_index(usertype_detail::metatable_index));
-			return real_call_with<Idx, is_index, is_variable>(L, f);
-		}
-
-		template <std::size_t Idx, bool is_index = true, bool is_variable = false>
-		static int real_call_with(lua_State* L, usertype_metatable& um) {
-			typedef meta::unqualified_tuple_element_t<Idx - 1, Tuple> K;
-			typedef meta::unqualified_tuple_element_t<Idx, Tuple> F;
-			static const int boost = 
-				!usertype_detail::is_non_factory_constructor<F>::value
-				&& std::is_same<K, call_construction>::value ? 
-				1 : 0;
-			auto& f = std::get<Idx>(um.functions);
-			return call_detail::call_wrapped<T, is_index, is_variable, boost>(L, f);
-		}
-
-		template <std::size_t Idx, bool is_index = true, bool is_variable = false>
-		static int call(lua_State* L) {
-			return detail::static_trampoline<(&real_call<Idx, is_index, is_variable>)>(L);
-		}
-
-		template <std::size_t Idx, bool is_index = true, bool is_variable = false>
-		static int call_with(lua_State* L) {
-			return detail::static_trampoline<(&real_call_with<Idx, is_index, is_variable>)>(L);
-		}
-
-		static int index_call(lua_State* L) {
-			return detail::static_trampoline<(&real_index_call)>(L);
-		}
-
-		static int new_index_call(lua_State* L) {
-			return detail::static_trampoline<(&real_new_index_call)>(L);
-		}
-
-		virtual int push_um(lua_State* L) override {
-			return stack::push(L, std::move(*this));
-		}
-
-		~usertype_metatable() override {
-
-		}
-	};
-
-	namespace stack {
-
-		template <typename T, std::size_t... I, typename... Args>
-		struct pusher<usertype_metatable<T, std::index_sequence<I...>, Args...>> {
-			typedef usertype_metatable<T, std::index_sequence<I...>, Args...> umt_t;
-			typedef typename umt_t::regs_t regs_t;
-
-			static umt_t& make_cleanup(lua_State* L, umt_t&& umx) {
-				// ensure some sort of uniqueness
-				static int uniqueness = 0;
-				std::string uniquegcmetakey = usertype_traits<T>::user_gc_metatable();
-				// std::to_string doesn't exist in android still, with NDK, so this bullshit
-				// is necessary
-				// thanks, Android :v
-				int appended = snprintf(nullptr, 0, "%d", uniqueness);
-				std::size_t insertionpoint = uniquegcmetakey.length() - 1;
-				uniquegcmetakey.append(appended, '\0');
-				char* uniquetarget = &uniquegcmetakey[insertionpoint];
-				snprintf(uniquetarget, uniquegcmetakey.length(), "%d", uniqueness);
-				++uniqueness;
-
-				const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
-				// Make sure userdata's memory is properly in lua first,
-				// otherwise all the light userdata we make later will become invalid
-				stack::push<user<umt_t>>(L, metatable_key, uniquegcmetakey, std::move(umx));
-				// Create the top level thing that will act as our deleter later on
-				stack_reference umt(L, -1);
-				stack::set_field<true>(L, gcmetakey, umt);
-				umt.pop();
-
-				stack::get_field<true>(L, gcmetakey);
-				return stack::pop<light<umt_t>>(L);
-			}
-
-			static int push(lua_State* L, umt_t&& umx) {
-
-				umt_t& um = make_cleanup(L, std::move(umx));
-				usertype_metatable_core& umc = um;
-				regs_t value_table{ {} };
-				int lastreg = 0;
-				(void)detail::swallow{ 0, (um.template make_regs<(I * 2)>(value_table, lastreg, std::get<(I * 2)>(um.functions), std::get<(I * 2 + 1)>(um.functions)), 0)... };
-				um.finish_regs(value_table, lastreg);
-				value_table[lastreg] = { nullptr, nullptr };
-				regs_t ref_table = value_table;
-				regs_t unique_table = value_table;
-				bool hasdestructor = !value_table.empty() && to_string(meta_function::garbage_collect) == value_table[lastreg - 1].name;
-				if (hasdestructor) {
-					ref_table[lastreg - 1] = { nullptr, nullptr };
-					unique_table[lastreg - 1] = { value_table[lastreg - 1].name, detail::unique_destruct<T> };
-				}
-
-				// Now use um
-				const bool& mustindex = umc.mustindex;
-				for (std::size_t i = 0; i < 3; ++i) {
-					// Pointer types, AKA "references" from C++
-					const char* metakey = nullptr;
-					luaL_Reg* metaregs = nullptr;
-					switch (i) {
-					case 0:
-						metakey = &usertype_traits<T*>::metatable()[0];
-						metaregs = ref_table.data();
-						break;
-					case 1:
-						metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
-						metaregs = unique_table.data();
-						break;
-					case 2:
-					default:
-						metakey = &usertype_traits<T>::metatable()[0];
-						metaregs = value_table.data();
-						break;
-					}
-					luaL_newmetatable(L, metakey);
-					stack_reference t(L, -1);
-					int upvalues = 0;
-					upvalues += stack::push(L, nullptr);
-					upvalues += stack::push(L, make_light(um));
-					luaL_setfuncs(L, metaregs, upvalues);
-
-					if (um.baseclasscheck != nullptr) {
-						stack::set_field(L, detail::base_class_check_key(), um.baseclasscheck, t.stack_index());
-					}
-					if (um.baseclasscast != nullptr) {
-						stack::set_field(L, detail::base_class_cast_key(), um.baseclasscast, t.stack_index());
-					}
-
-					stack::set_field(L, detail::base_class_index_propogation_key(), make_closure(um.indexbase, nullptr, make_light(um), make_light(umc)), t.stack_index());
-					stack::set_field(L, detail::base_class_new_index_propogation_key(), make_closure(um.newindexbase, nullptr, make_light(um), make_light(umc)), t.stack_index());
-
-					if (mustindex) {
-						// Basic index pushing: specialize
-						// index and newindex to give variables and stuff
-						stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, nullptr, make_light(um), make_light(umc)), t.stack_index());
-						stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, nullptr, make_light(um), make_light(umc)), t.stack_index());
-					}
-					else {
-						// If there's only functions, we can use the fast index version
-						stack::set_field(L, meta_function::index, t, t.stack_index());
-					}
-					// metatable on the metatable
-					// for call constructor purposes and such
-					lua_createtable(L, 0, 3);
-					stack_reference metabehind(L, -1);
-					if (um.callconstructfunc != nullptr) {
-						stack::set_field(L, meta_function::call_function, make_closure(um.callconstructfunc, nullptr, make_light(um), make_light(umc)), metabehind.stack_index());
-					}
-					if (um.secondarymeta) {
-						stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, nullptr, make_light(um), make_light(umc)), metabehind.stack_index());
-						stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, nullptr, make_light(um), make_light(umc)), metabehind.stack_index());
-					}
-					stack::set_field(L, metatable_key, metabehind, t.stack_index());
-					metabehind.pop();
-					// We want to just leave the table
-					// in the registry only, otherwise we return it
-					t.pop();
-				}
-
-				// Now for the shim-table that actually gets assigned to the name
-				luaL_newmetatable(L, &usertype_traits<T>::user_metatable()[0]);
-				stack_reference t(L, -1);
-				int upvalues = 0;
-				upvalues += stack::push(L, nullptr);
-				upvalues += stack::push(L, make_light(um));
-				luaL_setfuncs(L, value_table.data(), upvalues);
-				{
-					lua_createtable(L, 0, 3);
-					stack_reference metabehind(L, -1);
-					if (um.callconstructfunc != nullptr) {
-						stack::set_field(L, meta_function::call_function, make_closure(um.callconstructfunc, nullptr, make_light(um), make_light(umc)), metabehind.stack_index());
-					}
-					
-					stack::set_field(L, meta_function::index, make_closure(umt_t::index_call, nullptr, make_light(um), make_light(umc), nullptr, usertype_detail::toplevel_magic), metabehind.stack_index());
-					stack::set_field(L, meta_function::new_index, make_closure(umt_t::new_index_call, nullptr, make_light(um), make_light(umc), nullptr, usertype_detail::toplevel_magic), metabehind.stack_index());
-					
-					stack::set_field(L, metatable_key, metabehind, t.stack_index());
-					metabehind.pop();
-				}
-
-				return 1;
-			}
-		};
-
-	} // stack
-
-} // sol
-
-// end of sol/usertype_metatable.hpp
-
-// beginning of sol/simple_usertype_metatable.hpp
-
-namespace sol {
-
-	namespace usertype_detail {
-		inline int call_indexing_object(lua_State* L, object& f) {
-			int before = lua_gettop(L);
-			f.push();
-			for (int i = 1; i <= before; ++i) {
-				lua_pushvalue(L, i);
-			}
-			lua_callk(L, before, LUA_MULTRET, 0, nullptr);
-			int after = lua_gettop(L);
-			return after - before;
-		}
-
-		template <typename T, bool is_index, bool toplevel = false, bool has_indexing = false>
-		inline int simple_core_indexing_call(lua_State* L) {
-			simple_map& sm = toplevel 
-				? stack::get<user<simple_map>>(L, upvalue_index(simple_metatable_index)) 
-				: stack::pop<user<simple_map>>(L);
-			variable_map& variables = sm.variables;
-			function_map& functions = sm.functions;
-			static const int keyidx = -2 + static_cast<int>(is_index);
-			if (toplevel) {
-				if (stack::get<type>(L, keyidx) != type::string) {
-					if (has_indexing) {
-						object& indexingfunc = is_index
-							? sm.index
-							: sm.newindex;
-						return call_indexing_object(L, indexingfunc);
-					}
-					else {
-						return is_index
-							? indexing_fail<T, is_index>(L)
-							: metatable_newindex<T, true>(L);
-					}
-				}
-			}
-			string_detail::string_shim accessor = stack::get<string_detail::string_shim>(L, keyidx);
-			std::string accessorkey = accessor.c_str();
-			auto vit = variables.find(accessorkey);
-			if (vit != variables.cend()) {
-				auto& varwrap = *(vit->second);
-				if (is_index) {
-					return varwrap.index(L);
-				}
-				return varwrap.new_index(L);
-			}
-			auto fit = functions.find(accessorkey);
-			if (fit != functions.cend()) {
-				sol::object& func = fit->second;
-				if (is_index) {
-					return stack::push(L, func);
-				}
-				else {
-					if (has_indexing && !is_toplevel(L)) {
-						object& indexingfunc = is_index
-							? sm.index
-							: sm.newindex;
-						return call_indexing_object(L, indexingfunc);
-					}
-					else {
-						return is_index 
-							? indexing_fail<T, is_index>(L)
-							: metatable_newindex<T, true>(L);
-					}
-				}
-			}
-			/* Check table storage first for a method that works
-			luaL_getmetatable(L, sm.metakey);
-			if (type_of(L, -1) != type::lua_nil) {
-				stack::get_field<false, true>(L, accessor.c_str(), lua_gettop(L));
-				if (type_of(L, -1) != type::lua_nil) {
-					// Woo, we found it?
-					lua_remove(L, -2);
-					return 1;
-				}
-				lua_pop(L, 1);
-			}
-			lua_pop(L, 1);
-			*/
-
-			int ret = 0;
-			bool found = false;
-			// Otherwise, we need to do propagating calls through the bases
-			if (is_index) {
-				sm.indexbaseclasspropogation(L, found, ret, accessor);
-			}
-			else {
-				sm.newindexbaseclasspropogation(L, found, ret, accessor);
-			}
-			if (found) {
-				return ret;
-			}
-			if (toplevel) {
-				if (has_indexing && !is_toplevel(L)) {
-					object& indexingfunc = is_index
-						? sm.index
-						: sm.newindex;
-					return call_indexing_object(L, indexingfunc);
-				}
-				else {
-					return is_index
-						? indexing_fail<T, is_index>(L)
-						: metatable_newindex<T, true>(L);
-				}
-			}
-			return -1;
-		}
-
-		template <typename T, bool has_indexing = false>
-		inline int simple_real_index_call(lua_State* L) {
-			return simple_core_indexing_call<T, true, true, has_indexing>(L);
-		}
-
-		template <typename T, bool has_indexing = false>
-		inline int simple_real_new_index_call(lua_State* L) {
-			return simple_core_indexing_call<T, false, true, has_indexing>(L);
-		}
-
-		template <typename T, bool has_indexing = false>
-		inline int simple_index_call(lua_State* L) {
-#if defined(__clang__)
-			return detail::trampoline(L, &simple_real_index_call<T, has_indexing>);
-#else
-			return detail::static_trampoline<(&simple_real_index_call<T, has_indexing>)>(L);
-#endif
-		}
-
-		template <typename T, bool has_indexing = false>
-		inline int simple_new_index_call(lua_State* L) {
-#if defined(__clang__)
-			return detail::trampoline(L, &simple_real_new_index_call<T, has_indexing>);
-#else
-			return detail::static_trampoline<(&simple_real_new_index_call<T, has_indexing>)>(L);
-#endif
-		}
-	}
-
-	struct simple_tag {} const simple{};
-
-	template <typename T>
-	struct simple_usertype_metatable : usertype_detail::registrar {
-	public:
-		usertype_detail::function_map registrations;
-		usertype_detail::variable_map varmap;
-		object callconstructfunc;
-		object indexfunc;
-		object newindexfunc;
-		lua_CFunction indexbase;
-		lua_CFunction newindexbase;
-		usertype_detail::base_walk indexbaseclasspropogation;
-		usertype_detail::base_walk newindexbaseclasspropogation;
-		void* baseclasscheck;
-		void* baseclasscast;
-		bool mustindex;
-		bool secondarymeta;
-
-		template <typename N>
-		void insert(N&& n, object&& o) {
-			std::string key = usertype_detail::make_string(std::forward<N>(n));
-			int is_indexer = static_cast<int>(usertype_detail::is_indexer(n));
-			if (is_indexer == 1) {
-				indexfunc = o;
-				mustindex = true;
-			}
-			else if (is_indexer == 2) {
-				newindexfunc = o;
-				mustindex = true;
-			}
-			auto hint = registrations.find(key);
-			if (hint == registrations.cend()) {
-				registrations.emplace_hint(hint, std::move(key), std::move(o));
-				return;
-			}
-			hint->second = std::move(o);
-		}
-
-		template <typename N, typename F, typename... Args>
-		void insert_prepare(std::true_type, lua_State* L, N&&, F&& f, Args&&... args) {
-			object o = make_object<F>(L, std::forward<F>(f), function_detail::call_indicator(), std::forward<Args>(args)...);
-			callconstructfunc = std::move(o);
-		}
-
-		template <typename N, typename F, typename... Args>
-		void insert_prepare(std::false_type, lua_State* L, N&& n, F&& f, Args&&... args) {
-			object o = make_object<F>(L, std::forward<F>(f), std::forward<Args>(args)...);
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename N, typename F>
-		void add_member_function(std::true_type, lua_State* L, N&& n, F&& f) {
-			insert_prepare(std::is_same<meta::unqualified_t<N>, call_construction>(), L, std::forward<N>(n), std::forward<F>(f), function_detail::class_indicator<T>());
-		}
-
-		template <typename N, typename F>
-		void add_member_function(std::false_type, lua_State* L, N&& n, F&& f) {
-			insert_prepare(std::is_same<meta::unqualified_t<N>, call_construction>(), L, std::forward<N>(n), std::forward<F>(f));
-		}
-
-		template <typename N, typename F, meta::enable<meta::is_callable<meta::unwrap_unqualified_t<F>>> = meta::enabler>
-		void add_function(lua_State* L, N&& n, F&& f) {
-			object o = make_object(L, as_function_reference(std::forward<F>(f)));
-			if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
-				callconstructfunc = std::move(o);
-				return;
-			}
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename N, typename F, meta::disable<meta::is_callable<meta::unwrap_unqualified_t<F>>> = meta::enabler>
-		void add_function(lua_State* L, N&& n, F&& f) {
-			add_member_function(std::is_member_pointer<meta::unwrap_unqualified_t<F>>(), L, std::forward<N>(n), std::forward<F>(f));
-		}
-
-		template <typename N, typename F, meta::disable<is_variable_binding<meta::unqualified_t<F>>> = meta::enabler>
-		void add(lua_State* L, N&& n, F&& f) {
-			add_function(L, std::forward<N>(n), std::forward<F>(f));
-		}
-
-		template <typename N, typename F, meta::enable<is_variable_binding<meta::unqualified_t<F>>> = meta::enabler>
-		void add(lua_State*, N&& n, F&& f) {
-			mustindex = true;
-			secondarymeta = true;
-			std::string key = usertype_detail::make_string(std::forward<N>(n));
-			auto o = std::make_unique<usertype_detail::callable_binding<T, std::decay_t<F>>>(std::forward<F>(f));
-			auto hint = varmap.find(key);
-			if (hint == varmap.cend()) {
-				varmap.emplace_hint(hint, std::move(key), std::move(o));
-				return;
-			}
-			hint->second = std::move(o);
-		}
-
-		template <typename N, typename... Fxs>
-		void add(lua_State* L, N&& n, constructor_wrapper<Fxs...> c) {
-			object o(L, in_place<detail::tagged<T, constructor_wrapper<Fxs...>>>, std::move(c));
-			if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
-				callconstructfunc = std::move(o);
-				return;
-			}
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename N, typename... Lists>
-		void add(lua_State* L, N&& n, constructor_list<Lists...> c) {
-			object o(L, in_place<detail::tagged<T, constructor_list<Lists...>>>, std::move(c));
-			if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
-				callconstructfunc = std::move(o);
-				return;
-			}
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename N>
-		void add(lua_State* L, N&& n, destructor_wrapper<void> c) {
-			object o(L, in_place<detail::tagged<T, destructor_wrapper<void>>>, std::move(c));
-			if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
-				callconstructfunc = std::move(o);
-				return;
-			}
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename N, typename Fx>
-		void add(lua_State* L, N&& n, destructor_wrapper<Fx> c) {
-			object o(L, in_place<detail::tagged<T, destructor_wrapper<Fx>>>, std::move(c));
-			if (std::is_same<meta::unqualified_t<N>, call_construction>::value) {
-				callconstructfunc = std::move(o);
-				return;
-			}
-			insert(std::forward<N>(n), std::move(o));
-		}
-
-		template <typename... Bases>
-		void add(lua_State*, base_classes_tag, bases<Bases...>) {
-			static_assert(sizeof(usertype_detail::base_walk) <= sizeof(void*), "size of function pointer is greater than sizeof(void*); cannot work on this platform. Please file a bug report.");
-			static_assert(!meta::any_same<T, Bases...>::value, "base classes cannot list the original class as part of the bases");
-			if (sizeof...(Bases) < 1) {
-				return;
-			}
-			mustindex = true;
-			(void)detail::swallow{ 0, ((detail::has_derived<Bases>::value = true), 0)... };
-
-			static_assert(sizeof(void*) <= sizeof(detail::inheritance_check_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
-			static_assert(sizeof(void*) <= sizeof(detail::inheritance_cast_function), "The size of this data pointer is too small to fit the inheritance checking function: Please file a bug report.");
-			baseclasscheck = (void*)&detail::inheritance<T, Bases...>::type_check;
-			baseclasscast = (void*)&detail::inheritance<T, Bases...>::type_cast;
-			indexbaseclasspropogation = usertype_detail::walk_all_bases<true, Bases...>;
-			newindexbaseclasspropogation = usertype_detail::walk_all_bases<false, Bases...>;
-		}
-
-	private:
-		template<std::size_t... I, typename Tuple>
-		simple_usertype_metatable(usertype_detail::verified_tag, std::index_sequence<I...>, lua_State* L, Tuple&& args)
-			: callconstructfunc(lua_nil),
-			indexfunc(lua_nil), newindexfunc(lua_nil),
-			indexbase(&usertype_detail::simple_core_indexing_call<T, true>), newindexbase(&usertype_detail::simple_core_indexing_call<T, false>),
-			indexbaseclasspropogation(usertype_detail::walk_all_bases<true>), newindexbaseclasspropogation(&usertype_detail::walk_all_bases<false>),
-			baseclasscheck(nullptr), baseclasscast(nullptr),
-			mustindex(false), secondarymeta(false) {
-			(void)detail::swallow{ 0,
-				(add(L, detail::forward_get<I * 2>(args), detail::forward_get<I * 2 + 1>(args)),0)...
-			};
-		}
-
-		template<typename... Args>
-		simple_usertype_metatable(lua_State* L, usertype_detail::verified_tag v, Args&&... args) : simple_usertype_metatable(v, std::make_index_sequence<sizeof...(Args) / 2>(), L, std::forward_as_tuple(std::forward<Args>(args)...)) {}
-
-		template<typename... Args>
-		simple_usertype_metatable(lua_State* L, usertype_detail::add_destructor_tag, Args&&... args) : simple_usertype_metatable(L, usertype_detail::verified, std::forward<Args>(args)..., "__gc", default_destructor) {}
-
-		template<typename... Args>
-		simple_usertype_metatable(lua_State* L, usertype_detail::check_destructor_tag, Args&&... args) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_destructible<T>, meta::neg<usertype_detail::has_destructor<Args...>>>, usertype_detail::add_destructor_tag, usertype_detail::verified_tag>(), std::forward<Args>(args)...) {}
-
-	public:
-		simple_usertype_metatable(lua_State* L) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>>, decltype(default_constructor), usertype_detail::check_destructor_tag>()) {}
-
-		template<typename Arg, typename... Args, meta::disable_any<
-			meta::any_same<meta::unqualified_t<Arg>, 
-				usertype_detail::verified_tag, 
-				usertype_detail::add_destructor_tag,
-				usertype_detail::check_destructor_tag
-			>,
-			meta::is_specialization_of<constructors, meta::unqualified_t<Arg>>,
-			meta::is_specialization_of<constructor_wrapper, meta::unqualified_t<Arg>>
-		> = meta::enabler>
-		simple_usertype_metatable(lua_State* L, Arg&& arg, Args&&... args) : simple_usertype_metatable(L, meta::condition<meta::all<std::is_default_constructible<T>, meta::neg<usertype_detail::has_constructor<Args...>>>, decltype(default_constructor), usertype_detail::check_destructor_tag>(), std::forward<Arg>(arg), std::forward<Args>(args)...) {}
-
-		template<typename... Args, typename... CArgs>
-		simple_usertype_metatable(lua_State* L, constructors<CArgs...> constructorlist, Args&&... args) : simple_usertype_metatable(L, usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
-		template<typename... Args, typename... Fxs>
-		simple_usertype_metatable(lua_State* L, constructor_wrapper<Fxs...> constructorlist, Args&&... args) : simple_usertype_metatable(L, usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
-		simple_usertype_metatable(const simple_usertype_metatable&) = default;
-		simple_usertype_metatable(simple_usertype_metatable&&) = default;
-		simple_usertype_metatable& operator=(const simple_usertype_metatable&) = default;
-		simple_usertype_metatable& operator=(simple_usertype_metatable&&) = default;
-
-		virtual int push_um(lua_State* L) override {
-			return stack::push(L, std::move(*this));
-		}
-	};
-
-	namespace stack {
-		template <typename T>
-		struct pusher<simple_usertype_metatable<T>> {
-			typedef simple_usertype_metatable<T> umt_t;
-			
-			static usertype_detail::simple_map& make_cleanup(lua_State* L, umt_t& umx) {
-				static int uniqueness = 0;
-				std::string uniquegcmetakey = usertype_traits<T>::user_gc_metatable();
-				// std::to_string doesn't exist in android still, with NDK, so this bullshit
-				// is necessary
-				// thanks, Android :v
-				int appended = snprintf(nullptr, 0, "%d", uniqueness);
-				std::size_t insertionpoint = uniquegcmetakey.length() - 1;
-				uniquegcmetakey.append(appended, '\0');
-				char* uniquetarget = &uniquegcmetakey[insertionpoint];
-				snprintf(uniquetarget, uniquegcmetakey.length(), "%d", uniqueness);
-				++uniqueness;
-
-				const char* gcmetakey = &usertype_traits<T>::gc_table()[0];
-				stack::push<user<usertype_detail::simple_map>>(L, metatable_key, uniquegcmetakey, &usertype_traits<T>::metatable()[0], 
-					umx.indexbaseclasspropogation, umx.newindexbaseclasspropogation, 
-					std::move(umx.indexfunc), std::move(umx.newindexfunc),
-					std::move(umx.varmap), std::move(umx.registrations)
-				);
-				stack_reference stackvarmap(L, -1);
-				stack::set_field<true>(L, gcmetakey, stackvarmap);
-				stackvarmap.pop();
-
-				stack::get_field<true>(L, gcmetakey);
-				usertype_detail::simple_map& varmap = stack::pop<light<usertype_detail::simple_map>>(L);
-				return varmap;
-			}
-
-			static int push(lua_State* L, umt_t&& umx) {
-				bool hasindex = umx.indexfunc.valid();
-				bool hasnewindex = umx.newindexfunc.valid();
-				auto& varmap = make_cleanup(L, umx);
-				auto sic = hasindex ? &usertype_detail::simple_index_call<T, true> : &usertype_detail::simple_index_call<T, false>;
-				auto snic = hasnewindex ? &usertype_detail::simple_new_index_call<T, true> : &usertype_detail::simple_new_index_call<T, false>;
-				bool hasequals = false;
-				bool hasless = false;
-				bool haslessequals = false;
-				auto register_kvp = [&](std::size_t i, stack_reference& t, const std::string& first, object& second) {
-					if (first == to_string(meta_function::equal_to)) {
-						hasequals = true;
-					}
-					else if (first == to_string(meta_function::less_than)) {
-						hasless = true;
-					}
-					else if (first == to_string(meta_function::less_than_or_equal_to)) {
-						haslessequals = true;
-					}
-					else if (first == to_string(meta_function::index)) {
-						umx.indexfunc = second;
-					}
-					else if (first == to_string(meta_function::new_index)) {
-						umx.newindexfunc = second;
-					}
-					switch (i) {
-					case 0:
-						if (first == to_string(meta_function::garbage_collect)) {
-							return;
-						}
-						break;
-					case 1:
-						if (first == to_string(meta_function::garbage_collect)) {
-							stack::set_field(L, first, detail::unique_destruct<T>, t.stack_index());
-							return;
-						}
-						break;
-					case 2:
-					default:
-						break;
-					}
-					stack::set_field(L, first, second, t.stack_index());
-				};
-				for (std::size_t i = 0; i < 3; ++i) {
-					const char* metakey = nullptr;
-					switch (i) {
-					case 0:
-						metakey = &usertype_traits<T*>::metatable()[0];
-						break;
-					case 1:
-						metakey = &usertype_traits<detail::unique_usertype<T>>::metatable()[0];
-						break;
-					case 2:
-					default:
-						metakey = &usertype_traits<T>::metatable()[0];
-						break;
-					}
-					luaL_newmetatable(L, metakey);
-					stack_reference t(L, -1);
-					for (auto& kvp : varmap.functions) {
-						auto& first = std::get<0>(kvp);
-						auto& second = std::get<1>(kvp);
-						register_kvp(i, t, first, second);
-					}
-					luaL_Reg opregs[4]{};
-					int opregsindex = 0;
-					if (!hasless) {
-						const char* name = to_string(meta_function::less_than).c_str();
-						usertype_detail::make_reg_op<T, std::less<>, meta::supports_op_less<T>>(opregs, opregsindex, name);
-					}
-					if (!haslessequals) {
-						const char* name = to_string(meta_function::less_than_or_equal_to).c_str();
-						usertype_detail::make_reg_op<T, std::less_equal<>, meta::supports_op_less_equal<T>>(opregs, opregsindex, name);
-					}
-					if (!hasequals) {
-						const char* name = to_string(meta_function::equal_to).c_str();
-						usertype_detail::make_reg_op<T, std::conditional_t<meta::supports_op_equal<T>::value, std::equal_to<>, usertype_detail::no_comp>, std::true_type>(opregs, opregsindex, name);
-					}
-					t.push();
-					luaL_setfuncs(L, opregs, 0);
-					t.pop();
-
-					if (umx.baseclasscheck != nullptr) {
-						stack::set_field(L, detail::base_class_check_key(), umx.baseclasscheck, t.stack_index());
-					}
-					if (umx.baseclasscast != nullptr) {
-						stack::set_field(L, detail::base_class_cast_key(), umx.baseclasscast, t.stack_index());
-					}
-
-					// Base class propagation features
-					stack::set_field(L, detail::base_class_index_propogation_key(), umx.indexbase, t.stack_index());
-					stack::set_field(L, detail::base_class_new_index_propogation_key(), umx.newindexbase, t.stack_index());
-
-					if (umx.mustindex) {
-						// use indexing function
-						stack::set_field(L, meta_function::index,
-							make_closure(sic,
-								nullptr,
-								make_light(varmap)
-							), t.stack_index());
-						stack::set_field(L, meta_function::new_index,
-							make_closure(snic,
-								nullptr,
-								make_light(varmap)
-							), t.stack_index());
-					}
-					else {
-						// Metatable indexes itself
-						stack::set_field(L, meta_function::index, t, t.stack_index());
-					}
-					// metatable on the metatable
-					// for call constructor purposes and such
-					lua_createtable(L, 0, 2 * static_cast<int>(umx.secondarymeta) + static_cast<int>(umx.callconstructfunc.valid()));
-					stack_reference metabehind(L, -1);
-					if (umx.callconstructfunc.valid()) {
-						stack::set_field(L, sol::meta_function::call_function, umx.callconstructfunc, metabehind.stack_index());
-					}
-					if (umx.secondarymeta) {
-						stack::set_field(L, meta_function::index, 
-							make_closure(sic,
-								nullptr,
-								make_light(varmap)
-							), metabehind.stack_index());
-						stack::set_field(L, meta_function::new_index, 
-							make_closure(snic,
-								nullptr,
-								make_light(varmap)
-							), metabehind.stack_index());
-					}
-					stack::set_field(L, metatable_key, metabehind, t.stack_index());
-					metabehind.pop();
-
-					t.pop();
-				}
-
-				// Now for the shim-table that actually gets pushed
-				luaL_newmetatable(L, &usertype_traits<T>::user_metatable()[0]);
-				stack_reference t(L, -1);
-				for (auto& kvp : varmap.functions) {
-					auto& first = std::get<0>(kvp);
-					auto& second = std::get<1>(kvp);
-					register_kvp(2, t, first, second);
-				}
-				{
-					lua_createtable(L, 0, 2 + static_cast<int>(umx.callconstructfunc.valid()));
-					stack_reference metabehind(L, -1);
-					if (umx.callconstructfunc.valid()) {
-						stack::set_field(L, sol::meta_function::call_function, umx.callconstructfunc, metabehind.stack_index());
-					}
-					// use indexing function
-					stack::set_field(L, meta_function::index,
-						make_closure(sic,
-							nullptr,
-							make_light(varmap),
-							nullptr,
-							nullptr,
-							usertype_detail::toplevel_magic
-						), metabehind.stack_index());
-					stack::set_field(L, meta_function::new_index,
-						make_closure(snic,
-							nullptr,
-							make_light(varmap),
-							nullptr,
-							nullptr,
-							usertype_detail::toplevel_magic
-						), metabehind.stack_index());
-					stack::set_field(L, metatable_key, metabehind, t.stack_index());
-					metabehind.pop();
-				}
-
-				// Don't pop the table when we're done;
-				// return it
-				return 1;
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/simple_usertype_metatable.hpp
-
-// beginning of sol/container_usertype_metatable.hpp
-
-namespace sol {
-	
-	namespace detail {
-
-		template <typename T>
-		struct has_find {
-		private:
-			typedef std::array<char, 1> one;
-			typedef std::array<char, 2> two;
-
-			template <typename C> static one test(decltype(std::declval<C>().find(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
-			template <typename C> static two test(...);
-
-		public:
-			static const bool value = sizeof(test<T>(0)) == sizeof(char);
-		};
-
-		template <typename T>
-		struct has_push_back {
-		private:
-			typedef std::array<char, 1> one;
-			typedef std::array<char, 2> two;
-
-			template <typename C> static one test(decltype(std::declval<C>().push_back(std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
-			template <typename C> static two test(...);
-
-		public:
-			static const bool value = sizeof(test<T>(0)) == sizeof(char);
-		};
-
-		template <typename T>
-		struct has_clear {
-		private:
-			typedef std::array<char, 1> one;
-			typedef std::array<char, 2> two;
-
-			template <typename C> static one test(decltype(&C::clear));
-			template <typename C> static two test(...);
-
-		public:
-			static const bool value = sizeof(test<T>(0)) == sizeof(char);
-		};
-
-		template <typename T>
-		struct has_insert {
-		private:
-			typedef std::array<char, 1> one;
-			typedef std::array<char, 2> two;
-
-			template <typename C> static one test(decltype(std::declval<C>().insert(std::declval<std::add_rvalue_reference_t<typename C::const_iterator>>(), std::declval<std::add_rvalue_reference_t<typename C::value_type>>()))*);
-			template <typename C> static two test(...);
-
-		public:
-			static const bool value = sizeof(test<T>(0)) == sizeof(char);
-		};
-
-		template <typename T>
-		T& get_first(const T& t) {
-			return std::forward<T>(t);
-		}
-
-		template <typename A, typename B>
-		decltype(auto) get_first(const std::pair<A, B>& t) {
-			return t.first;
-		}
-
-		template <typename C, typename I, meta::enable<has_find<meta::unqualified_t<C>>> = meta::enabler>
-		auto find(C& c, I&& i) {
-			return c.find(std::forward<I>(i));
-		}
-
-		template <typename C, typename I, meta::disable<has_find<meta::unqualified_t<C>>> = meta::enabler>
-		auto find(C& c, I&& i) {
-			using std::begin;
-			using std::end;
-			return std::find_if(begin(c), end(c), [&i](auto&& x) {
-				return i == get_first(x);
-			});
-		}
-
-	}
-
-	template <typename Raw, typename C = void>
-	struct container_usertype_metatable {
-		typedef meta::has_key_value_pair<meta::unqualified_t<Raw>> is_associative;
-		typedef meta::unqualified_t<Raw> T;
-		typedef typename T::iterator I;
-		typedef std::conditional_t<is_associative::value, typename T::value_type, std::pair<std::size_t, typename T::value_type>> KV;
-		typedef typename KV::first_type K;
-		typedef typename KV::second_type V;
-		typedef std::remove_reference_t<decltype(*std::declval<I&>())> IR;
-		typedef typename meta::iterator_tag<I>::type tag_t;
-		typedef std::conditional_t<std::is_same<tag_t, std::input_iterator_tag>::value, 
-			V, 
-			std::conditional_t<is_associative::value,
-				V,
-				decltype(*std::declval<I&>())
-			>
-		> push_type;
-
-		struct iter {
-			T& source;
-			I it;
-
-			iter(T& source, I it) : source(source), it(std::move(it)) {}
-		};
-
-		static auto& get_src(lua_State* L) {
-#ifdef SOL_SAFE_USERTYPE
-			auto p = stack::check_get<T*>(L, 1);
-			if (!p || p.value() == nullptr) {
-				luaL_error(L, "sol: 'self' argument is not the proper type (pass 'self' as first argument with ':' or call on proper type)");
-			}
-			return *p.value();
-#else
-			return stack::get<T>(L, 1);
-#endif // Safe getting with error
-		}
-
-		static int real_index_call_associative(std::true_type, lua_State* L) {
-			auto k = stack::check_get<K>(L, 2);
-			if (k) {
-				auto& src = get_src(L);
-				using std::end;
-				auto it = detail::find(src, *k);
-				if (it != end(src)) {
-					auto& v = *it;
-					return stack::stack_detail::push_reference<push_type>(L, v.second);
-				}
-			}
-			else {
-				auto maybename = stack::check_get<string_detail::string_shim>(L, 2);
-				if (maybename) {
-					auto& name = *maybename;
-					if (name == "add") {
-						return stack::push(L, &add_call);
-					}
-					else if (name == "insert") {
-						return stack::push(L, &insert_call);
-					}
-					else if (name == "clear") {
-						return stack::push(L, &clear_call);
-					}
-					else if (name == "find") {
-						return stack::push(L, &find_call);
-					}
-				}
-			}
-			return stack::push(L, lua_nil);
-		}
-
-		static int real_index_call_associative(std::false_type, lua_State* L) {
-			auto& src = get_src(L);
-			auto maybek = stack::check_get<K>(L, 2);
-			if (maybek) {
-				using std::begin;
-				auto it = begin(src);
-				K k = *maybek;
-				if (k > src.size() || k < 1) {
-					return stack::push(L, lua_nil);
-				}
-				--k;
-				std::advance(it, k);
-				return stack::stack_detail::push_reference<push_type>(L, *it);
-			}
-			else {
-				auto maybename = stack::check_get<string_detail::string_shim>(L, 2);
-				if (maybename) {
-					auto& name = *maybename;
-					if (name == "add") {
-						return stack::push(L, &add_call);
-					}
-					else if (name == "insert") {
-						return stack::push(L, &insert_call);
-					}
-					else if (name == "clear") {
-						return stack::push(L, &clear_call);
-					}
-					else if (name == "find") {
-						return stack::push(L, &find_call);
-					}
-				}
-			}
-
-			return stack::push(L, lua_nil);
-		}
-
-		static int real_index_call(lua_State* L) {
-			return real_index_call_associative(is_associative(), L);
-		}
-
-		static int real_new_index_call_const(std::false_type, std::false_type, lua_State* L) {
-			return luaL_error(L, "sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");
-		}
-
-		static int real_new_index_call_const(std::false_type, std::true_type, lua_State* L) {
-			return luaL_error(L, "sol: cannot write to a const value type or an immutable iterator (e.g., std::set)");
-		}
-
-		static int real_new_index_call_const(std::true_type, std::true_type, lua_State* L) {
-			auto& src = get_src(L);
-#ifdef SOL_CHECK_ARGUMENTS
-			auto maybek = stack::check_get<K>(L, 2);
-			if (!maybek) {
-				return luaL_error(L, "sol: improper key of type %s to a %s", lua_typename(L, static_cast<int>(type_of(L, 2))), detail::demangle<T>().c_str());
-			}
-			K& k = *maybek;
-#else
-			K k = stack::get<K>(L, 2);
-#endif
-			using std::end;
-			auto it = detail::find(src, k);
-			if (it != end(src)) {
-				auto& v = *it;
-				v.second = stack::get<V>(L, 3);
-			}
-			else {
-				src.insert(it, { std::move(k), stack::get<V>(L, 3) });
-			}
-			return 0;
-		}
-
-		static int real_new_index_call_const(std::true_type, std::false_type, lua_State* L) {
-			auto& src = get_src(L);
-#ifdef SOL_CHECK_ARGUMENTS
-			auto maybek = stack::check_get<K>(L, 2);
-			if (!maybek) {
-				return luaL_error(L, "sol: improper index of type %s to a %s", lua_typename(L, static_cast<int>(type_of(L, 2))), detail::demangle<T>().c_str());
-			}
-			K& k = *maybek;
-#else
-			K k = stack::get<K>(L, 2);
-#endif
-			using std::begin;
-			auto it = begin(src);
-#ifdef SOL_CHECK_ARGUMENTS
-			if (k < 1) {
-				return luaL_error(L, "sol: out of bounds index to a %s", detail::demangle<T>().c_str());
-			}
-#endif
-			--k;
-			if (k == src.size()) {
-				real_add_call_push(std::integral_constant<bool, detail::has_push_back<T>::value && std::is_copy_constructible<V>::value>(), L, src, 1);
-				return 0;
-			}
-#ifdef SOL_CHECK_ARGUMENTS
-			if (k > src.size()) {
-				return luaL_error(L, "sol: out of bounds index to a %s", detail::demangle<T>().c_str());
-			}
-#endif
-			std::advance(it, k);
-			*it = stack::get<V>(L, 3);
-			return 0;
-		}
-
-		static int real_new_index_call(lua_State* L) {
-			return real_new_index_call_const(meta::neg<meta::any<std::is_const<V>, std::is_const<IR>, meta::neg<std::is_copy_assignable<V>>>>(), is_associative(), L);
-		}
-
-		static int real_pairs_next_call_assoc(std::true_type, lua_State* L) {
-			using std::end;
-			iter& i = stack::get<user<iter>>(L, 1);
-			auto& source = i.source;
-			auto& it = i.it;
-			if (it == end(source)) {
-				return 0;
-			}
-			int p;
-			p = stack::push_reference(L, it->first);
-			p += stack::stack_detail::push_reference<push_type>(L, it->second);
-			std::advance(it, 1);
-			return p;
-		}
-
-		static int real_pairs_call_assoc(std::true_type, lua_State* L) {
-			auto& src = get_src(L);
-			using std::begin;
-			stack::push(L, pairs_next_call);
-			stack::push<user<iter>>(L, src, begin(src));
-			stack::push(L, 1);
-			return 3;
-		}
-
-		static int real_pairs_next_call_assoc(std::false_type, lua_State* L) {
-			using std::end;
-			iter& i = stack::get<user<iter>>(L, 1);
-			auto& source = i.source;
-			auto& it = i.it;
-			K k = stack::get<K>(L, 2);
-			if (it == end(source)) {
-				return 0;
-			}
-			int p;
-			p = stack::push_reference(L, k + 1);
-			p += stack::stack_detail::push_reference<push_type>(L, *it);
-			std::advance(it, 1);
-			return p;
-		}
-
-		static int real_pairs_call_assoc(std::false_type, lua_State* L) {
-			auto& src = get_src(L);
-			using std::begin;
-			stack::push(L, pairs_next_call);
-			stack::push<user<iter>>(L, src, begin(src));
-			stack::push(L, 0);
-			return 3;
-		}
-
-		static int real_pairs_next_call(lua_State* L) {
-			return real_pairs_next_call_assoc(is_associative(), L);
-		}
-
-		static int real_pairs_call(lua_State* L) {
-			return real_pairs_call_assoc(is_associative(), L);
-		}
-
-		static int real_length_call(lua_State*L) {
-			auto& src = get_src(L);
-			return stack::push(L, src.size());
-		}
-
-		static int real_add_call_insert(std::true_type, lua_State*L, T& src, int boost = 0) {
-			using std::end;
-			src.insert(end(src), stack::get<V>(L, 2 + boost));
-			return 0;
-		}
-
-		static int real_add_call_insert(std::false_type, lua_State*L, T&, int = 0) {
-			static const std::string& s = detail::demangle<T>();
-			return luaL_error(L, "sol: cannot call insert on type %s", s.c_str());
-		}
-
-		static int real_add_call_push(std::true_type, lua_State*L, T& src, int boost = 0) {
-			src.push_back(stack::get<V>(L, 2 + boost));
-			return 0;
-		}
-
-		static int real_add_call_push(std::false_type, lua_State*L, T& src, int boost = 0) {
-			return real_add_call_insert(std::integral_constant<bool, detail::has_insert<T>::value && std::is_copy_constructible<V>::value>(), L, src, boost);
-		}
-
-		static int real_add_call_associative(std::true_type, lua_State* L) {
-			return real_insert_call(L);
-		}
-
-		static int real_add_call_associative(std::false_type, lua_State* L) {
-			auto& src = get_src(L);
-			return real_add_call_push(std::integral_constant<bool, detail::has_push_back<T>::value && std::is_copy_constructible<V>::value>(), L, src);
-		}
-
-		static int real_add_call_capable(std::true_type, lua_State* L) {
-			return real_add_call_associative(is_associative(), L);
-		}
-
-		static int real_add_call_capable(std::false_type, lua_State* L) {
-			static const std::string& s = detail::demangle<T>();
-			return luaL_error(L, "sol: cannot call add on type %s", s.c_str());
-		}
-
-		static int real_add_call(lua_State* L) {
-			return real_add_call_capable(std::integral_constant<bool, (detail::has_push_back<T>::value || detail::has_insert<T>::value) && std::is_copy_constructible<V>::value>(), L);
-		}
-
-		static int real_insert_call_capable(std::false_type, std::false_type, lua_State*L) {
-			static const std::string& s = detail::demangle<T>();
-			return luaL_error(L, "sol: cannot call insert on type %s", s.c_str());
-		}
-
-		static int real_insert_call_capable(std::false_type, std::true_type, lua_State*L) {
-			return real_insert_call_capable(std::false_type(), std::false_type(), L);
-		}
-
-		static int real_insert_call_capable(std::true_type, std::false_type, lua_State* L) {
-			using std::begin;
-			auto& src = get_src(L);
-			src.insert(std::next(begin(src), stack::get<K>(L, 2)), stack::get<V>(L, 3));
-			return 0;
-		}
-
-		static int real_insert_call_capable(std::true_type, std::true_type, lua_State* L) {
-			return real_new_index_call(L);
-		}
-
-		static int real_insert_call(lua_State*L) {
-			return real_insert_call_capable(std::integral_constant<bool, detail::has_insert<T>::value && std::is_copy_assignable<V>::value>(), is_associative(), L);
-		}
-
-		static int real_clear_call_capable(std::false_type, lua_State* L) {
-			static const std::string& s = detail::demangle<T>();
-			return luaL_error(L, "sol: cannot call clear on type %s", s.c_str());
-		}
-
-		static int real_clear_call_capable(std::true_type, lua_State* L) {
-			auto& src = get_src(L);
-			src.clear();
-			return 0;
-		}
-
-		static int real_clear_call(lua_State*L) {
-			return real_clear_call_capable(std::integral_constant<bool, detail::has_clear<T>::value>(), L);
-		}
-
-		static int real_find_call_capable(std::false_type, std::false_type, lua_State*L) {
-			static const std::string& s = detail::demangle<T>();
-			return luaL_error(L, "sol: cannot call find on type %s", s.c_str());
-		}
-
-		static int real_find_call_capable(std::false_type, std::true_type, lua_State*L) {
-			return real_index_call(L);
-		}
-
-		static int real_find_call_capable(std::true_type, std::false_type, lua_State* L) {
-			auto k = stack::check_get<V>(L, 2);
-			if (k) {
-				auto& src = get_src(L);
-				auto it = src.find(*k);
-				if (it != src.end()) {
-					auto& v = *it;
-					return stack::stack_detail::push_reference<push_type>(L, v);
-				}
-			}
-			return stack::push(L, lua_nil);
-		}
-
-		static int real_find_call_capable(std::true_type, std::true_type, lua_State* L) {
-			return real_index_call(L);
-		}
-
-		static int real_find_call(lua_State*L) {
-			return real_find_call_capable(std::integral_constant<bool, detail::has_find<T>::value>(), is_associative(), L);
-		}
-
-		static int add_call(lua_State*L) {
-			return detail::static_trampoline<(&real_add_call)>(L);
-		}
-
-		static int insert_call(lua_State*L) {
-			return detail::static_trampoline<(&real_insert_call)>(L);
-		}
-
-		static int clear_call(lua_State*L) {
-			return detail::static_trampoline<(&real_clear_call)>(L);
-		}
-
-		static int find_call(lua_State*L) {
-			return detail::static_trampoline<(&real_find_call)>(L);
-		}
-
-		static int length_call(lua_State*L) {
-			return detail::static_trampoline<(&real_length_call)>(L);
-		}
-
-		static int pairs_next_call(lua_State*L) {
-			return detail::static_trampoline<(&real_pairs_next_call)>(L);
-		}
-
-		static int pairs_call(lua_State*L) {
-			return detail::static_trampoline<(&real_pairs_call)>(L);
-		}
-
-		static int index_call(lua_State*L) {
-			return detail::static_trampoline<(&real_index_call)>(L);
-		}
-
-		static int new_index_call(lua_State*L) {
-			return detail::static_trampoline<(&real_new_index_call)>(L);
-		}
-	};
-
-	namespace stack {
-		namespace stack_detail {
-			template <typename T>
-			inline auto container_metatable() {
-				typedef container_usertype_metatable<std::remove_pointer_t<T>> meta_cumt;
-				std::array<luaL_Reg, 11> reg = { {
-					{ "__index", &meta_cumt::index_call },
-					{ "__newindex", &meta_cumt::new_index_call },
-					{ "__pairs", &meta_cumt::pairs_call },
-					{ "__ipairs", &meta_cumt::pairs_call },
-					{ "__len", &meta_cumt::length_call },
-					{ "clear", &meta_cumt::clear_call },
-					{ "insert", &meta_cumt::insert_call },
-					{ "add", &meta_cumt::add_call },
-					{ "find", &meta_cumt::find_call },
-					std::is_pointer<T>::value ? luaL_Reg{ nullptr, nullptr } : luaL_Reg{ "__gc", &detail::usertype_alloc_destroy<T> },
-					{ nullptr, nullptr }
-				} };
-				return reg;
-			}
-
-			template <typename T>
-			inline auto container_metatable_behind() {
-				typedef container_usertype_metatable<std::remove_pointer_t<T>> meta_cumt;
-				std::array<luaL_Reg, 3> reg = { {
-					{ "__index", &meta_cumt::index_call },
-					{ "__newindex", &meta_cumt::new_index_call },
-					{ nullptr, nullptr }
-				} };
-				return reg;
-			}
-
-			template <typename T>
-			struct metatable_setup {
-				lua_State* L;
-
-				metatable_setup(lua_State* L) : L(L) {}
-
-				void operator()() {
-					static const auto reg = container_metatable<T>();
-					static const auto containerreg = container_metatable_behind<T>();
-					static const char* metakey = &usertype_traits<T>::metatable()[0];
-					
-					if (luaL_newmetatable(L, metakey) == 1) {
-						stack_reference metatable(L, -1);
-						luaL_setfuncs(L, reg.data(), 0);
-
-						lua_createtable(L, 0, static_cast<int>(containerreg.size()));
-						stack_reference metabehind(L, -1);
-						luaL_setfuncs(L, containerreg.data(), 0);
-						
-						stack::set_field(L, metatable_key, metabehind, metatable.stack_index());
-						metabehind.pop();
-					}
-					lua_setmetatable(L, -2);
-				}
-			};
-		}
-		
-		template<typename T>
-		struct pusher<T, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
-			static int push(lua_State* L, const T& cont) {
-				stack_detail::metatable_setup<T> fx(L);
-				return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, cont);
-			}
-
-			static int push(lua_State* L, T&& cont) {
-				stack_detail::metatable_setup<T> fx(L);
-				return pusher<detail::as_value_tag<T>>{}.push_fx(L, fx, std::move(cont));
-			}
-		};
-
-		template<typename T>
-		struct pusher<T*, std::enable_if_t<meta::all<is_container<meta::unqualified_t<T>>, meta::neg<meta::any<std::is_base_of<reference, meta::unqualified_t<T>>, std::is_base_of<stack_reference, meta::unqualified_t<T>>>>>::value>> {
-			static int push(lua_State* L, T* cont) {
-				stack_detail::metatable_setup<meta::unqualified_t<std::remove_pointer_t<T>>*> fx(L);
-				return pusher<detail::as_pointer_tag<T>>{}.push_fx(L, fx, cont);
-			}
-		};
-	} // stack
-
-} // sol
-
-// end of sol/container_usertype_metatable.hpp
-
-namespace sol {
-
-	template<typename T>
-	class usertype {
-	private:
-		std::unique_ptr<usertype_detail::registrar, detail::deleter> metatableregister;
-
-		template<typename... Args>
-		usertype(usertype_detail::verified_tag, Args&&... args) : metatableregister(detail::make_unique_deleter<usertype_metatable<T, std::make_index_sequence<sizeof...(Args) / 2>, Args...>, detail::deleter>(std::forward<Args>(args)...)) {}
-
-		template<typename... Args>
-		usertype(usertype_detail::add_destructor_tag, Args&&... args) : usertype(usertype_detail::verified, std::forward<Args>(args)..., "__gc", default_destructor) {}
-
-		template<typename... Args>
-		usertype(usertype_detail::check_destructor_tag, Args&&... args) : usertype(meta::condition<meta::all<std::is_destructible<T>, meta::neg<usertype_detail::has_destructor<Args...>>>, usertype_detail::add_destructor_tag, usertype_detail::verified_tag>(), std::forward<Args>(args)...) {}
-
-	public:
-
-		template<typename... Args>
-		usertype(Args&&... args) : usertype(meta::condition<meta::all<std::is_default_constructible<T>, meta::neg<usertype_detail::has_constructor<Args...>>>, decltype(default_constructor), usertype_detail::check_destructor_tag>(), std::forward<Args>(args)...) {}
-
-		template<typename... Args, typename... CArgs>
-		usertype(constructors<CArgs...> constructorlist, Args&&... args) : usertype(usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
-		template<typename... Args, typename... Fxs>
-		usertype(constructor_wrapper<Fxs...> constructorlist, Args&&... args) : usertype(usertype_detail::check_destructor_tag(), std::forward<Args>(args)..., "new", constructorlist) {}
-
-		template<typename... Args>
-		usertype(simple_tag, lua_State* L, Args&&... args) : metatableregister(detail::make_unique_deleter<simple_usertype_metatable<T>, detail::deleter>(L, std::forward<Args>(args)...)) {}
-
-		usertype_detail::registrar* registrar_data() {
-			return metatableregister.get();
-		}
-
-		int push(lua_State* L) {
-			int r = metatableregister->push_um(L);
-			metatableregister = nullptr;
-			return r;
-		}
-	};
-
-	template<typename T>
-	class simple_usertype : public usertype<T> {
-	private:
-		typedef usertype<T> base_t;
-		lua_State* state;
-
-	public:
-		template<typename... Args>
-		simple_usertype(lua_State* L, Args&&... args) : base_t(simple, L, std::forward<Args>(args)...), state(L) {}
-		
-		template <typename N, typename F>
-		void set(N&& n, F&& f) {
-			auto meta = static_cast<simple_usertype_metatable<T>*>(base_t::registrar_data());
-			meta->add(state, n, f);
-		}
-	};
-
-	namespace stack {
-		template<typename T>
-		struct pusher<usertype<T>> {
-			static int push(lua_State* L, usertype<T>& user) {
-				return user.push(L);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/usertype.hpp
-
-// beginning of sol/table_iterator.hpp
-
-namespace sol {
-
-	template <typename reference_type>
-	class basic_table_iterator : public std::iterator<std::input_iterator_tag, std::pair<object, object>> {
-	private:
-		typedef std::iterator<std::input_iterator_tag, std::pair<object, object>> base_t;
-	public:
-		typedef object key_type;
-		typedef object mapped_type;
-		typedef base_t::value_type value_type;
-		typedef base_t::iterator_category iterator_category;
-		typedef base_t::difference_type difference_type;
-		typedef base_t::pointer pointer;
-		typedef base_t::reference reference;
-		typedef const value_type& const_reference;
-
-	private:
-		std::pair<object, object> kvp;
-		reference_type ref;
-		int tableidx = 0;
-		int keyidx = 0;
-		std::ptrdiff_t idx = 0;
-
-	public:
-
-		basic_table_iterator() : keyidx(-1), idx(-1) {
-
-		}
-
-		basic_table_iterator(reference_type x) : ref(std::move(x)) {
-			ref.push();
-			tableidx = lua_gettop(ref.lua_state());
-			stack::push(ref.lua_state(), lua_nil);
-			this->operator++();
-			if (idx == -1) {
-				return;
-			}
-			--idx;
-		}
-
-		basic_table_iterator& operator++() {
-			if (idx == -1)
-				return *this;
-
-			if (lua_next(ref.lua_state(), tableidx) == 0) {
-				idx = -1;
-				keyidx = -1;
-				return *this;
-			}
-			++idx;
-			kvp.first = object(ref.lua_state(), -2);
-			kvp.second = object(ref.lua_state(), -1);
-			lua_pop(ref.lua_state(), 1);
-			// leave key on the stack
-			keyidx = lua_gettop(ref.lua_state());
-			return *this;
-		}
-
-		basic_table_iterator operator++(int) {
-			auto saved = *this;
-			this->operator++();
-			return saved;
-		}
-
-		reference operator*() {
-			return kvp;
-		}
-
-		const_reference operator*() const {
-			return kvp;
-		}
-
-		bool operator== (const basic_table_iterator& right) const {
-			return idx == right.idx;
-		}
-
-		bool operator!= (const basic_table_iterator& right) const {
-			return idx != right.idx;
-		}
-
-		~basic_table_iterator() {
-			if (keyidx != -1) {
-				stack::remove(ref.lua_state(), keyidx, 1);
-			}
-			if (ref.valid()) {
-				stack::remove(ref.lua_state(), tableidx, 1);
-			}
-		}
-	};
-
-} // sol
-
-// end of sol/table_iterator.hpp
-
-namespace sol {
-	namespace detail {
-		template <std::size_t n>
-		struct clean { lua_State* L; clean(lua_State* luastate) : L(luastate) {} ~clean() { lua_pop(L, static_cast<int>(n)); } };
-		struct ref_clean { lua_State* L; int& n; ref_clean(lua_State* luastate, int& n) : L(luastate), n(n) {} ~ref_clean() { lua_pop(L, static_cast<int>(n)); } };
-		inline int fail_on_newindex(lua_State* L) {
-			return luaL_error(L, "sol: cannot modify the elements of an enumeration table");
-		}
-	}
-
-	const new_table create = new_table{};
-
-	template <bool top_level, typename base_type>
-	class basic_table_core : public basic_object_base<base_type> {
-		typedef basic_object_base<base_type> base_t;
-		friend class state;
-		friend class state_view;
-
-		template <typename... Args>
-		using is_global = meta::all<meta::boolean<top_level>, meta::is_c_str<Args>...>;
-
-		template<typename Fx>
-		void for_each(std::true_type, Fx&& fx) const {
-			auto pp = stack::push_pop(*this);
-			stack::push(base_t::lua_state(), lua_nil);
-			while (lua_next(base_t::lua_state(), -2)) {
-				sol::object key(base_t::lua_state(), -2);
-				sol::object value(base_t::lua_state(), -1);
-				std::pair<sol::object&, sol::object&> keyvalue(key, value);
-				auto pn = stack::pop_n(base_t::lua_state(), 1);
-				fx(keyvalue);
-			}
-		}
-
-		template<typename Fx>
-		void for_each(std::false_type, Fx&& fx) const {
-			auto pp = stack::push_pop(*this);
-			stack::push(base_t::lua_state(), lua_nil);
-			while (lua_next(base_t::lua_state(), -2)) {
-				sol::object key(base_t::lua_state(), -2);
-				sol::object value(base_t::lua_state(), -1);
-				auto pn = stack::pop_n(base_t::lua_state(), 1);
-				fx(key, value);
-			}
-		}
-
-		template<typename Ret0, typename Ret1, typename... Ret, std::size_t... I, typename Keys>
-		auto tuple_get(types<Ret0, Ret1, Ret...>, std::index_sequence<0, 1, I...>, Keys&& keys) const
-			-> decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) {
-			typedef decltype(stack::pop<std::tuple<Ret0, Ret1, Ret...>>(nullptr)) Tup;
-			return Tup(
-				traverse_get_optional<top_level, Ret0>(meta::is_optional<meta::unqualified_t<Ret0>>(), detail::forward_get<0>(keys)),
-				traverse_get_optional<top_level, Ret1>(meta::is_optional<meta::unqualified_t<Ret1>>(), detail::forward_get<1>(keys)),
-				traverse_get_optional<top_level, Ret>(meta::is_optional<meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys))...
-			);
-		}
-
-		template<typename Ret, std::size_t I, typename Keys>
-		decltype(auto) tuple_get(types<Ret>, std::index_sequence<I>, Keys&& keys) const {
-			return traverse_get_optional<top_level, Ret>(meta::is_optional<meta::unqualified_t<Ret>>(), detail::forward_get<I>(keys));
-		}
-
-		template<typename Pairs, std::size_t... I>
-		void tuple_set(std::index_sequence<I...>, Pairs&& pairs) {
-			auto pp = stack::push_pop<top_level && (is_global<decltype(detail::forward_get<I * 2>(pairs))...>::value)>(*this);
-			void(detail::swallow{ (stack::set_field<top_level>(base_t::lua_state(),
-				detail::forward_get<I * 2>(pairs),
-				detail::forward_get<I * 2 + 1>(pairs),
-				lua_gettop(base_t::lua_state())
-			), 0)... });
-		}
-
-		template <bool global, typename T, typename Key>
-		decltype(auto) traverse_get_deep(Key&& key) const {
-			stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
-			return stack::get<T>(base_t::lua_state());
-		}
-
-		template <bool global, typename T, typename Key, typename... Keys>
-		decltype(auto) traverse_get_deep(Key&& key, Keys&&... keys) const {
-			stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
-			return traverse_get_deep<false, T>(std::forward<Keys>(keys)...);
-		}
-
-		template <bool global, typename T, std::size_t I, typename Key>
-		decltype(auto) traverse_get_deep_optional(int& popcount, Key&& key) const {
-			typedef decltype(stack::get<T>(base_t::lua_state())) R;
-			auto p = stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
-			popcount += p.levels;
-			if (!p.success)
-				return R(nullopt);
-			return stack::get<T>(base_t::lua_state());
-		}
-
-		template <bool global, typename T, std::size_t I, typename Key, typename... Keys>
-		decltype(auto) traverse_get_deep_optional(int& popcount, Key&& key, Keys&&... keys) const {
-			auto p = I > 0 ? stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), -1) : stack::probe_get_field<global>(base_t::lua_state(), std::forward<Key>(key), lua_gettop(base_t::lua_state()));
-			popcount += p.levels;
-			if (!p.success)
-				return T(nullopt);
-			return traverse_get_deep_optional<false, T, I + 1>(popcount, std::forward<Keys>(keys)...);
-		}
-
-		template <bool global, typename T, typename... Keys>
-		decltype(auto) traverse_get_optional(std::false_type, Keys&&... keys) const {
-			detail::clean<sizeof...(Keys)> c(base_t::lua_state());
-			return traverse_get_deep<top_level, T>(std::forward<Keys>(keys)...);
-		}
-
-		template <bool global, typename T, typename... Keys>
-		decltype(auto) traverse_get_optional(std::true_type, Keys&&... keys) const {
-			int popcount = 0;
-			detail::ref_clean c(base_t::lua_state(), popcount);
-			return traverse_get_deep_optional<top_level, T, 0>(popcount, std::forward<Keys>(keys)...);
-		}
-
-		template <bool global, typename Key, typename Value>
-		void traverse_set_deep(Key&& key, Value&& value) const {
-			stack::set_field<global>(base_t::lua_state(), std::forward<Key>(key), std::forward<Value>(value));
-		}
-
-		template <bool global, typename Key, typename... Keys>
-		void traverse_set_deep(Key&& key, Keys&&... keys) const {
-			stack::get_field<global>(base_t::lua_state(), std::forward<Key>(key));
-			traverse_set_deep<false>(std::forward<Keys>(keys)...);
-		}
-
-		basic_table_core(lua_State* L, detail::global_tag t) noexcept : base_t(L, t) { }
-	
-	protected:
-		basic_table_core(detail::no_safety_tag, lua_State* L, int index) : base_t(L, index) {}
-		basic_table_core(detail::no_safety_tag, lua_State* L, ref_index index) : base_t(L, index) {}
-		template <typename T, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_table_core(detail::no_safety_tag, T&& r) noexcept : base_t(std::forward<T>(r)) {}
-		
-	public:
-		typedef basic_table_iterator<base_type> iterator;
-		typedef iterator const_iterator;
-
-		basic_table_core() noexcept = default;
-		basic_table_core(const basic_table_core&) = default;
-		basic_table_core(basic_table_core&&) = default;
-		basic_table_core& operator=(const basic_table_core&) = default;
-		basic_table_core& operator=(basic_table_core&&) = default;
-		basic_table_core(const stack_reference& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
-		basic_table_core(stack_reference&& r) : basic_table_core(r.lua_state(), r.stack_index()) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<meta::unqualified_t<T>, ref_index>>> = meta::enabler>
-		basic_table_core(lua_State* L, T&& r) : basic_table_core(L, sol::ref_index(r.registry_index())) {}
-		basic_table_core(lua_State* L, new_table nt) : base_t(L, (lua_createtable(L, nt.sequence_hint, nt.map_hint), -1)) {
-			if (!std::is_base_of<stack_reference, base_type>::value) {
-				lua_pop(L, 1);
-			}
-		}
-		basic_table_core(lua_State* L, int index = -1) : basic_table_core(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_table_core>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_table_core(lua_State* L, ref_index index) : basic_table_core(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_table_core>(L, -1, type_panic);
-#endif // Safety
-		}
-		template <typename T, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_table_core>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_table_core(T&& r) noexcept : basic_table_core(detail::no_safety, std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_table<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				stack::check<basic_table_core>(base_t::lua_state(), -1, type_panic);
-			}
-#endif // Safety
-		}
-
-		iterator begin() const {
-			return iterator(*this);
-		}
-
-		iterator end() const {
-			return iterator();
-		}
-
-		const_iterator cbegin() const {
-			return begin();
-		}
-
-		const_iterator cend() const {
-			return end();
-		}
-
-		template<typename... Ret, typename... Keys>
-		decltype(auto) get(Keys&&... keys) const {
-			static_assert(sizeof...(Keys) == sizeof...(Ret), "number of keys and number of return types do not match");
-			auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
-			return tuple_get(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), std::forward_as_tuple(std::forward<Keys>(keys)...));
-		}
-
-		template<typename T, typename Key>
-		decltype(auto) get_or(Key&& key, T&& otherwise) const {
-			typedef decltype(get<T>("")) U;
-			optional<U> option = get<optional<U>>(std::forward<Key>(key));
-			if (option) {
-				return static_cast<U>(option.value());
-			}
-			return static_cast<U>(std::forward<T>(otherwise));
-		}
-
-		template<typename T, typename Key, typename D>
-		decltype(auto) get_or(Key&& key, D&& otherwise) const {
-			optional<T> option = get<optional<T>>(std::forward<Key>(key));
-			if (option) {
-				return static_cast<T>(option.value());
-			}
-			return static_cast<T>(std::forward<D>(otherwise));
-		}
-
-		template <typename T, typename... Keys>
-		decltype(auto) traverse_get(Keys&&... keys) const {
-			auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
-			return traverse_get_optional<top_level, T>(meta::is_optional<meta::unqualified_t<T>>(), std::forward<Keys>(keys)...);
-		}
-
-		template <typename... Keys>
-		basic_table_core& traverse_set(Keys&&... keys) {
-			auto pp = stack::push_pop<is_global<Keys...>::value>(*this);
-			auto pn = stack::pop_n(base_t::lua_state(), static_cast<int>(sizeof...(Keys)-2));
-			traverse_set_deep<top_level>(std::forward<Keys>(keys)...);
-			return *this;
-		}
-
-		template<typename... Args>
-		basic_table_core& set(Args&&... args) {
-			tuple_set(std::make_index_sequence<sizeof...(Args) / 2>(), std::forward_as_tuple(std::forward<Args>(args)...));
-			return *this;
-		}
-
-		template<typename T>
-		basic_table_core& set_usertype(usertype<T>& user) {
-			return set_usertype(usertype_traits<T>::name(), user);
-		}
-
-		template<typename Key, typename T>
-		basic_table_core& set_usertype(Key&& key, usertype<T>& user) {
-			return set(std::forward<Key>(key), user);
-		}
-
-		template<typename Class, typename... Args>
-		basic_table_core& new_usertype(const std::string& name, Args&&... args) {
-			usertype<Class> utype(std::forward<Args>(args)...);
-			set_usertype(name, utype);
-			return *this;
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		basic_table_core& new_usertype(const std::string& name, Args&&... args) {
-			constructors<types<CTor0, CTor...>> ctor{};
-			return new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
-		}
-
-		template<typename Class, typename... CArgs, typename... Args>
-		basic_table_core& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
-			usertype<Class> utype(ctor, std::forward<Args>(args)...);
-			set_usertype(name, utype);
-			return *this;
-		}
-
-		template<typename Class, typename... Args>
-		basic_table_core& new_simple_usertype(const std::string& name, Args&&... args) {
-			simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
-			set_usertype(name, utype);
-			return *this;
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		basic_table_core& new_simple_usertype(const std::string& name, Args&&... args) {
-			constructors<types<CTor0, CTor...>> ctor{};
-			return new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
-		}
-
-		template<typename Class, typename... CArgs, typename... Args>
-		basic_table_core& new_simple_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
-			simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
-			set_usertype(name, utype);
-			return *this;
-		}
-
-		template<typename Class, typename... Args>
-		simple_usertype<Class> create_simple_usertype(Args&&... args) {
-			simple_usertype<Class> utype(base_t::lua_state(), std::forward<Args>(args)...);
-			return utype;
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		simple_usertype<Class> create_simple_usertype(Args&&... args) {
-			constructors<types<CTor0, CTor...>> ctor{};
-			return create_simple_usertype<Class>(ctor, std::forward<Args>(args)...);
-		}
-
-		template<typename Class, typename... CArgs, typename... Args>
-		simple_usertype<Class> create_simple_usertype(constructors<CArgs...> ctor, Args&&... args) {
-			simple_usertype<Class> utype(base_t::lua_state(), ctor, std::forward<Args>(args)...);
-			return utype;
-		}
-
-		template<bool read_only = true, typename... Args>
-		basic_table_core& new_enum(const std::string& name, Args&&... args) {
-			if (read_only) {
-				table idx = create_with(std::forward<Args>(args)...);
-				table x = create_with(
-					meta_function::new_index, detail::fail_on_newindex,
-					meta_function::index, idx
-				);
-				table target = create_named(name);
-				target[metatable_key] = x;
-			}
-			else {
-				create_named(name, std::forward<Args>(args)...);
-			}
-			return *this;
-		}
-
-		template<typename Fx>
-		void for_each(Fx&& fx) const {
-			typedef meta::is_invokable<Fx(std::pair<sol::object, sol::object>)> is_paired;
-			for_each(is_paired(), std::forward<Fx>(fx));
-		}
-
-		size_t size() const {
-			auto pp = stack::push_pop(*this);
-			lua_len(base_t::lua_state(), -1);
-			return stack::pop<size_t>(base_t::lua_state());
-		}
-
-		bool empty() const {
-			return cbegin() == cend();
-		}
-
-		template<typename T>
-		proxy<basic_table_core&, T> operator[](T&& key) & {
-			return proxy<basic_table_core&, T>(*this, std::forward<T>(key));
-		}
-
-		template<typename T>
-		proxy<const basic_table_core&, T> operator[](T&& key) const & {
-			return proxy<const basic_table_core&, T>(*this, std::forward<T>(key));
-		}
-
-		template<typename T>
-		proxy<basic_table_core, T> operator[](T&& key) && {
-			return proxy<basic_table_core, T>(*this, std::forward<T>(key));
-		}
-
-		template<typename Sig, typename Key, typename... Args>
-		basic_table_core& set_function(Key&& key, Args&&... args) {
-			set_fx(types<Sig>(), std::forward<Key>(key), std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Key, typename... Args>
-		basic_table_core& set_function(Key&& key, Args&&... args) {
-			set_fx(types<>(), std::forward<Key>(key), std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template <typename... Args>
-		basic_table_core& add(Args&&... args) {
-			auto pp = stack::push_pop(*this);
-			(void)detail::swallow{0, 
-				(stack::set_ref(base_t::lua_state(), std::forward<Args>(args)), 0)...
-			};
-			return *this;
-		}
-
-	private:
-		template<typename R, typename... Args, typename Fx, typename Key, typename = std::result_of_t<Fx(Args...)>>
-		void set_fx(types<R(Args...)>, Key&& key, Fx&& fx) {
-			set_resolved_function<R(Args...)>(std::forward<Key>(key), std::forward<Fx>(fx));
-		}
-
-		template<typename Fx, typename Key, meta::enable<meta::is_specialization_of<overload_set, meta::unqualified_t<Fx>>> = meta::enabler>
-		void set_fx(types<>, Key&& key, Fx&& fx) {
-			set(std::forward<Key>(key), std::forward<Fx>(fx));
-		}
-
-		template<typename Fx, typename Key, typename... Args, meta::disable<meta::is_specialization_of<overload_set, meta::unqualified_t<Fx>>> = meta::enabler>
-		void set_fx(types<>, Key&& key, Fx&& fx, Args&&... args) {
-			set(std::forward<Key>(key), as_function_reference(std::forward<Fx>(fx), std::forward<Args>(args)...));
-		}
-
-		template<typename... Sig, typename... Args, typename Key>
-		void set_resolved_function(Key&& key, Args&&... args) {
-			set(std::forward<Key>(key), as_function_reference<function_sig<Sig...>>(std::forward<Args>(args)...));
-		}
-
-	public:
-		static inline table create(lua_State* L, int narr = 0, int nrec = 0) {
-			lua_createtable(L, narr, nrec);
-			table result(L);
-			lua_pop(L, 1);
-			return result;
-		}
-
-		template <typename Key, typename Value, typename... Args>
-		static inline table create(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			lua_createtable(L, narr, nrec);
-			table result(L);
-			result.set(std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-			lua_pop(L, 1);
-			return result;
-		}
-
-		template <typename... Args>
-		static inline table create_with(lua_State* L, Args&&... args) {
-			static_assert(sizeof...(Args) % 2 == 0, "You must have an even number of arguments for a key, value ... list.");
-			static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
-			return create(L, narr, static_cast<int>((sizeof...(Args) / 2) - narr), std::forward<Args>(args)...);
-		}
-
-		table create(int narr = 0, int nrec = 0) {
-			return create(base_t::lua_state(), narr, nrec);
-		}
-
-		template <typename Key, typename Value, typename... Args>
-		table create(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			return create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-		}
-
-		template <typename Name>
-		table create(Name&& name, int narr = 0, int nrec = 0) {
-			table x = create(base_t::lua_state(), narr, nrec);
-			this->set(std::forward<Name>(name), x);
-			return x;
-		}
-
-		template <typename Name, typename Key, typename Value, typename... Args>
-		table create(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			table x = create(base_t::lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-			this->set(std::forward<Name>(name), x);
-			return x;
-		}
-
-		template <typename... Args>
-		table create_with(Args&&... args) {
-			return create_with(base_t::lua_state(), std::forward<Args>(args)...);
-		}
-
-		template <typename Name, typename... Args>
-		table create_named(Name&& name, Args&&... args) {
-			static const int narr = static_cast<int>(meta::count_2_for_pack<std::is_integral, Args...>::value);
-			return create(std::forward<Name>(name), narr, sizeof...(Args) / 2 - narr, std::forward<Args>(args)...);
-		}
-
-		~basic_table_core() {
-
-		}
-	};
-} // sol
-
-// end of sol/table_core.hpp
-
-namespace sol {
-	typedef table_core<false> table;
-
-	namespace stack {
-		template <>
-		struct getter<metatable_t> {
-			static table get(lua_State* L, int index = -1) {
-				if (lua_getmetatable(L, index) == 0) {
-					return table(L, ref_index(LUA_REFNIL));
-				}
-				return table(L, -1);
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/table.hpp
-
-// beginning of sol/environment.hpp
-
-namespace sol {
-
-	template <typename base_type>
-	struct basic_environment : basic_table<base_type> {
-	private:
-		typedef basic_table<base_type> base_t;
-
-	public:
-		basic_environment() noexcept = default;
-		basic_environment(const basic_environment&) = default;
-		basic_environment(basic_environment&&) = default;
-		basic_environment& operator=(const basic_environment&) = default;
-		basic_environment& operator=(basic_environment&&) = default;
-		basic_environment(const stack_reference& r) : basic_environment(r.lua_state(), r.stack_index()) {}
-		basic_environment(stack_reference&& r) : basic_environment(r.lua_state(), r.stack_index()) {}
-
-		basic_environment(lua_State* L, new_table nt) : base_t(L, std::move(nt)) {}
-		basic_environment(lua_State* L, new_table t, const reference& fallback) : basic_environment(L, std::move(t)) {
-			sol::stack_table mt(L, sol::new_table(0, 1));
-			mt.set(sol::meta_function::index, fallback);
-			this->set(metatable_key, mt);
-			mt.pop();
-		}
-
-		basic_environment(env_t, const stack_reference& extraction_target) : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<env_t>(this->lua_state(), -1, type_panic);
-#endif // Safety
-			lua_pop(this->lua_state(), 2);
-		}
-		basic_environment(env_t, const reference& extraction_target) : base_t(detail::no_safety, extraction_target.lua_state(), (stack::push_environment_of(extraction_target), -1)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<env_t>(this->lua_state(), -1, type_panic);
-#endif // Safety
-			lua_pop(this->lua_state(), 2);
-		}
-		basic_environment(lua_State* L, int index = -1) : base_t(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<basic_environment>(L, index, type_panic);
-#endif // Safety
-		}
-		basic_environment(lua_State* L, ref_index index) : base_t(detail::no_safety, L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<basic_environment>(L, -1, type_panic);
-#endif // Safety
-		}
-		template <typename T, meta::enable<meta::neg<meta::any_same<meta::unqualified_t<T>, basic_environment>>, meta::neg<std::is_same<base_type, stack_reference>>, std::is_base_of<base_type, meta::unqualified_t<T>>> = meta::enabler>
-		basic_environment(T&& r) noexcept : base_t(detail::no_safety, std::forward<T>(r)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!is_environment<meta::unqualified_t<T>>::value) {
-				auto pp = stack::push_pop(*this);
-				stack::check<basic_environment>(base_t::lua_state(), -1, type_panic);
-			}
-#endif // Safety
-		}
-
-		template <typename T>
-		void set_on(const T& target) const {
-			lua_State* L = target.lua_state();
-			auto pp = stack::push_pop(target);
-#if SOL_LUA_VERSION < 502
-			// Use lua_setfenv
-			this->push();
-			lua_setfenv(L, -2);
-#else
-			// Use upvalues as explained in Lua 5.2 and beyond's manual
-			this->push();
-			const char* name = lua_setupvalue(L, -2, 1);
-			if (name == nullptr) {
-				this->pop();
-			}
-#endif
-		}
-	};
-
-	template <typename T, typename E>
-	void set_environment(const basic_environment<E>& env, const T& target) {
-		env.set_on(target);
-	}
-
-	template <typename E = reference, typename T>
-	basic_environment<E> get_environment(const T& target) {
-		lua_State* L = target.lua_state();
-		auto pp = stack::pop_n(L, stack::push_environment_of(target));
-		return basic_environment<E>(L, -1);
-	}
-
-	struct this_environment {
-		optional<environment> env;
-
-		this_environment() : env(nullopt) {}
-		this_environment(sol::environment e) : env(std::move(e)) {}
-		this_environment(const this_environment&) = default;
-		this_environment(this_environment&&) = default;
-		this_environment& operator=(const this_environment&) = default;
-		this_environment& operator=(this_environment&&) = default;
-
-		explicit operator bool() const {
-			return static_cast<bool>(env);
-		}
-
-		operator optional<environment>& () {
-			return env;
-		}
-
-		operator const optional<environment>& () const {
-			return env;
-		}
-
-		operator environment& () {
-			return env.value();
-		}
-
-		operator const environment& () const {
-			return env.value();
-		}
-	};
-
-	namespace stack {
-		template <>
-		struct getter<env_t> {
-			static environment get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				return get_environment(stack_reference(L, raw_index(index)));
-			}
-		};
-
-		template <>
-		struct getter<this_environment> {
-			static this_environment get(lua_State* L, int, record& tracking) {
-				tracking.use(0);
-				lua_Debug info;
-				// Level 0 means current function (this C function, which may or may not be useful for us?)
-				// Level 1 means next call frame up the stack. (Can be nothing if function called directly from C++ with lua_p/call)
-				int pre_stack_size = lua_gettop(L);
-				if (lua_getstack(L, 1, &info) != 1) {
-					if (lua_getstack(L, 0, &info) != 1) {
-						lua_settop(L, pre_stack_size);
-						return this_environment();
-					}
-				}
-				if (lua_getinfo(L, "f", &info) == 0) {
-					lua_settop(L, pre_stack_size);
-					return this_environment();
-				}
-
-				sol::stack_reference f(L, -1);
-				sol::environment env(sol::env_key, f);
-				if (!env.valid()) {
-					lua_settop(L, pre_stack_size);
-					return this_environment();
-				}
-				return this_environment(std::move(env));
-			}
-		};
-	} // stack
-} // sol
-
-// end of sol/environment.hpp
-
-// beginning of sol/load_result.hpp
-
-namespace sol {
-	struct load_result : public proxy_base<load_result> {
-	private:
-		lua_State* L;
-		int index;
-		int returncount;
-		int popcount;
-		load_status err;
-
-		template <typename T>
-		decltype(auto) tagged_get(types<optional<T>>) const {
-			if (!valid()) {
-				return optional<T>(nullopt);
-			}
-			return stack::get<optional<T>>(L, index);
-		}
-
-		template <typename T>
-		decltype(auto) tagged_get(types<T>) const {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (!valid()) {
-				type_panic(L, index, type_of(L, index), type::none);
-			}
-#endif // Check Argument Safety
-			return stack::get<T>(L, index);
-		}
-
-		optional<error> tagged_get(types<optional<error>>) const {
-			if (valid()) {
-				return nullopt;
-			}
-			return error(detail::direct_error, stack::get<std::string>(L, index));
-		}
-
-		error tagged_get(types<error>) const {
-#ifdef SOL_CHECK_ARGUMENTS
-			if (valid()) {
-				type_panic(L, index, type_of(L, index), type::none);
-			}
-#endif // Check Argument Safety
-			return error(detail::direct_error, stack::get<std::string>(L, index));
-		}
-
-	public:
-		load_result() = default;
-		load_result(lua_State* Ls, int stackindex = -1, int retnum = 0, int popnum = 0, load_status lerr = load_status::ok) noexcept : L(Ls), index(stackindex), returncount(retnum), popcount(popnum), err(lerr) {
-
-		}
-		load_result(const load_result&) = default;
-		load_result& operator=(const load_result&) = default;
-		load_result(load_result&& o) noexcept : L(o.L), index(o.index), returncount(o.returncount), popcount(o.popcount), err(o.err) {
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but we will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-			o.popcount = 0;
-			o.err = load_status::syntax;
-		}
-		load_result& operator=(load_result&& o) noexcept {
-			L = o.L;
-			index = o.index;
-			returncount = o.returncount;
-			popcount = o.popcount;
-			err = o.err;
-			// Must be manual, otherwise destructor will screw us
-			// return count being 0 is enough to keep things clean
-			// but we will be thorough
-			o.L = nullptr;
-			o.index = 0;
-			o.returncount = 0;
-			o.popcount = 0;
-			o.err = load_status::syntax;
-			return *this;
-		}
-
-		load_status status() const noexcept {
-			return err;
-		}
-
-		bool valid() const noexcept {
-			return status() == load_status::ok;
-		}
-
-		template<typename T>
-		T get() const {
-			return tagged_get(types<meta::unqualified_t<T>>());
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) {
-			return get<protected_function>().template call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Args>
-		decltype(auto) operator()(Args&&... args) {
-			return call<>(std::forward<Args>(args)...);
-		}
-
-		lua_State* lua_state() const noexcept { return L; };
-		int stack_index() const noexcept { return index; };
-
-		~load_result() {
-			stack::remove(L, index, popcount);
-		}
-	};
-} // sol
-
-// end of sol/load_result.hpp
-
-namespace sol {
-	enum class lib : char {
-		base,
-		package,
-		coroutine,
-		string,
-		os,
-		math,
-		table,
-		debug,
-		bit32,
-		io,
-		ffi,
-		jit,
-		utf8,
-		count
-	};
-
-	inline std::size_t total_memory_used(lua_State* L) {
-		std::size_t kb = lua_gc(L, LUA_GCCOUNT, 0);
-		kb *= 1024;
-		kb += lua_gc(L, LUA_GCCOUNTB, 0);
-		return kb;
-	}
-
-	inline protected_function_result simple_on_error(lua_State*, sol::protected_function_result result) {
-		return result;
-	}
-
-	inline protected_function_result default_on_error( lua_State* L, protected_function_result pfr ) {
-		type t = type_of(L, pfr.stack_index());
-		std::string err = to_string(pfr.status()) + " error";
-		if (t == type::string) {
-			err += " ";
-			err += stack::get<std::string>(L, pfr.stack_index());
-		}
-#ifdef SOL_NO_EXCEPTIONS
-		if (t != type::nil) {
-			lua_pop(L, 1);
-		}
-		stack::push(L, err);
-		lua_error(L);
-#else
-		throw error(detail::direct_error, err);
-#endif
-		return pfr;
-	}
-
-	class state_view {
-	private:
-		lua_State* L;
-		table reg;
-		global_table global;
-
-		optional<object> is_loaded_package(const std::string& key) {
-			auto loaded = reg.traverse_get<optional<object>>("_LOADED", key);
-			bool is53mod = loaded && !(loaded->is<bool>() && !loaded->as<bool>());
-			if (is53mod)
-				return loaded;
-#if SOL_LUA_VERSION <= 501
-			auto loaded51 = global.traverse_get<optional<object>>("package", "loaded", key);
-			bool is51mod = loaded51 && !(loaded51->is<bool>() && !loaded51->as<bool>());
-			if (is51mod)
-				return loaded51;
-#endif
-			return nullopt;
-		}
-
-		template <typename T>
-		void ensure_package(const std::string& key, T&& sr) {
-#if SOL_LUA_VERSION <= 501
-			auto pkg = global["package"];
-			if (!pkg.valid()) {
-				pkg = create_table_with("loaded", create_table_with(key, sr));
-			}
-			else {
-				auto ld = pkg["loaded"];
-				if (!ld.valid()) {
-					ld = create_table_with(key, sr);
-				}
-				else {
-					ld[key] = sr;
-				}
-			}
-#endif
-			auto loaded = reg["_LOADED"];
-			if (!loaded.valid()) {
-				loaded = create_table_with(key, sr);
-			}
-			else {
-				loaded[key] = sr;
-			}
-		}
-
-		template <typename Fx>
-		object require_core(const std::string& key, Fx&& action, bool create_global = true) {
-			optional<object> loaded = is_loaded_package(key);
-			if (loaded && loaded->valid())
-				return std::move(*loaded);
-			action();
-			auto sr = stack::get<stack_reference>(L);
-			if (create_global)
-				set(key, sr);
-			ensure_package(key, sr);
-			return stack::pop<object>(L);
-		}
-
-	public:
-		typedef global_table::iterator iterator;
-		typedef global_table::const_iterator const_iterator;
-
-		state_view(lua_State* Ls) :
-			L(Ls),
-			reg(Ls, LUA_REGISTRYINDEX),
-			global(Ls, detail::global_) {
-
-		}
-
-		state_view(this_state Ls) : state_view(Ls.L){
-
-		}
-
-		lua_State* lua_state() const {
-			return L;
-		}
-
-		template<typename... Args>
-		void open_libraries(Args&&... args) {
-			static_assert(meta::all_same<lib, Args...>::value, "all types must be libraries");
-			if (sizeof...(args) == 0) {
-				luaL_openlibs(L);
-				return;
-			}
-
-			lib libraries[1 + sizeof...(args)] = { lib::count, std::forward<Args>(args)... };
-
-			for (auto&& library : libraries) {
-				switch (library) {
-#if SOL_LUA_VERSION <= 501 && defined(SOL_LUAJIT)
-				case lib::coroutine:
-#endif // luajit opens coroutine base stuff
-				case lib::base:
-					luaL_requiref(L, "base", luaopen_base, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::package:
-					luaL_requiref(L, "package", luaopen_package, 1);
-					lua_pop(L, 1);
-					break;
-#if !defined(SOL_LUAJIT)
-				case lib::coroutine:
-#if SOL_LUA_VERSION > 501
-					luaL_requiref(L, "coroutine", luaopen_coroutine, 1);
-					lua_pop(L, 1);
-#endif // Lua 5.2+ only
-					break;
-#endif // Not LuaJIT - comes builtin
-				case lib::string:
-					luaL_requiref(L, "string", luaopen_string, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::table:
-					luaL_requiref(L, "table", luaopen_table, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::math:
-					luaL_requiref(L, "math", luaopen_math, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::bit32:
-#ifdef SOL_LUAJIT
-					luaL_requiref(L, "bit32", luaopen_bit, 1);
-					lua_pop(L, 1);
-#elif (SOL_LUA_VERSION == 502) || defined(LUA_COMPAT_BITLIB)  || defined(LUA_COMPAT_5_2)
-					luaL_requiref(L, "bit32", luaopen_bit32, 1);
-					lua_pop(L, 1);
-#else
-#endif // Lua 5.2 only (deprecated in 5.3 (503)) (Can be turned on with Compat flags)
-					break;
-				case lib::io:
-					luaL_requiref(L, "io", luaopen_io, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::os:
-					luaL_requiref(L, "os", luaopen_os, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::debug:
-					luaL_requiref(L, "debug", luaopen_debug, 1);
-					lua_pop(L, 1);
-					break;
-				case lib::utf8:
-#if SOL_LUA_VERSION > 502 && !defined(SOL_LUAJIT)
-					luaL_requiref(L, "utf8", luaopen_utf8, 1);
-					lua_pop(L, 1);
-#endif // Lua 5.3+ only
-					break;
-				case lib::ffi:
-#ifdef SOL_LUAJIT
-					luaL_requiref(L, "ffi", luaopen_ffi, 1);
-					lua_pop(L, 1);
-#endif // LuaJIT only
-					break;
-				case lib::jit:
-#ifdef SOL_LUAJIT
-					luaL_requiref(L, "jit", luaopen_jit, 1);
-					lua_pop(L, 1);
-#endif // LuaJIT Only
-					break;
-				case lib::count:
-				default:
-					break;
-				}
-			}
-		}
-
-		object require(const std::string& key, lua_CFunction open_function, bool create_global = true) {
-			luaL_requiref(L, key.c_str(), open_function, create_global ? 1 : 0);
-			return stack::pop<object>(L);
-		}
-
-		object require_script(const std::string& key, const std::string& code, bool create_global = true) {
-			return require_core(key, [this, &code]() {stack::script(L, code); }, create_global);
-		}
-
-		object require_file(const std::string& key, const std::string& filename, bool create_global = true) {
-			return require_core(key, [this, &filename]() {stack::script_file(L, filename); }, create_global);
-		}
-
-		template <typename E>
-		protected_function_result do_string(const std::string& code, const basic_environment<E>& env) {
-			load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
-			if (x != load_status::ok) {
-				return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
-			}
-			protected_function pf(L, -1);
-			pf.pop();
-			set_environment(env, pf);
-			return pf();
-		}
-
-		template <typename E>
-		protected_function_result do_file(const std::string& filename, const basic_environment<E>& env) {
-			load_status x = static_cast<load_status>(luaL_loadfile(L, filename.c_str()));
-			if (x != load_status::ok) {
-				return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
-			}
-			protected_function pf(L, -1);
-			pf.pop();
-			set_environment(env, pf);
-			return pf();
-		}
-
-		protected_function_result do_string(const std::string& code) {
-			load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
-			if (x != load_status::ok) {
-				return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
-			}
-			protected_function pf(L, -1);
-			pf.pop();
-			return pf();
-		}
-
-		protected_function_result do_file(const std::string& filename) {
-			load_status x = static_cast<load_status>(luaL_loadfile(L, filename.c_str()));
-			if (x != load_status::ok) {
-				return protected_function_result(L, -1, 0, 1, static_cast<call_status>(x));
-			}
-			protected_function pf(L, -1);
-			pf.pop();
-			return pf();
-		}
-
-		protected_function_result script(const std::string& code, const environment& env) {
-			return script(code, env, sol::default_on_error);
-		}
-
-		protected_function_result script_file(const std::string& filename, const environment& env) {
-			return script_file(filename, env, sol::default_on_error);
-		}
-
-		template <typename Fx, meta::disable<meta::is_specialization_of<basic_environment, meta::unqualified_t<Fx>>> = meta::enabler>
-		protected_function_result script(const std::string& code, Fx&& on_error) {
-			protected_function_result pfr = do_string(code);
-			if (!pfr.valid()) {
-				return on_error(L, std::move(pfr));
-			}
-			return pfr;
-		}
-
-		template <typename Fx, meta::disable<meta::is_specialization_of<basic_environment, meta::unqualified_t<Fx>>> = meta::enabler>
-		protected_function_result script_file(const std::string& filename, Fx&& on_error) {
-			protected_function_result pfr = do_file(filename);
-			if (!pfr.valid()) {
-				return on_error(L, std::move(pfr));
-			}
-			return pfr;
-		}
-
-		template <typename Fx, typename E>
-		protected_function_result script(const std::string& code, const basic_environment<E>& env, Fx&& on_error) {
-			protected_function_result pfr = do_string(code, env);
-			if (!pfr.valid()) {
-				return on_error(L, std::move(pfr));
-			}
-			return pfr;
-		}
-
-		template <typename Fx, typename E>
-		protected_function_result script_file(const std::string& filename, const basic_environment<E>& env, Fx&& on_error) {
-			protected_function_result pfr = do_file(filename, env);
-			if (!pfr.valid()) {
-				return on_error(L, std::move(pfr));
-			}
-			return pfr;
-		}
-
-		function_result script(const std::string& code) {
-			int index = lua_gettop(L);
-			stack::script(L, code);
-			int postindex = lua_gettop(L);
-			int returns = postindex - index;
-			return function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
-		}
-
-		function_result script_file(const std::string& filename) {
-			int index = lua_gettop(L);
-			stack::script_file(L, filename);
-			int postindex = lua_gettop(L);
-			int returns = postindex - index;
-			return function_result(L, (std::max)(postindex - (returns - 1), 1), returns);
-		}
-
-		load_result load(const std::string& code) {
-			load_status x = static_cast<load_status>(luaL_loadstring(L, code.c_str()));
-			return load_result(L, lua_absindex(L, -1), 1, 1, x);
-		}
-
-		load_result load_file(const std::string& filename) {
-			load_status x = static_cast<load_status>(luaL_loadfile(L, filename.c_str()));
-			return load_result(L, lua_absindex(L, -1), 1, 1, x);
-		}
-
-		load_result load_buffer(const char *buff, size_t size, const char *name, const char* mode = nullptr) {
-			load_status x = static_cast<load_status>(luaL_loadbufferx(L, buff, size, name, mode));
-			return load_result(L, lua_absindex(L, -1), 1, 1, x);
-		}
-
-		iterator begin() const {
-			return global.begin();
-		}
-
-		iterator end() const {
-			return global.end();
-		}
-
-		const_iterator cbegin() const {
-			return global.cbegin();
-		}
-
-		const_iterator cend() const {
-			return global.cend();
-		}
-
-		global_table globals() const {
-			return global;
-		}
-
-		table registry() const {
-			return reg;
-		}
-
-		std::size_t memory_used() const {
-			return total_memory_used(lua_state());
-		}
-
-		void collect_garbage() {
-			lua_gc(lua_state(), LUA_GCCOLLECT, 0);
-		}
-
-		operator lua_State* () const {
-			return lua_state();
-		}
-
-		void set_panic(lua_CFunction panic) {
-			lua_atpanic(L, panic);
-		}
-
-		template<typename... Args, typename... Keys>
-		decltype(auto) get(Keys&&... keys) const {
-			return global.get<Args...>(std::forward<Keys>(keys)...);
-		}
-
-		template<typename T, typename Key>
-		decltype(auto) get_or(Key&& key, T&& otherwise) const {
-			return global.get_or(std::forward<Key>(key), std::forward<T>(otherwise));
-		}
-
-		template<typename T, typename Key, typename D>
-		decltype(auto) get_or(Key&& key, D&& otherwise) const {
-			return global.get_or<T>(std::forward<Key>(key), std::forward<D>(otherwise));
-		}
-
-		template<typename... Args>
-		state_view& set(Args&&... args) {
-			global.set(std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename T, typename... Keys>
-		decltype(auto) traverse_get(Keys&&... keys) const {
-			return global.traverse_get<T>(std::forward<Keys>(keys)...);
-		}
-
-		template<typename... Args>
-		state_view& traverse_set(Args&&... args) {
-			global.traverse_set(std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename T>
-		state_view& set_usertype(usertype<T>& user) {
-			return set_usertype(usertype_traits<T>::name(), user);
-		}
-
-		template<typename Key, typename T>
-		state_view& set_usertype(Key&& key, usertype<T>& user) {
-			global.set_usertype(std::forward<Key>(key), user);
-			return *this;
-		}
-
-		template<typename Class, typename... Args>
-		state_view& new_usertype(const std::string& name, Args&&... args) {
-			global.new_usertype<Class>(name, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		state_view& new_usertype(const std::string& name, Args&&... args) {
-			global.new_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Class, typename... CArgs, typename... Args>
-		state_view& new_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
-			global.new_usertype<Class>(name, ctor, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Class, typename... Args>
-		state_view& new_simple_usertype(const std::string& name, Args&&... args) {
-			global.new_simple_usertype<Class>(name, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		state_view& new_simple_usertype(const std::string& name, Args&&... args) {
-			global.new_simple_usertype<Class, CTor0, CTor...>(name, std::forward<Args>(args)...);
-			return *this;
-		}
-		
-		template<typename Class, typename... CArgs, typename... Args>
-		state_view& new_simple_usertype(const std::string& name, constructors<CArgs...> ctor, Args&&... args) {
-			global.new_simple_usertype<Class>(name, ctor, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename Class, typename... Args>
-		simple_usertype<Class> create_simple_usertype(Args&&... args) {
-			return global.create_simple_usertype<Class>(std::forward<Args>(args)...);
-		}
-
-		template<typename Class, typename CTor0, typename... CTor, typename... Args>
-		simple_usertype<Class> create_simple_usertype(Args&&... args) {
-			return global.create_simple_usertype<Class, CTor0, CTor...>(std::forward<Args>(args)...);
-		}
-
-		template<typename Class, typename... CArgs, typename... Args>
-		simple_usertype<Class> create_simple_usertype(constructors<CArgs...> ctor, Args&&... args) {
-			return global.create_simple_usertype<Class>(ctor, std::forward<Args>(args)...);
-		}
-
-		template<bool read_only = true, typename... Args>
-		state_view& new_enum(const std::string& name, Args&&... args) {
-			global.new_enum<read_only>(name, std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template <typename Fx>
-		void for_each(Fx&& fx) {
-			global.for_each(std::forward<Fx>(fx));
-		}
-
-		template<typename T>
-		proxy<global_table&, T> operator[](T&& key) {
-			return global[std::forward<T>(key)];
-		}
-
-		template<typename T>
-		proxy<const global_table&, T> operator[](T&& key) const {
-			return global[std::forward<T>(key)];
-		}
-
-		template<typename Sig, typename... Args, typename Key>
-		state_view& set_function(Key&& key, Args&&... args) {
-			global.set_function<Sig>(std::forward<Key>(key), std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template<typename... Args, typename Key>
-		state_view& set_function(Key&& key, Args&&... args) {
-			global.set_function(std::forward<Key>(key), std::forward<Args>(args)...);
-			return *this;
-		}
-
-		template <typename Name>
-		table create_table(Name&& name, int narr = 0, int nrec = 0) {
-			return global.create(std::forward<Name>(name), narr, nrec);
-		}
-
-		template <typename Name, typename Key, typename Value, typename... Args>
-		table create_table(Name&& name, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			return global.create(std::forward<Name>(name), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-		}
-
-		template <typename Name, typename... Args>
-		table create_named_table(Name&& name, Args&&... args) {
-			table x = global.create_with(std::forward<Args>(args)...);
-			global.set(std::forward<Name>(name), x);
-			return x;
-		}
-
-		table create_table(int narr = 0, int nrec = 0) {
-			return create_table(lua_state(), narr, nrec);
-		}
-
-		template <typename Key, typename Value, typename... Args>
-		table create_table(int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			return create_table(lua_state(), narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-		}
-
-		template <typename... Args>
-		table create_table_with(Args&&... args) {
-			return create_table_with(lua_state(), std::forward<Args>(args)...);
-		}
-
-		static inline table create_table(lua_State* L, int narr = 0, int nrec = 0) {
-			return global_table::create(L, narr, nrec);
-		}
-
-		template <typename Key, typename Value, typename... Args>
-		static inline table create_table(lua_State* L, int narr, int nrec, Key&& key, Value&& value, Args&&... args) {
-			return global_table::create(L, narr, nrec, std::forward<Key>(key), std::forward<Value>(value), std::forward<Args>(args)...);
-		}
-
-		template <typename... Args>
-		static inline table create_table_with(lua_State* L, Args&&... args) {
-			return global_table::create_with(L, std::forward<Args>(args)...);
-		}
-	};
-} // sol
-
-// end of sol/state_view.hpp
-
-namespace sol {
-	inline int default_at_panic(lua_State* L) {
-#ifdef SOL_NO_EXCEPTIONS
-		(void)L;
-		return -1;
-#else
-		const char* message = lua_tostring(L, -1);
-		if (message) {
-			std::string err = message;
-			lua_settop(L, 0);
-			throw error(err);
-		}
-		lua_settop(L, 0);
-		throw error(std::string("An unexpected error occurred and forced the lua state to call atpanic"));
-#endif
-	}
-
-	inline int default_error_handler(lua_State*L) {
-		using namespace sol;
-		std::string msg = "An unknown error has triggered the default error handler";
-		optional<string_detail::string_shim> maybetopmsg = stack::check_get<string_detail::string_shim>(L, 1);
-		if (maybetopmsg) {
-			const string_detail::string_shim& topmsg = maybetopmsg.value();
-			msg.assign(topmsg.c_str(), topmsg.size());
-		}
-		luaL_traceback(L, L, msg.c_str(), 1);
-		optional<string_detail::string_shim> maybetraceback = stack::check_get<string_detail::string_shim>(L, -1);
-		if (maybetraceback) {
-			const string_detail::string_shim& traceback = maybetraceback.value();
-			msg.assign(traceback.c_str(), traceback.size());
-		}
-		return stack::push(L, msg);
-	}
-
-	class state : private std::unique_ptr<lua_State, void(*)(lua_State*)>, public state_view {
-	private:
-		typedef std::unique_ptr<lua_State, void(*)(lua_State*)> unique_base;
-	public:
-		state(lua_CFunction panic = default_at_panic) : unique_base(luaL_newstate(), lua_close),
-			state_view(unique_base::get()) {
-			set_panic(panic);
-			stack::luajit_exception_handler(unique_base::get());
-		}
-
-		state(lua_CFunction panic, lua_Alloc alfunc, void* alpointer = nullptr) : unique_base(lua_newstate(alfunc, alpointer), lua_close),
-			state_view(unique_base::get()) {
-			set_panic(panic);
-			sol::protected_function::set_default_handler(sol::object(lua_state(), in_place, default_error_handler));
-			stack::luajit_exception_handler(unique_base::get());
-		}
-
-		state(const state&) = delete;
-		state(state&&) = default;
-		state& operator=(const state&) = delete;
-		state& operator=(state&& that) {
-			state_view::operator=(std::move(that));
-			unique_base::operator=(std::move(that));
-			return *this;
-		}
-
-		using state_view::get;
-
-		~state() {
-			auto& handler = protected_function::get_default_handler();
-			if (handler.lua_state() == this->lua_state()) {
-				protected_function::set_default_handler(reference());
-			}
-		}
-	};
-} // sol
-
-// end of sol/state.hpp
-
-// beginning of sol/coroutine.hpp
-
-// beginning of sol/thread.hpp
-
-namespace sol {
-	struct lua_thread_state {
-		lua_State* L;
-		operator lua_State* () const {
-			return L;
-		}
-		lua_State* operator-> () const {
-			return L;
-		}
-	};
-
-	namespace stack {
-
-		template <>
-		struct pusher<lua_thread_state> {
-			int push(lua_State*, lua_thread_state lts) {
-				lua_pushthread(lts.L);
-				return 1;
-			}
-		};
-
-		template <>
-		struct getter<lua_thread_state> {
-			lua_thread_state get(lua_State* L, int index, record& tracking) {
-				tracking.use(1);
-				lua_thread_state lts{ lua_tothread(L, index) };
-				return lts;
-			}
-		};
-
-		template <>
-		struct check_getter<lua_thread_state> {
-			template <typename Handler>
-			optional<lua_thread_state> get(lua_State* L, int index, Handler&& handler, record& tracking) {
-				lua_thread_state lts{ lua_tothread(L, index) };
-				if (lts.L == nullptr) {
-					handler(L, index, type::thread, type_of(L, index));
-					return nullopt;
-				}
-				tracking.use(1);
-				return lts;
-			}
-		};
-
-	}
-
-#if SOL_LUA_VERSION < 502
-	inline lua_State* main_thread(lua_State*, lua_State* backup_if_unsupported = nullptr) {
-		return backup_if_unsupported;
-	}
-#else
-	inline lua_State* main_thread(lua_State* L, lua_State* = nullptr) {
-		lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_MAINTHREAD);
-		lua_thread_state s = stack::pop<lua_thread_state>(L);
-		return s.L;
-	}
-#endif // Lua 5.2+ has the main thread getter
-
-	class thread : public reference {
-	public:
-		thread() noexcept = default;
-		thread(const thread&) = default;
-		thread(thread&&) = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, thread>>, std::is_base_of<reference, meta::unqualified_t<T>>> = meta::enabler>
-		thread(T&& r) : reference(std::forward<T>(r)) {}
-		thread(const stack_reference& r) : thread(r.lua_state(), r.stack_index()) {};
-		thread(stack_reference&& r) : thread(r.lua_state(), r.stack_index()) {};
-		thread& operator=(const thread&) = default;
-		thread& operator=(thread&&) = default;
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
-		thread(lua_State* L, T&& r) : thread(L, sol::ref_index(r.registry_index())) {}
-		thread(lua_State* L, int index = -1) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			type_assert(L, index, type::thread);
-#endif // Safety
-		}
-		thread(lua_State* L, ref_index index) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			type_assert(L, -1, type::thread);
-#endif // Safety
-		}
-		thread(lua_State* L, lua_State* actualthread) : thread(L, lua_thread_state{ actualthread }) {}
-		thread(lua_State* L, sol::this_state actualthread) : thread(L, lua_thread_state{ actualthread.L }) {}
-		thread(lua_State* L, lua_thread_state actualthread) : reference(L, -stack::push(L, actualthread)) {
-#ifdef SOL_CHECK_ARGUMENTS
-			type_assert(L, -1, type::thread);
-#endif // Safety
-			lua_pop(L, 1);
-		}
-
-		state_view state() const {
-			return state_view(this->thread_state());
-		}
-
-		bool is_main_thread() const {
-			int ismainthread = lua_pushthread(this->thread_state());
-			lua_pop(this->thread_state(), 1);
-			return ismainthread == 1;
-		}
-
-		lua_State* thread_state() const {
-			auto pp = stack::push_pop(*this);
-			lua_State* lthread = lua_tothread(lua_state(), -1);
-			return lthread;
-		}
-
-		thread_status status() const {
-			lua_State* lthread = thread_state();
-			thread_status lstat = static_cast<thread_status>(lua_status(lthread));
-			if (lstat != thread_status::ok && lua_gettop(lthread) == 0) {
-				// No thing on the thread's stack means its dead
-				return thread_status::dead;
-			}
-			return lstat;
-		}
-
-		thread create() {
-			return create(lua_state());
-		}
-
-		static thread create(lua_State* L) {
-			lua_newthread(L);
-			thread result(L);
-			lua_pop(L, 1);
-			return result;
-		}
-	};
-} // sol
-
-// end of sol/thread.hpp
-
-namespace sol {
-	class coroutine : public reference {
-	private:
-		call_status stats = call_status::yielded;
-
-		void luacall(std::ptrdiff_t argcount, std::ptrdiff_t) {
-#if SOL_LUA_VERSION < 502
-			stats = static_cast<call_status>(lua_resume(lua_state(), static_cast<int>(argcount)));
-#elif SOL_LUA_VERSION < 504
-			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount)));
-#else
-			int nstack = 0;
-			stats = static_cast<call_status>(lua_resume(lua_state(), nullptr, static_cast<int>(argcount), &nstack));
-#endif
-		}
-
-		template<std::size_t... I, typename... Ret>
-		auto invoke(types<Ret...>, std::index_sequence<I...>, std::ptrdiff_t n) {
-			luacall(n, sizeof...(Ret));
-			return stack::pop<std::tuple<Ret...>>(lua_state());
-		}
-
-		template<std::size_t I, typename Ret>
-		Ret invoke(types<Ret>, std::index_sequence<I>, std::ptrdiff_t n) {
-			luacall(n, 1);
-			return stack::pop<Ret>(lua_state());
-		}
-
-		template <std::size_t I>
-		void invoke(types<void>, std::index_sequence<I>, std::ptrdiff_t n) {
-			luacall(n, 0);
-		}
-
-		protected_function_result invoke(types<>, std::index_sequence<>, std::ptrdiff_t n) {
-			int stacksize = lua_gettop(lua_state());
-			int firstreturn = (std::max)(1, stacksize - static_cast<int>(n));
-			luacall(n, LUA_MULTRET);
-			int poststacksize = lua_gettop(lua_state());
-			int returncount = poststacksize - (firstreturn - 1);
-			if (error()) {
-				return protected_function_result(lua_state(), lua_absindex(lua_state(), -1), 1, returncount, status());
-			}
-			return protected_function_result(lua_state(), firstreturn, returncount, returncount, status());
-		}
-
-	public:
-		coroutine() noexcept = default;
-		coroutine(const coroutine&) noexcept = default;
-		coroutine(coroutine&&) noexcept = default;
-		coroutine& operator=(const coroutine&) noexcept = default;
-		coroutine& operator=(coroutine&&) noexcept = default;
-		template <typename T, meta::enable<meta::neg<std::is_same<meta::unqualified_t<T>, coroutine>>, std::is_base_of<reference, meta::unqualified_t<T>>> = meta::enabler>
-		coroutine(T&& r) : reference(std::forward<T>(r)) {}
-		coroutine(lua_nil_t r) : reference(r) {}
-		coroutine(const stack_reference& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {}
-		coroutine(stack_reference&& r) noexcept : coroutine(r.lua_state(), r.stack_index()) {}
-		template <typename T, meta::enable<meta::neg<std::is_integral<meta::unqualified_t<T>>>, meta::neg<std::is_same<T, ref_index>>> = meta::enabler>
-		coroutine(lua_State* L, T&& r) : coroutine(L, sol::ref_index(r.registry_index())) {}
-		coroutine(lua_State* L, int index = -1) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			stack::check<coroutine>(L, index, type_panic);
-#endif // Safety
-		}
-		coroutine(lua_State* L, ref_index index) : reference(L, index) {
-#ifdef SOL_CHECK_ARGUMENTS
-			auto pp = stack::push_pop(*this);
-			stack::check<coroutine>(L, -1, type_panic);
-#endif // Safety
-		}
-
-		call_status status() const noexcept {
-			return stats;
-		}
-
-		bool error() const noexcept {
-			call_status cs = status();
-			return cs != call_status::ok && cs != call_status::yielded;
-		}
-
-		bool runnable() const noexcept {
-			return valid()
-				&& (status() == call_status::yielded);
-		}
-
-		explicit operator bool() const noexcept {
-			return runnable();
-		}
-
-		template<typename... Args>
-		protected_function_result operator()(Args&&... args) {
-			return call<>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) operator()(types<Ret...>, Args&&... args) {
-			return call<Ret...>(std::forward<Args>(args)...);
-		}
-
-		template<typename... Ret, typename... Args>
-		decltype(auto) call(Args&&... args) {
-			push();
-			int pushcount = stack::multi_push(lua_state(), std::forward<Args>(args)...);
-			return invoke(types<Ret...>(), std::make_index_sequence<sizeof...(Ret)>(), pushcount);
-		}
-	};
-} // sol
-
-// end of sol/coroutine.hpp
-
-#ifdef __GNUC__
-#pragma GCC diagnostic pop
-#elif defined _MSC_VER
-#pragma warning( push )
-#endif // g++
-
-#ifdef SOL_INSIDE_UNREAL
-#ifdef SOL_INSIDE_UNREAL_REMOVED_CHECK
-#if DO_CHECK
-#define check(expr) { if(UNLIKELY(!(expr))) { FDebug::LogAssertFailedMessage( #expr, __FILE__, __LINE__ ); _DebugBreakAndPromptForRemote(); FDebug::AssertFailed( #expr, __FILE__, __LINE__ ); CA_ASSUME(false); } }
-#else
-#define check(expr) { CA_ASSUME(expr); }
-#endif
-#endif 
-#endif // Unreal Engine 4 Bullshit
-
-#endif // SOL_HPP
-// end of sol.hpp
-
-#endif // SOL_SINGLE_INCLUDE_HPP
diff --git a/unit_tests/CMakeLists.txt b/unit_tests/CMakeLists.txt
index 86a5297e5..cf2ece5c0 100644
--- a/unit_tests/CMakeLists.txt
+++ b/unit_tests/CMakeLists.txt
@@ -114,10 +114,12 @@ add_executable(library-partition-tests
     EXCLUDE_FROM_ALL
     ${LibraryPartitionTestsSources})
 
-add_executable(server-tests
+if (BUILD_ROUTED)
+  add_executable(server-tests
 	EXCLUDE_FROM_ALL
 	${ServerTestsSources}
 	$<TARGET_OBJECTS:UTIL> $<TARGET_OBJECTS:SERVER>)
+endif()
 
 add_executable(util-tests
 	EXCLUDE_FROM_ALL
@@ -170,7 +172,9 @@ target_link_libraries(library-extract-tests osrm_extract osrm_guidance ${Boost_U
 target_link_libraries(library-contract-tests osrm_contract ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(library-customize-tests osrm_customize ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(library-partition-tests osrm_partition ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
-target_link_libraries(server-tests osrm ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+if (BUILD_ROUTED)
+  target_link_libraries(server-tests osrm ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
+endif()
 target_link_libraries(util-tests ${UTIL_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(contractor-tests osrm_contract ${CONTRACTOR_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 target_link_libraries(storage-tests osrm_store ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
diff --git a/unit_tests/common/range_tools.hpp b/unit_tests/common/range_tools.hpp
index 904ded9c1..dc10c9a3d 100644
--- a/unit_tests/common/range_tools.hpp
+++ b/unit_tests/common/range_tools.hpp
@@ -3,7 +3,7 @@
 
 #include <boost/test/unit_test.hpp>
 
-#define REQUIRE_SIZE_RANGE(range, ref) BOOST_REQUIRE_EQUAL(range.size(), ref)
+#define REQUIRE_SIZE_RANGE(range, ref) BOOST_REQUIRE_EQUAL((range).size(), ref)
 #define CHECK_EQUAL_RANGE(range, ...)                                                              \
     do                                                                                             \
     {                                                                                              \
@@ -11,9 +11,11 @@
         const auto &rhs = {__VA_ARGS__};                                                           \
         BOOST_CHECK_EQUAL_COLLECTIONS(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());             \
     } while (0)
-#define CHECK_EQUAL_COLLECTIONS(lhs, rhs)                                                          \
+#define CHECK_EQUAL_COLLECTIONS(coll_lhs, coll_rhs)                                                \
     do                                                                                             \
     {                                                                                              \
+        const auto &lhs = coll_lhs;                                                                \
+        const auto &rhs = coll_rhs;                                                                \
         BOOST_CHECK_EQUAL_COLLECTIONS(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());             \
     } while (0)
 
diff --git a/unit_tests/contractor/contracted_edge_container.cpp b/unit_tests/contractor/contracted_edge_container.cpp
index 9418f73a4..50d6480f8 100644
--- a/unit_tests/contractor/contracted_edge_container.cpp
+++ b/unit_tests/contractor/contracted_edge_container.cpp
@@ -27,8 +27,8 @@ std::ostream &operator<<(std::ostream &out, const QueryEdge &edge)
     out << "{" << edge.source << ", " << edge.target << ", " << edge.data << "}";
     return out;
 }
-}
-}
+} // namespace contractor
+} // namespace osrm
 
 BOOST_AUTO_TEST_SUITE(contracted_edge_container)
 
diff --git a/unit_tests/contractor/helper.hpp b/unit_tests/contractor/helper.hpp
index de9f6b618..e0dd159fd 100644
--- a/unit_tests/contractor/helper.hpp
+++ b/unit_tests/contractor/helper.hpp
@@ -38,7 +38,7 @@ inline contractor::ContractorGraph makeGraph(const std::vector<TestEdge> &edges)
 
     return contractor::ContractorGraph{max_id + 1, std::move(input_edges)};
 }
-}
-}
+} // namespace unit_test
+} // namespace osrm
 
 #endif
diff --git a/unit_tests/customizer/cell_customization.cpp b/unit_tests/customizer/cell_customization.cpp
index d5a3f9eb8..58a468281 100644
--- a/unit_tests/customizer/cell_customization.cpp
+++ b/unit_tests/customizer/cell_customization.cpp
@@ -56,7 +56,7 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
     return partitioner::MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(
         mlp, max_id + 1, edges);
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(cell_customization_tests)
 
@@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(four_levels_test)
     };
 
     auto graph = makeGraph(mlp, edges);
-    std::vector<bool> node_filter(true, graph.GetNumberOfNodes());
+    std::vector<bool> node_filter(graph.GetNumberOfNodes(), true);
 
     CellStorage storage(mlp, graph);
     auto metric = storage.MakeMetric();
diff --git a/unit_tests/engine/geometry_string.cpp b/unit_tests/engine/geometry_string.cpp
index 27727c2ca..c08972d06 100644
--- a/unit_tests/engine/geometry_string.cpp
+++ b/unit_tests/engine/geometry_string.cpp
@@ -135,7 +135,7 @@ BOOST_AUTO_TEST_CASE(incorrect_polylines)
     };
     util::Coordinate coord{util::FloatLongitude{0}, util::FloatLatitude{0}};
 
-    for (auto polyline : polylines)
+    for (const auto &polyline : polylines)
     {
         const auto result = decodePolyline(polyline);
         BOOST_CHECK(result.size() == 1);
diff --git a/unit_tests/engine/offline_facade.cpp b/unit_tests/engine/offline_facade.cpp
index 1307450be..7c264e176 100644
--- a/unit_tests/engine/offline_facade.cpp
+++ b/unit_tests/engine/offline_facade.cpp
@@ -18,9 +18,9 @@ namespace offline
 struct Algorithm final
 {
 };
-}
+} // namespace offline
 
-} // routing_algorithms
+} // namespace routing_algorithms
 
 // Define engine data for offline data facade
 template <> struct SearchEngineData<routing_algorithms::offline::Algorithm>
@@ -386,7 +386,7 @@ class ContiguousInternalMemoryDataFacade<routing_algorithms::offline::Algorithm>
     }
 };
 
-} // datafacade
+} // namespace datafacade
 
 // Fallback to MLD algorithm: requires from data facade MLD specific members
 namespace routing_algorithms
@@ -427,11 +427,11 @@ void unpackPath(const FacadeT &facade,
     mld::unpackPath(facade, packed_path_begin, packed_path_end, phantom_nodes, unpacked_path);
 }
 
-} // offline
-} // routing_algorithms
+} // namespace offline
+} // namespace routing_algorithms
 
-} // engine
-} // osrm
+} // namespace engine
+} // namespace osrm
 
 BOOST_AUTO_TEST_SUITE(offline_facade)
 
diff --git a/unit_tests/extractor/graph_compressor.cpp b/unit_tests/extractor/graph_compressor.cpp
index 470463df7..e49932afb 100644
--- a/unit_tests/extractor/graph_compressor.cpp
+++ b/unit_tests/extractor/graph_compressor.cpp
@@ -68,7 +68,6 @@ BOOST_AUTO_TEST_CASE(long_road_test)
     std::unordered_set<NodeID> barrier_nodes;
     std::unordered_set<NodeID> traffic_lights;
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     std::vector<NodeBasedEdgeAnnotation> annotations(1);
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
@@ -92,7 +91,6 @@ BOOST_AUTO_TEST_CASE(long_road_test)
                         traffic_lights,
                         scripting_environment,
                         restrictions,
-                        conditional_restrictions,
                         maneuver_overrides,
                         graph,
                         annotations,
@@ -116,7 +114,6 @@ BOOST_AUTO_TEST_CASE(loop_test)
     std::unordered_set<NodeID> barrier_nodes;
     std::unordered_set<NodeID> traffic_lights;
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     std::vector<NodeBasedEdgeAnnotation> annotations(1);
     test::MockScriptingEnvironment scripting_environment;
@@ -154,7 +151,6 @@ BOOST_AUTO_TEST_CASE(loop_test)
                         traffic_lights,
                         scripting_environment,
                         restrictions,
-                        conditional_restrictions,
                         maneuver_overrides,
                         graph,
                         annotations,
@@ -182,7 +178,6 @@ BOOST_AUTO_TEST_CASE(t_intersection)
     std::unordered_set<NodeID> traffic_lights;
     std::vector<NodeBasedEdgeAnnotation> annotations(1);
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -205,7 +200,6 @@ BOOST_AUTO_TEST_CASE(t_intersection)
                         traffic_lights,
                         scripting_environment,
                         restrictions,
-                        conditional_restrictions,
                         maneuver_overrides,
                         graph,
                         annotations,
@@ -227,7 +221,6 @@ BOOST_AUTO_TEST_CASE(street_name_changes)
     std::unordered_set<NodeID> traffic_lights;
     std::vector<NodeBasedEdgeAnnotation> annotations(2);
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -246,7 +239,6 @@ BOOST_AUTO_TEST_CASE(street_name_changes)
                         traffic_lights,
                         scripting_environment,
                         restrictions,
-                        conditional_restrictions,
                         maneuver_overrides,
                         graph,
                         annotations,
@@ -267,7 +259,6 @@ BOOST_AUTO_TEST_CASE(direction_changes)
     std::unordered_set<NodeID> traffic_lights;
     std::vector<NodeBasedEdgeAnnotation> annotations(1);
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -282,7 +273,6 @@ BOOST_AUTO_TEST_CASE(direction_changes)
                         traffic_lights,
                         scripting_environment,
                         restrictions,
-                        conditional_restrictions,
                         maneuver_overrides,
                         graph,
                         annotations,
diff --git a/unit_tests/extractor/intersection_analysis_tests.cpp b/unit_tests/extractor/intersection_analysis_tests.cpp
index 3dae9d3ff..b7ec2e707 100644
--- a/unit_tests/extractor/intersection_analysis_tests.cpp
+++ b/unit_tests/extractor/intersection_analysis_tests.cpp
@@ -24,7 +24,6 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
         {EMPTY_NAMEID, 0, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false},
         {EMPTY_NAMEID, 1, INAVLID_CLASS_DATA, TRAVEL_MODE_DRIVING, false}};
     std::vector<TurnRestriction> restrictions{TurnRestriction{NodeRestriction{0, 2, 1}, false}};
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -90,7 +89,6 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
                                traffic_lights,
                                scripting_environment,
                                restrictions,
-                               conditional_restrictions,
                                maneuver_overrides,
                                graph,
                                annotations,
@@ -101,7 +99,8 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
 
     EdgeBasedNodeDataContainer node_data_container(
         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+    RestrictionGraph restriction_graph = constructRestrictionGraph(restrictions);
+    RestrictionMap restriction_map(restriction_graph);
 
     const auto connectivity_matrix = [&](NodeID node) {
         std::vector<bool> result;
@@ -132,7 +131,7 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
                       1, 0, 0, 1, // from node 1 to nodes 0 and 4
                       1, 1, 0, 1  // from node 3 to nodes 0, 1 and 4
                       // clang-format on
-                      );
+    );
     REQUIRE_SIZE_RANGE(connectivity_matrix(3), 0); // no incoming edges, empty matrix
     CHECK_EQUAL_RANGE(connectivity_matrix(4), 0);  // from node 2 not allowed U-turn
     CHECK_EQUAL_RANGE(connectivity_matrix(5),
@@ -140,14 +139,14 @@ BOOST_AUTO_TEST_CASE(simple_intersection_connectivity)
                       0, 1, // from node 0 to node 6
                       0, 1, // from node 6 a U-turn to node 6
                       // clang-format on
-                      );
+    );
 
     CHECK_EQUAL_RANGE(connectivity_matrix(6),
                       // clang-format off
                       1, 0, // from node 5 a U-turn to node 5
                       0, 1, // from node 7 a U-turn to node 7
                       // clang-format on
-                      );
+    );
 }
 
 BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
@@ -156,7 +155,6 @@ BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
     std::unordered_set<NodeID> traffic_lights;
     std::vector<NodeBasedEdgeAnnotation> annotations;
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -214,7 +212,6 @@ BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
                                traffic_lights,
                                scripting_environment,
                                restrictions,
-                               conditional_restrictions,
                                maneuver_overrides,
                                graph,
                                annotations,
@@ -225,7 +222,9 @@ BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
 
     EdgeBasedNodeDataContainer node_data_container(
         std::vector<EdgeBasedNode>(graph.GetNumberOfEdges()), annotations);
-    RestrictionMap restriction_map(restrictions, IndexNodeByFromAndVia());
+
+    RestrictionGraph restriction_graph = constructRestrictionGraph(restrictions);
+    RestrictionMap restriction_map(restriction_graph);
 
     const auto connectivity_matrix = [&](NodeID node) {
         std::vector<bool> result;
@@ -254,7 +253,7 @@ BOOST_AUTO_TEST_CASE(roundabout_intersection_connectivity)
                       0, 1, 0, 1, 0, 0, // from node 3 to nodes 2 and 4
                       0, 1, 0, 1, 0, 1  // from node 5 to nodes 2, 4 and 6
                       // clang-format on
-                      );
+    );
 }
 
 BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
@@ -263,7 +262,6 @@ BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
     std::unordered_set<NodeID> traffic_lights{2};
     std::vector<NodeBasedEdgeAnnotation> annotations(1);
     std::vector<TurnRestriction> restrictions;
-    std::vector<ConditionalTurnRestriction> conditional_restrictions;
     CompressedEdgeContainer container;
     test::MockScriptingEnvironment scripting_environment;
     std::vector<UnresolvedManeuverOverride> maneuver_overrides;
@@ -306,7 +304,6 @@ BOOST_AUTO_TEST_CASE(skip_degree_two_nodes)
                                traffic_lights,
                                scripting_environment,
                                restrictions,
-                               conditional_restrictions,
                                maneuver_overrides,
                                graph,
                                annotations,
diff --git a/unit_tests/extractor/restriction_graph.cpp b/unit_tests/extractor/restriction_graph.cpp
new file mode 100644
index 000000000..f44a25dd1
--- /dev/null
+++ b/unit_tests/extractor/restriction_graph.cpp
@@ -0,0 +1,599 @@
+#include "extractor/restriction_graph.hpp"
+#include "extractor/maneuver_override.hpp"
+#include "extractor/restriction.hpp"
+#include "util/typedefs.hpp"
+
+#include <boost/test/unit_test.hpp>
+#include <iostream>
+
+#include <vector>
+
+BOOST_AUTO_TEST_SUITE(restriction_graph)
+
+using namespace osrm;
+using namespace osrm::extractor;
+
+TurnRestriction makeWayRestriction(NodeID from, std::vector<NodeID> via, NodeID to, bool is_only)
+{
+    WayRestriction wr{from, std::move(via), to};
+    return TurnRestriction(wr, is_only);
+}
+
+TurnRestriction makeNodeRestriction(NodeID from, NodeID via, NodeID to, bool is_only)
+{
+    NodeRestriction nr{from, via, to};
+    return TurnRestriction(nr, is_only);
+}
+
+struct instruction
+{
+    NodeID to;
+    bool is_only;
+};
+
+std::ostream &operator<<(std::ostream &os, const instruction &in)
+{
+    os << std::boolalpha << in.to << ':' << in.is_only;
+    return os;
+}
+
+bool operator==(const instruction &lhs, const instruction &rhs) noexcept
+{
+    return lhs.to == rhs.to && lhs.is_only == rhs.is_only;
+}
+
+bool operator!=(const instruction &lhs, const instruction &rhs) noexcept { return !(lhs == rhs); }
+
+void checkInstructions(RestrictionGraph::RestrictionRange restrictions,
+                       std::vector<instruction> expected_instructions)
+{
+    std::vector<instruction> actual_instructions;
+    std::transform(restrictions.begin(),
+                   restrictions.end(),
+                   std::back_inserter(actual_instructions),
+                   [](const auto &restriction) {
+                       return instruction{restriction->To(), bool(restriction->is_only)};
+                   });
+    std::sort(actual_instructions.begin(),
+              actual_instructions.end(),
+              [](const auto &lhs, const auto &rhs) {
+                  return (lhs.to < rhs.to) || (lhs.to == rhs.to && lhs.is_only);
+              });
+    std::sort(expected_instructions.begin(),
+              expected_instructions.end(),
+              [](const auto &lhs, const auto &rhs) {
+                  return (lhs.to < rhs.to) || (lhs.to == rhs.to && lhs.is_only);
+              });
+
+    BOOST_REQUIRE_EQUAL_COLLECTIONS(actual_instructions.begin(),
+                                    actual_instructions.end(),
+                                    expected_instructions.begin(),
+                                    expected_instructions.end());
+}
+
+void checkEdges(RestrictionGraph::EdgeRange edges, std::vector<NodeID> expected_edges)
+{
+    std::vector<NodeID> actual_edges;
+    std::transform(edges.begin(),
+                   edges.end(),
+                   std::back_inserter(actual_edges),
+                   [&](const auto &edge) { return edge.node_based_to; });
+    std::sort(actual_edges.begin(), actual_edges.end(), std::less<NodeID>());
+    std::sort(expected_edges.begin(), expected_edges.end(), std::less<NodeID>());
+
+    BOOST_REQUIRE_EQUAL_COLLECTIONS(
+        actual_edges.begin(), actual_edges.end(), expected_edges.begin(), expected_edges.end());
+}
+
+std::map<NodeID, size_t> nextEdges(RestrictionGraph::EdgeRange edges)
+{
+    std::map<NodeID, size_t> res;
+    std::transform(
+        edges.begin(), edges.end(), std::inserter(res, res.end()), [&](const auto &edge) {
+            return std::make_pair(edge.node_based_to, edge.target);
+        });
+    return res;
+}
+
+std::map<NodeID, size_t> checkNode(const RestrictionGraph &graph,
+                                   const RestrictionID node_id,
+                                   std::vector<instruction> expected_instructions,
+                                   std::vector<NodeID> expected_edges)
+{
+    checkInstructions(graph.GetRestrictions(node_id), std::move(expected_instructions));
+    checkEdges(graph.GetEdges(node_id), std::move(expected_edges));
+    return nextEdges(graph.GetEdges(node_id));
+}
+
+std::map<NodeID, size_t>
+validateStartRestrictionNode(RestrictionGraph &graph,
+                             NodeID from,
+                             NodeID to,
+                             std::vector<instruction> restriction_instructions,
+                             std::vector<NodeID> restriction_edges)
+{
+    BOOST_REQUIRE_EQUAL(graph.start_edge_to_node.count({from, to}), 1);
+    const auto node_id = graph.start_edge_to_node[{from, to}];
+    BOOST_REQUIRE_GE(node_id, graph.num_via_nodes);
+    BOOST_REQUIRE_LT(node_id, graph.nodes.size());
+
+    return checkNode(
+        graph, node_id, std::move(restriction_instructions), std::move(restriction_edges));
+}
+
+std::map<NodeID, size_t>
+validateViaRestrictionNode(RestrictionGraph &graph,
+                           size_t via_node_idx,
+                           NodeID from,
+                           NodeID to,
+                           std::vector<instruction> restriction_instructions,
+                           std::vector<NodeID> restriction_edges)
+{
+    BOOST_REQUIRE_GE(graph.via_edge_to_node.count({from, to}), 1);
+    auto node_match_it = graph.via_edge_to_node.equal_range({from, to});
+
+    BOOST_REQUIRE_MESSAGE(
+        std::any_of(node_match_it.first,
+                    node_match_it.second,
+                    [&](const auto node_match) { return node_match.second == via_node_idx; }),
+        "Could not find expected via_node_idx " << via_node_idx << " for graph edge " << from << ","
+                                                << to);
+
+    BOOST_REQUIRE_LT(via_node_idx, graph.num_via_nodes);
+    return checkNode(
+        graph, via_node_idx, std::move(restriction_instructions), std::move(restriction_edges));
+}
+
+BOOST_AUTO_TEST_CASE(empty_restrictions)
+{
+    //
+    // Input
+    //
+    // Output
+    //
+    std::vector<TurnRestriction> empty;
+
+    auto graph = constructRestrictionGraph(empty);
+
+    BOOST_CHECK(graph.nodes.empty());
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 0);
+    BOOST_CHECK(graph.edges.empty());
+    BOOST_CHECK(graph.start_edge_to_node.empty());
+    BOOST_CHECK(graph.via_edge_to_node.empty());
+}
+
+BOOST_AUTO_TEST_CASE(node_restriction)
+{
+    //
+    // Input
+    // 0 -> 1: only_2
+    //
+    // Output
+    // s(0,1,[only_2])
+    //
+    std::vector<TurnRestriction> input{
+        makeNodeRestriction(0, 1, 2, true),
+    };
+
+    std::cout << "Construct graph" << std::endl;
+    auto graph = constructRestrictionGraph(input);
+    std::cout << "Constructed graph" << std::endl;
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 1);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 0);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 1);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 0);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 0);
+
+    validateStartRestrictionNode(graph, 0, 1, {{2, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(way_restriction)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 3);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 2);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 1);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 2);
+
+    auto start_edges = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto via_edges = validateViaRestrictionNode(graph, start_edges[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges[3], 2, 3, {{4, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(disconnected_restrictions)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    // 5 -> 6 -> 7 -> 8: only_9
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    // s(5,6) -> v(6,7) -> v(7,8,[only_9])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeWayRestriction(5,
+                           {
+                               6,
+                               7,
+                               8,
+                           },
+                           9,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 6);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 4);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 4);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 4);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto start_edges_2 = validateStartRestrictionNode(graph, 5, 6, {}, {7});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, true}}, {});
+    auto via_edges_2 = validateViaRestrictionNode(graph, start_edges_2[7], 6, 7, {}, {8});
+    validateViaRestrictionNode(graph, via_edges_2[8], 7, 8, {{9, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(same_prefix_restrictions)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    // 0 -> 1 -> 2 -> 5: only_6
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    //                  \_>v(2,5,[only_6])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               5,
+                           },
+                           6,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 4);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 3);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 1);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+
+    auto start_edges = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+
+    auto via_edges = validateViaRestrictionNode(graph, start_edges[2], 1, 2, {}, {3, 5});
+    validateViaRestrictionNode(graph, via_edges[3], 2, 3, {{4, true}}, {});
+    validateViaRestrictionNode(graph, via_edges[5], 2, 5, {{6, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(duplicate_edges)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    // 5 -> 1 -> 2 -> 3: only_6
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    // s(5,1) -> v(1,2) -> v(2,3,[only_6])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeWayRestriction(5,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           6,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 6);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 4);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 4);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 4);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.count({1, 2}), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.count({2, 3}), 2);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto start_edges_2 = validateStartRestrictionNode(graph, 5, 1, {}, {2});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, true}}, {});
+
+    auto via_edges_2 = validateViaRestrictionNode(graph, start_edges_2[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_2[3], 2, 3, {{6, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(nested_restriction)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: [only_4]
+    // 1 -> 2: [only_4]
+    //
+    // Output
+    // s(0,1) -> v(1,2,[only_4]) -> v(2,3,[only_4])
+    // s(1,2,[only_4])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeNodeRestriction(1, 2, 4, true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 4);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 2);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 2);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 2);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    validateStartRestrictionNode(graph, 1, 2, {{4, true}}, {});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {{4, true}}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(partially_nested_restriction)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    // 2 -> 3 -> 4: only_5
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    //                        |
+    //                        t
+    //                        |
+    //           s(2,3) -> v(3,4,[only_5])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeWayRestriction(2, {3, 4}, 5, true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 5);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 4);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto start_edges_2 = validateStartRestrictionNode(graph, 2, 3, {}, {4});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, true}}, {4});
+    validateViaRestrictionNode(graph, start_edges_2[4], 3, 4, {{5, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(conflicting_nested_restriction)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: no_4
+    // 2 -> 3 -> 4: only_5
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[no_4])
+    // s(2,3) -> v(3,4,[only_5])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           false),
+        makeWayRestriction(2, {3, 4}, 5, true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 5);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 3);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto start_edges_2 = validateStartRestrictionNode(graph, 2, 3, {}, {4});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, false}}, {});
+    validateViaRestrictionNode(graph, start_edges_2[4], 3, 4, {{5, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(restriction_edge_matches_start)
+{
+    //
+    // Input
+    // 0 -> 1 -> 2 -> 3: only_4
+    // 3 -> 4 -> 5: only_6
+    //
+    // Output
+    // s(0,1) -> v(1,2) -> v(2,3,[only_4])
+    // s(3,4) -> v(4,5,[only_6])
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               2,
+                               3,
+                           },
+                           4,
+                           true),
+        makeWayRestriction(3, {4, 5}, 6, true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 5);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 3);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 2);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {2});
+    auto start_edges_2 = validateStartRestrictionNode(graph, 3, 4, {}, {5});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[2], 1, 2, {}, {3});
+    validateViaRestrictionNode(graph, via_edges_1[3], 2, 3, {{4, true}}, {});
+    validateViaRestrictionNode(graph, start_edges_2[5], 4, 5, {{6, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(self_nested_restriction)
+{
+    //
+    // Input
+    // 0 -> 1 -> 0 -> 1 -> 2: only_3
+    //
+    // Output
+    // s(0,1) -> v(1,0) -> v(0,1) -> v(1,2,[only_3])
+    //              \___t___/
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               1,
+                               0,
+                               1,
+                               2,
+                           },
+                           3,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 4);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 4);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 1);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 1, {}, {0});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[0], 1, 0, {}, {1});
+    auto via_edges_2 = validateViaRestrictionNode(graph, via_edges_1[1], 0, 1, {}, {0, 2});
+    validateViaRestrictionNode(graph, via_edges_2[2], 1, 2, {{3, true}}, {});
+}
+
+BOOST_AUTO_TEST_CASE(single_node_restriction)
+{
+    //
+    // Input
+    // 0 -> 0 -> 0 -> 0 -> 0: only_0
+    //
+    // Output
+    // s(0,0) -> v(0,0) -> v(0,0) -> v(0,0,[only_0])
+    //                                 \t/
+    //
+    std::vector<TurnRestriction> input{
+        makeWayRestriction(0,
+                           {
+                               0,
+                               0,
+                               0,
+                               0,
+                           },
+                           0,
+                           true),
+    };
+
+    auto graph = constructRestrictionGraph(input);
+
+    BOOST_CHECK_EQUAL(graph.nodes.size(), 4);
+    BOOST_CHECK_EQUAL(graph.num_via_nodes, 3);
+    BOOST_CHECK_EQUAL(graph.edges.size(), 4);
+    BOOST_CHECK_EQUAL(graph.start_edge_to_node.size(), 1);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.size(), 3);
+    BOOST_CHECK_EQUAL(graph.via_edge_to_node.count({0, 0}), 3);
+
+    auto start_edges_1 = validateStartRestrictionNode(graph, 0, 0, {}, {0});
+
+    auto via_edges_1 = validateViaRestrictionNode(graph, start_edges_1[0], 0, 0, {}, {0});
+    auto via_edges_2 = validateViaRestrictionNode(graph, via_edges_1[0], 0, 0, {}, {0});
+    validateViaRestrictionNode(graph, via_edges_2[0], 0, 0, {{0, true}}, {0});
+}
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/library/extract.cpp b/unit_tests/library/extract.cpp
index 23f5ea0d9..aa18c7552 100644
--- a/unit_tests/library/extract.cpp
+++ b/unit_tests/library/extract.cpp
@@ -20,6 +20,8 @@ BOOST_AUTO_TEST_CASE(test_extract_with_valid_config)
     osrm::ExtractorConfig config;
     config.input_path = OSRM_TEST_DATA_DIR "/monaco.osm.pbf";
     config.UseDefaultOutputNames(OSRM_TEST_DATA_DIR "/monaco.osm.pbf");
+    config.profile_path = OSRM_TEST_DATA_DIR "/../../profiles/car.lua";
+    config.small_component_size = 1000;
     config.requested_num_threads = std::thread::hardware_concurrency();
     BOOST_CHECK_NO_THROW(osrm::extract(config));
 }
diff --git a/unit_tests/library/json.cpp b/unit_tests/library/json.cpp
index 537eecc94..1b0b36a86 100644
--- a/unit_tests/library/json.cpp
+++ b/unit_tests/library/json.cpp
@@ -6,7 +6,6 @@
 #include "engine/api/json_factory.hpp"
 #include "osrm/coordinate.hpp"
 
-#include <iterator>
 #include <vector>
 
 using namespace osrm;
@@ -27,7 +26,7 @@ BOOST_AUTO_TEST_CASE(test_json_linestring)
     const auto coords = geom.values["coordinates"].get<util::json::Array>().values;
     BOOST_CHECK_EQUAL(coords.size(), 3); // array of three location arrays
 
-    for (const auto each : coords)
+    for (const auto &each : coords)
     {
         const auto loc = each.get<util::json::Array>().values;
         BOOST_CHECK_EQUAL(loc.size(), 2);
@@ -53,7 +52,7 @@ BOOST_AUTO_TEST_CASE(test_json_single_point)
     const auto coords = geom.values["coordinates"].get<util::json::Array>().values;
     BOOST_CHECK_EQUAL(coords.size(), 2); // array of two location arrays
 
-    for (const auto each : coords)
+    for (const auto &each : coords)
     {
         const auto loc = each.get<util::json::Array>().values;
         BOOST_CHECK_EQUAL(loc.size(), 2);
diff --git a/unit_tests/library/limits.cpp b/unit_tests/library/limits.cpp
index ea6182a7d..8db7ff24b 100644
--- a/unit_tests/library/limits.cpp
+++ b/unit_tests/library/limits.cpp
@@ -18,7 +18,7 @@ osrm::util::Coordinate getZeroCoordinate()
 {
     return {osrm::util::FloatLongitude{0}, osrm::util::FloatLatitude{0}};
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(limits)
 
diff --git a/unit_tests/library/match.cpp b/unit_tests/library/match.cpp
index 7505a2adf..741e8e4fd 100644
--- a/unit_tests/library/match.cpp
+++ b/unit_tests/library/match.cpp
@@ -7,14 +7,30 @@
 #include "osrm/match_parameters.hpp"
 
 #include "osrm/coordinate.hpp"
-#include "osrm/engine_config.hpp"
 #include "osrm/json_container.hpp"
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
+osrm::Status run_match_json(const osrm::OSRM &osrm,
+                            const osrm::MatchParameters &params,
+                            osrm::json::Object &json_result,
+                            bool use_json_only_api)
+{
+    using namespace osrm;
+
+    if (use_json_only_api)
+    {
+        return osrm.Match(params, json_result);
+    }
+    engine::api::ResultT result = json::Object();
+    auto rc = osrm.Match(params, result);
+    json_result = result.get<json::Object>();
+    return rc;
+}
+
 BOOST_AUTO_TEST_SUITE(match)
 
-BOOST_AUTO_TEST_CASE(test_match)
+void test_match(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -25,11 +41,9 @@ BOOST_AUTO_TEST_CASE(test_match)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Match(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -63,8 +77,10 @@ BOOST_AUTO_TEST_CASE(test_match)
         }
     }
 }
+BOOST_AUTO_TEST_CASE(test_match_new_api) { test_match(false); }
+BOOST_AUTO_TEST_CASE(test_match_old_api) { test_match(true); }
 
-BOOST_AUTO_TEST_CASE(test_match_skip_waypoints)
+void test_match_skip_waypoints(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -76,19 +92,19 @@ BOOST_AUTO_TEST_CASE(test_match_skip_waypoints)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Match(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
     BOOST_CHECK(json_result.values.find("tracepoints") == json_result.values.end());
 }
+BOOST_AUTO_TEST_CASE(test_match_skip_waypoints_old_api) { test_match_skip_waypoints(true); }
+BOOST_AUTO_TEST_CASE(test_match_skip_waypoints_new_api) { test_match_skip_waypoints(false); }
 
-BOOST_AUTO_TEST_CASE(test_match_split)
+void test_match_split(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -98,11 +114,9 @@ BOOST_AUTO_TEST_CASE(test_match_split)
     params.coordinates = get_split_trace_locations();
     params.timestamps = {1, 2, 1700, 1800};
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_match_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Match(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -140,6 +154,8 @@ BOOST_AUTO_TEST_CASE(test_match_split)
         }
     }
 }
+BOOST_AUTO_TEST_CASE(test_match_split_old_api) { test_match_split(true); }
+BOOST_AUTO_TEST_CASE(test_match_split_new_api) { test_match_split(false); }
 
 BOOST_AUTO_TEST_CASE(test_match_fb_serialization)
 {
@@ -170,7 +186,7 @@ BOOST_AUTO_TEST_CASE(test_match_fb_serialization)
     const auto matchings = fb->routes();
     const auto &number_of_matchings = matchings->size();
 
-    for (const auto &waypoint : *waypoints)
+    for (const auto waypoint : *waypoints)
     {
         BOOST_CHECK(waypoint_check(waypoint));
         const auto matchings_index = waypoint->matchings_index();
diff --git a/unit_tests/library/nearest.cpp b/unit_tests/library/nearest.cpp
index 39d134f99..249e19387 100644
--- a/unit_tests/library/nearest.cpp
+++ b/unit_tests/library/nearest.cpp
@@ -7,14 +7,28 @@
 #include "osrm/nearest_parameters.hpp"
 
 #include "osrm/coordinate.hpp"
-#include "osrm/engine_config.hpp"
 #include "osrm/json_container.hpp"
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
+osrm::Status run_nearest_json(const osrm::OSRM &osrm,
+                              const osrm::NearestParameters &params,
+                              osrm::json::Object &json_result,
+                              bool use_json_only_api)
+{
+    if (use_json_only_api)
+    {
+        return osrm.Nearest(params, json_result);
+    }
+    osrm::engine::api::ResultT result = osrm::json::Object();
+    auto rc = osrm.Nearest(params, result);
+    json_result = result.get<osrm::json::Object>();
+    return rc;
+}
+
 BOOST_AUTO_TEST_SUITE(nearest)
 
-BOOST_AUTO_TEST_CASE(test_nearest_response)
+void test_nearest_response(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -23,11 +37,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response)
     NearestParameters params;
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Nearest(params, result);
+    json::Object json_result;
+    const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -41,8 +54,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response)
         BOOST_CHECK(distance >= 0);
     }
 }
+BOOST_AUTO_TEST_CASE(test_nearest_response_old_api) { test_nearest_response(true); }
+BOOST_AUTO_TEST_CASE(test_nearest_response_new_api) { test_nearest_response(false); }
 
-BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints)
+void test_nearest_response_skip_waypoints(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -52,18 +67,25 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints)
     params.skip_waypoints = true;
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Nearest(params, result);
+    json::Object json_result;
+    const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
     BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end());
 }
+BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_old_api)
+{
+    test_nearest_response_skip_waypoints(true);
+}
+BOOST_AUTO_TEST_CASE(test_nearest_response_skip_waypoints_new_api)
+{
+    test_nearest_response_skip_waypoints(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates)
+void test_nearest_response_no_coordinates(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -71,16 +93,23 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates)
 
     NearestParameters params;
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Nearest(params, result);
+    json::Object json_result;
+    const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == Status::Error);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "InvalidOptions");
 }
+BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_old_api)
+{
+    test_nearest_response_no_coordinates(true);
+}
+BOOST_AUTO_TEST_CASE(test_nearest_response_no_coordinates_new_api)
+{
+    test_nearest_response_no_coordinates(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates)
+void test_nearest_response_multiple_coordinates(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -90,16 +119,23 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Nearest(params, result);
+    json::Object json_result;
+    const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == Status::Error);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "InvalidOptions");
 }
+BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_old_api)
+{
+    test_nearest_response_multiple_coordinates(true);
+}
+BOOST_AUTO_TEST_CASE(test_nearest_response_multiple_coordinates_new_api)
+{
+    test_nearest_response_multiple_coordinates(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component)
+void test_nearest_response_for_location_in_small_component(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -111,11 +147,10 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component)
     params.coordinates.push_back(locations.at(0));
     params.number_of_results = 3;
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Nearest(params, result);
+    json::Object json_result;
+    const auto rc = run_nearest_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -137,6 +172,14 @@ BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component)
         BOOST_CHECK(nodes[1].get<util::json::Number>().value != 0);
     }
 }
+BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_old_api)
+{
+    test_nearest_response_for_location_in_small_component(true);
+}
+BOOST_AUTO_TEST_CASE(test_nearest_response_for_location_in_small_component_new_api)
+{
+    test_nearest_response_for_location_in_small_component(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization)
 {
@@ -159,7 +202,7 @@ BOOST_AUTO_TEST_CASE(test_nearest_fb_serialization)
     auto waypoints = fb->waypoints();
     BOOST_CHECK(waypoints->size() > 0); // the dataset has at least one nearest coordinate
 
-    for (const auto &waypoint : *waypoints)
+    for (const auto waypoint : *waypoints)
     {
         BOOST_CHECK(waypoint->distance() >= 0);
         BOOST_CHECK(waypoint->nodes()->first() != 0);
diff --git a/unit_tests/library/route.cpp b/unit_tests/library/route.cpp
index 3a5979fdb..0e4798523 100644
--- a/unit_tests/library/route.cpp
+++ b/unit_tests/library/route.cpp
@@ -15,9 +15,24 @@
 #include "osrm/route_parameters.hpp"
 #include "osrm/status.hpp"
 
+osrm::Status run_route_json(const osrm::OSRM &osrm,
+                            const osrm::RouteParameters &params,
+                            osrm::json::Object &json_result,
+                            bool use_json_only_api)
+{
+    if (use_json_only_api)
+    {
+        return osrm.Route(params, json_result);
+    }
+    osrm::engine::api::ResultT result = osrm::json::Object();
+    auto rc = osrm.Route(params, result);
+    json_result = result.get<osrm::json::Object>();
+    return rc;
+}
+
 BOOST_AUTO_TEST_SUITE(route)
 
-BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture)
+void test_route_same_coordinates_fixture(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -28,11 +43,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     // unset snapping dependent hint
     for (auto &itr : json_result.values["waypoints"].get<json::Array>().values)
     {
@@ -115,8 +129,16 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture)
 
     CHECK_EQUAL_JSON(reference, json_result);
 }
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_old_api)
+{
+    test_route_same_coordinates_fixture(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_fixture_new_api)
+{
+    test_route_same_coordinates_fixture(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
+void test_route_same_coordinates(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -128,11 +150,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -242,7 +263,7 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
                     const auto &entries = intersection_object.at("entry").get<json::Array>().values;
                     BOOST_CHECK(bearings.size() == entries.size());
 
-                    for (const auto bearing : bearings)
+                    for (const auto &bearing : bearings)
                         BOOST_CHECK(0. <= bearing.get<json::Number>().value &&
                                     bearing.get<json::Number>().value <= 360.);
 
@@ -268,8 +289,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates)
         }
     }
 }
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_old_api) { test_route_same_coordinates(true); }
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_new_api) { test_route_same_coordinates(false); }
 
-BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints)
+void test_route_same_coordinates_no_waypoints(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -282,11 +305,10 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -315,8 +337,16 @@ BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints)
         // The rest of legs contents is verified by test_route_same_coordinates
     }
 }
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_old_api)
+{
+    test_route_same_coordinates_no_waypoints(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_same_coordinates_no_waypoints_new_api)
+{
+    test_route_same_coordinates_no_waypoints(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component)
+void test_route_response_for_locations_in_small_component(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -329,11 +359,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component)
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -351,8 +380,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component)
         BOOST_CHECK(latitude >= -90. && latitude <= 90.);
     }
 }
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_old_api)
+{
+    test_route_response_for_locations_in_small_component(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_small_component_new_api)
+{
+    test_route_response_for_locations_in_small_component(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component)
+void test_route_response_for_locations_in_big_component(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -365,11 +402,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component)
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -387,8 +423,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component)
         BOOST_CHECK(latitude >= -90. && latitude <= 90.);
     }
 }
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_old_api)
+{
+    test_route_response_for_locations_in_big_component(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_in_big_component_new_api)
+{
+    test_route_response_for_locations_in_big_component(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components)
+void test_route_response_for_locations_across_components(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -403,11 +447,10 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components)
     params.coordinates.push_back(small_component.at(1));
     params.coordinates.push_back(big_component.at(1));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -425,8 +468,16 @@ BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components)
         BOOST_CHECK(latitude >= -90. && latitude <= 90.);
     }
 }
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_old_api)
+{
+    test_route_response_for_locations_across_components(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_response_for_locations_across_components_new_api)
+{
+    test_route_response_for_locations_across_components(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints)
+void test_route_user_disables_generating_hints(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -438,16 +489,23 @@ BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints)
     params.coordinates.push_back(get_dummy_location());
     params.generate_hints = false;
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     for (auto waypoint : json_result.values["waypoints"].get<json::Array>().values)
         BOOST_CHECK_EQUAL(waypoint.get<json::Object>().values.count("hint"), 0);
 }
+BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_old_api)
+{
+    test_route_user_disables_generating_hints(true);
+}
+BOOST_AUTO_TEST_CASE(test_route_user_disables_generating_hints_new_api)
+{
+    test_route_user_disables_generating_hints(false);
+}
 
-BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance)
+void speed_annotation_matches_duration_and_distance(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -460,11 +518,10 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto &routes = json_result.values["routes"].get<json::Array>().values;
     const auto &legs = routes[0].get<json::Object>().values.at("legs").get<json::Array>().values;
     const auto &annotation =
@@ -489,8 +546,16 @@ BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance)
         BOOST_CHECK_EQUAL(duration, 0);
     }
 }
+BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_old_api)
+{
+    speed_annotation_matches_duration_and_distance(true);
+}
+BOOST_AUTO_TEST_CASE(speed_annotation_matches_duration_and_distance_new_api)
+{
+    speed_annotation_matches_duration_and_distance(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property)
+void test_manual_setting_of_annotations_property(bool use_json_only_api)
 {
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
 
@@ -501,11 +566,10 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property)
     params.coordinates.push_back(get_dummy_location());
     params.coordinates.push_back(get_dummy_location());
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Route(params, result);
+    json::Object json_result;
+    const auto rc = run_route_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -522,6 +586,14 @@ BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property)
                            .values;
     BOOST_CHECK_EQUAL(annotations.size(), 6);
 }
+BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_old_api)
+{
+    test_manual_setting_of_annotations_property(true);
+}
+BOOST_AUTO_TEST_CASE(test_manual_setting_of_annotations_property_new_api)
+{
+    test_manual_setting_of_annotations_property(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
 {
@@ -547,7 +619,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
     const auto waypoints = fb->waypoints();
     BOOST_CHECK(waypoints->size() == params.coordinates.size());
 
-    for (const auto &waypoint : *waypoints)
+    for (const auto waypoint : *waypoints)
     {
         const auto longitude = waypoint->location()->longitude();
         const auto latitude = waypoint->location()->latitude();
@@ -561,7 +633,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
     const auto routes = fb->routes();
     BOOST_REQUIRE_GT(routes->size(), 0);
 
-    for (const auto &route : *routes)
+    for (const auto route : *routes)
     {
         BOOST_CHECK_EQUAL(route->distance(), 0);
         BOOST_CHECK_EQUAL(route->duration(), 0);
@@ -569,7 +641,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb)
         const auto &legs = route->legs();
         BOOST_CHECK(legs->size() > 0);
 
-        for (const auto &leg : *legs)
+        for (const auto leg : *legs)
         {
             BOOST_CHECK_EQUAL(leg->distance(), 0);
 
@@ -648,7 +720,7 @@ BOOST_AUTO_TEST_CASE(test_route_serialize_fb_skip_waypoints)
     const auto routes = fb->routes();
     BOOST_REQUIRE_GT(routes->size(), 0);
 
-    for (const auto &route : *routes)
+    for (const auto route : *routes)
     {
         BOOST_CHECK_EQUAL(route->distance(), 0);
         BOOST_CHECK_EQUAL(route->duration(), 0);
diff --git a/unit_tests/library/table.cpp b/unit_tests/library/table.cpp
index 26fbdec78..0fa27d9a1 100644
--- a/unit_tests/library/table.cpp
+++ b/unit_tests/library/table.cpp
@@ -7,14 +7,28 @@
 #include "osrm/table_parameters.hpp"
 
 #include "osrm/coordinate.hpp"
-#include "osrm/engine_config.hpp"
 #include "osrm/json_container.hpp"
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
+osrm::Status run_table_json(const osrm::OSRM &osrm,
+                            const osrm::TableParameters &params,
+                            osrm::json::Object &json_result,
+                            bool use_json_only_api)
+{
+    if (use_json_only_api)
+    {
+        return osrm.Table(params, json_result);
+    }
+    osrm::engine::api::ResultT result = osrm::json::Object();
+    auto rc = osrm.Table(params, result);
+    json_result = result.get<osrm::json::Object>();
+    return rc;
+}
+
 BOOST_AUTO_TEST_SUITE(table)
 
-BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
+void test_table_three_coords_one_source_one_dest_matrix(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -28,11 +42,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
     params.destinations.push_back(2);
     params.annotations = TableParameters::AnnotationsType::All;
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Table(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -75,8 +87,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix)
         BOOST_CHECK(waypoint_check(source));
     }
 }
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_old_api)
+{
+    test_table_three_coords_one_source_one_dest_matrix(true);
+}
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_new_api)
+{
+    test_table_three_coords_one_source_one_dest_matrix(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints)
+void test_table_three_coords_one_source_one_dest_matrix_no_waypoints(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -91,11 +111,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo
     params.destinations.push_back(2);
     params.annotations = TableParameters::AnnotationsType::All;
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Table(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -126,8 +144,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypo
     BOOST_CHECK(json_result.values.find("destinations") == json_result.values.end());
     BOOST_CHECK(json_result.values.find("sources") == json_result.values.end());
 }
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_old_api)
+{
+    test_table_three_coords_one_source_one_dest_matrix_no_waypoints(true);
+}
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_one_dest_matrix_no_waypoints_new_api)
+{
+    test_table_three_coords_one_source_one_dest_matrix_no_waypoints(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
+void test_table_three_coords_one_source_matrix(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -140,9 +166,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
     params.sources.push_back(0);
     engine::api::ResultT result = json::Object();
 
-    const auto rc = osrm.Table(params, result);
+    json::Object json_result;
+    const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
 
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -174,8 +200,16 @@ BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix)
         BOOST_CHECK(waypoint_check(source));
     }
 }
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_old_api)
+{
+    test_table_three_coords_one_source_matrix(true);
+}
+BOOST_AUTO_TEST_CASE(test_table_three_coords_one_source_matrix_new_api)
+{
+    test_table_three_coords_one_source_matrix(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
+void test_table_three_coordinates_matrix(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -187,11 +221,9 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
     params.coordinates.push_back(get_dummy_location());
     params.annotations = TableParameters::AnnotationsType::Duration;
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Table(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Ok || rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
@@ -219,9 +251,17 @@ BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix)
         BOOST_CHECK(waypoint_check(source));
     }
 }
+BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_old_api)
+{
+    test_table_three_coordinates_matrix(true);
+}
+BOOST_AUTO_TEST_CASE(test_table_three_coordinates_matrix_new_api)
+{
+    test_table_three_coordinates_matrix(false);
+}
 
 // See https://github.com/Project-OSRM/osrm-backend/pull/3992
-BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates)
+void test_table_no_segment_for_some_coordinates(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -234,17 +274,23 @@ BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates)
     params.radiuses.push_back(boost::make_optional(0.));
     params.radiuses.push_back(boost::none);
 
-    engine::api::ResultT result = json::Object();
+    json::Object json_result;
+    const auto rc = run_table_json(osrm, params, json_result, use_json_only_api);
 
-    const auto rc = osrm.Table(params, result);
-
-    auto &json_result = result.get<json::Object>();
     BOOST_CHECK(rc == Status::Error);
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "NoSegment");
     const auto message = json_result.values.at("message").get<json::String>().value;
     BOOST_CHECK_EQUAL(message, "Could not find a matching segment for coordinate 0");
 }
+BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_old_api)
+{
+    test_table_no_segment_for_some_coordinates(true);
+}
+BOOST_AUTO_TEST_CASE(test_table_no_segment_for_some_coordinates_new_api)
+{
+    test_table_no_segment_for_some_coordinates(false);
+}
 
 BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb)
 {
@@ -286,14 +332,14 @@ BOOST_AUTO_TEST_CASE(test_table_serialiaze_fb)
     // check destinations array of waypoint objects
     const auto &destinations_array = fb->table()->destinations();
     BOOST_CHECK_EQUAL(destinations_array->size(), params.destinations.size());
-    for (const auto &destination : *destinations_array)
+    for (const auto destination : *destinations_array)
     {
         BOOST_CHECK(waypoint_check(destination));
     }
     // check sources array of waypoint objects
     const auto &sources_array = fb->waypoints();
     BOOST_CHECK_EQUAL(sources_array->size(), params.sources.size());
-    for (const auto &source : *sources_array)
+    for (const auto source : *sources_array)
     {
         BOOST_CHECK(waypoint_check(source));
     }
diff --git a/unit_tests/library/tile.cpp b/unit_tests/library/tile.cpp
index 9fcff9904..00a6c3846 100644
--- a/unit_tests/library/tile.cpp
+++ b/unit_tests/library/tile.cpp
@@ -18,8 +18,23 @@
 
 #include <map>
 
+osrm::Status run_tile(const osrm::OSRM &osrm,
+                      const osrm::TileParameters &params,
+                      std::string &string_result,
+                      bool use_string_only_api)
+{
+    if (use_string_only_api)
+    {
+        return osrm.Tile(params, string_result);
+    }
+    osrm::engine::api::ResultT result = std::string();
+    auto rc = osrm.Tile(params, result);
+    string_result = result.get<std::string>();
+    return rc;
+}
+
 #define CHECK_EQUAL_RANGE(R1, R2)                                                                  \
-    BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
+    BOOST_CHECK_EQUAL_COLLECTIONS((R1).begin(), (R1).end(), (R2).begin(), (R2).end());
 
 BOOST_AUTO_TEST_SUITE(tile)
 
@@ -75,7 +90,7 @@ void validate_feature_layer(vtzero::layer layer)
         std::count_if(layer.value_table().begin(), layer.value_table().end(), [](auto v) {
             return v.type() == vtzero::property_value_type::uint_value;
         });
-    BOOST_CHECK_EQUAL(number_of_uint_values, 78);
+    BOOST_CHECK_EQUAL(number_of_uint_values, 79);
 }
 
 void validate_turn_layer(vtzero::layer layer)
@@ -118,7 +133,7 @@ void validate_turn_layer(vtzero::layer layer)
             return v.type() == vtzero::property_value_type::float_value;
         });
 
-    BOOST_CHECK_EQUAL(number_of_float_values, 74);
+    BOOST_CHECK_EQUAL(number_of_float_values, 73);
 }
 
 void validate_node_layer(vtzero::layer layer)
@@ -153,19 +168,17 @@ void validate_internal_nodes_layer(vtzero::layer layer)
     }
 }
 
-void validate_tile(const osrm::OSRM &osrm)
+void validate_tile(const osrm::OSRM &osrm, bool use_string_only_api)
 {
     using namespace osrm;
 
     // This tile should contain most of monaco
     TileParameters params{17059, 11948, 15};
 
-    engine::api::ResultT result = std::string();
-
-    const auto rc = osrm.Tile(params, result);
+    std::string str_result;
+    const auto rc = run_tile(osrm, params, str_result, use_string_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &str_result = result.get<std::string>();
     BOOST_CHECK(str_result.size() > 114000);
 
     vtzero::vector_tile tile{str_result};
@@ -176,42 +189,47 @@ void validate_tile(const osrm::OSRM &osrm)
     validate_internal_nodes_layer(tile.next_layer());
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_ch)
+void test_tile_ch(bool use_string_only_api)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
-    validate_tile(osrm);
+    validate_tile(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_ch_old_api) { test_tile_ch(true); }
+BOOST_AUTO_TEST_CASE(test_tile_ch_new_api) { test_tile_ch(false); }
 
-BOOST_AUTO_TEST_CASE(test_tile_corech)
+void test_tile_corech(bool use_string_only_api)
 {
     // Note: this tests that given the CoreCH algorithm config option, configuration falls back to
     // CH and is compatible with CH data
     using namespace osrm;
     auto osrm =
         getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-    validate_tile(osrm);
+    validate_tile(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_corech_old_api) { test_tile_corech(true); }
+BOOST_AUTO_TEST_CASE(test_tile_corech_new_api) { test_tile_corech(false); }
 
-BOOST_AUTO_TEST_CASE(test_tile_mld)
+void test_tile_mld(bool use_string_only_api)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
-    validate_tile(osrm);
+    validate_tile(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_mld_old_api) { test_tile_mld(true); }
+BOOST_AUTO_TEST_CASE(test_tile_mld_new_api) { test_tile_mld(false); }
 
-void test_tile_turns(const osrm::OSRM &osrm)
+void test_tile_turns(const osrm::OSRM &osrm, bool use_string_only_api)
 {
     using namespace osrm;
 
     // Small tile where we can test all the values
     TileParameters params{272953, 191177, 19};
 
-    engine::api::ResultT result = std::string();
-    const auto rc = osrm.Tile(params, result);
+    std::string str_result;
+    const auto rc = run_tile(osrm, params, str_result, use_string_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &str_result = result.get<std::string>();
     BOOST_CHECK_GT(str_result.size(), 128);
 
     vtzero::vector_tile tile{str_result};
@@ -304,44 +322,51 @@ void test_tile_turns(const osrm::OSRM &osrm)
     // Verify the expected turn angles
     std::sort(actual_turn_angles.begin(), actual_turn_angles.end());
     const std::vector<std::int64_t> expected_turn_angles = {
-        -122, -120, -117, -65, -57, -30, -28, -3, -2, 2, 3, 28, 30, 57, 65, 117, 120, 122};
+        -122, -120, -117, -65, -58, -30, -28, -2, -2, 2, 2, 28, 30, 58, 65, 117, 120, 122};
     CHECK_EQUAL_RANGE(actual_turn_angles, expected_turn_angles);
 
     // Verify the expected bearings
     std::sort(actual_turn_bearings.begin(), actual_turn_bearings.end());
     const std::vector<std::int64_t> expected_turn_bearings = {
-        49, 49, 107, 107, 169, 169, 171, 171, 229, 229, 257, 257, 286, 286, 349, 349, 352, 352};
+        49, 49, 107, 107, 169, 169, 171, 171, 229, 229, 257, 257, 286, 286, 349, 349, 351, 351};
     CHECK_EQUAL_RANGE(actual_turn_bearings, expected_turn_bearings);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_turns_ch)
+void test_tile_turns_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api)
 {
     using namespace osrm;
-    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
+    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm);
 
-    test_tile_turns(osrm);
+    test_tile_turns(osrm, use_string_only_api);
 }
-
-BOOST_AUTO_TEST_CASE(test_tile_turns_corech)
+BOOST_AUTO_TEST_CASE(test_tile_turns_ch_old_api)
 {
-    // Note: this tests that given the CoreCH algorithm config option, configuration falls back to
-    // CH and is compatible with CH data
-    using namespace osrm;
-    auto osrm =
-        getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-
-    test_tile_turns(osrm);
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_turns_ch_new_api)
+{
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
+BOOST_AUTO_TEST_CASE(test_tile_turns_corech_old_api)
+{
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_turns_corech_new_api)
+{
+    test_tile_turns_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_turns_mld)
+void test_tile_turns_mld(bool use_string_only_api)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
 
-    test_tile_turns(osrm);
+    test_tile_turns(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_turns_mld_old_api) { test_tile_turns_mld(true); }
+BOOST_AUTO_TEST_CASE(test_tile_turns_mld_new_api) { test_tile_turns_mld(false); }
 
-void test_tile_speeds(const osrm::OSRM &osrm)
+void test_tile_speeds(const osrm::OSRM &osrm, bool use_string_only_api)
 {
     using namespace osrm;
 
@@ -349,11 +374,10 @@ void test_tile_speeds(const osrm::OSRM &osrm)
     // TileParameters params{272953, 191177, 19};
     TileParameters params{136477, 95580, 18};
 
-    engine::api::ResultT result = std::string();
-    const auto rc = osrm.Tile(params, result);
+    std::string str_result;
+    const auto rc = run_tile(osrm, params, str_result, use_string_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &str_result = result.get<std::string>();
     BOOST_CHECK_GT(str_result.size(), 128);
 
     vtzero::vector_tile tile{str_result};
@@ -393,34 +417,41 @@ void test_tile_speeds(const osrm::OSRM &osrm)
     BOOST_CHECK(actual_names == expected_names);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_speeds_ch)
+void test_tile_speeds_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api)
 {
     using namespace osrm;
 
-    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
-    test_tile_speeds(osrm);
+    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm);
+    test_tile_speeds(osrm, use_string_only_api);
 }
-
-BOOST_AUTO_TEST_CASE(test_tile_speeds_corech)
+BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_old_api)
 {
-    // Note: this tests that given the CoreCH algorithm config option, configuration falls back to
-    // CH and is compatible with CH data
-    using namespace osrm;
-
-    auto osrm =
-        getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-    test_tile_speeds(osrm);
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_speeds_ch_new_api)
+{
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
+BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_old_api)
+{
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_speeds_corech_new_api)
+{
+    test_tile_speeds_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_speeds_mld)
+void test_tile_speeds_mld(bool use_string_only_api)
 {
     using namespace osrm;
 
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
-    test_tile_speeds(osrm);
+    test_tile_speeds(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_speeds_mld_old_api) { test_tile_speeds_mld(true); }
+BOOST_AUTO_TEST_CASE(test_tile_speeds_mld_new_api) { test_tile_speeds_mld(false); }
 
-void test_tile_nodes(const osrm::OSRM &osrm)
+void test_tile_nodes(const osrm::OSRM &osrm, bool use_string_only_api)
 {
     using namespace osrm;
 
@@ -430,11 +461,10 @@ void test_tile_nodes(const osrm::OSRM &osrm)
     // Small tile where we can test all the values
     TileParameters params{272953, 191177, 19};
 
-    engine::api::ResultT result = std::string();
-    const auto rc = osrm.Tile(params, result);
+    std::string str_result;
+    const auto rc = run_tile(osrm, params, str_result, use_string_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &str_result = result.get<std::string>();
     BOOST_CHECK_GT(str_result.size(), 128);
 
     vtzero::vector_tile tile{str_result};
@@ -456,31 +486,38 @@ void test_tile_nodes(const osrm::OSRM &osrm)
     BOOST_CHECK(found_node_ids == expected_node_ids);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_nodes_ch)
+void test_tile_nodes_ch(osrm::EngineConfig::Algorithm algorithm, bool use_string_only_api)
 {
     using namespace osrm;
 
-    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CH);
-    test_tile_nodes(osrm);
+    auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", algorithm);
+    test_tile_nodes(osrm, use_string_only_api);
 }
-
-BOOST_AUTO_TEST_CASE(test_tile_nodes_corech)
+BOOST_AUTO_TEST_CASE(test_tile_node_ch_old_api)
 {
-    // Note: this tests that given the CoreCH algorithm config option, configuration falls back to
-    // CH and is compatible with CH data
-    using namespace osrm;
-
-    auto osrm =
-        getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm", osrm::EngineConfig::Algorithm::CoreCH);
-    test_tile_nodes(osrm);
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_node_ch_new_api)
+{
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CH, false);
+}
+BOOST_AUTO_TEST_CASE(test_tile_node_corech_old_api)
+{
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, true);
+}
+BOOST_AUTO_TEST_CASE(test_tile_node_corech_new_api)
+{
+    test_tile_nodes_ch(osrm::EngineConfig::Algorithm::CoreCH, false);
 }
 
-BOOST_AUTO_TEST_CASE(test_tile_nodes_mld)
+void test_tile_nodes_mld(bool use_string_only_api)
 {
     using namespace osrm;
 
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/mld/monaco.osrm", osrm::EngineConfig::Algorithm::MLD);
-    test_tile_nodes(osrm);
+    test_tile_nodes(osrm, use_string_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tile_node_mld_old_api) { test_tile_nodes_mld(true); }
+BOOST_AUTO_TEST_CASE(test_tile_node_mld_new_api) { test_tile_nodes_mld(false); }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/library/trip.cpp b/unit_tests/library/trip.cpp
index 043d5a1be..6eb500e81 100644
--- a/unit_tests/library/trip.cpp
+++ b/unit_tests/library/trip.cpp
@@ -7,14 +7,28 @@
 #include <engine/api/flatbuffers/fbresult_generated.h>
 
 #include "osrm/coordinate.hpp"
-#include "osrm/engine_config.hpp"
 #include "osrm/json_container.hpp"
 #include "osrm/osrm.hpp"
 #include "osrm/status.hpp"
 
+osrm::Status run_trip_json(const osrm::OSRM &osrm,
+                           const osrm::TripParameters &params,
+                           osrm::json::Object &json_result,
+                           bool use_json_only_api)
+{
+    if (use_json_only_api)
+    {
+        return osrm.Trip(params, json_result);
+    }
+    osrm::engine::api::ResultT result = osrm::json::Object();
+    auto rc = osrm.Trip(params, result);
+    json_result = result.get<osrm::json::Object>();
+    return rc;
+}
+
 BOOST_AUTO_TEST_SUITE(trip)
 
-BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component)
+void test_roundtrip_response_for_locations_in_small_component(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -26,11 +40,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component)
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -56,8 +69,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component)
         BOOST_CHECK(pos >= 0 && pos < waypoints.size());
     }
 }
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_old_api)
+{
+    test_roundtrip_response_for_locations_in_small_component(true);
+}
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_new_api)
+{
+    test_roundtrip_response_for_locations_in_small_component(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_skip_waypoints)
+void test_roundtrip_response_for_locations_in_small_component_skip_waypoints(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -70,18 +91,27 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_small_component_sk
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
     BOOST_CHECK(json_result.values.find("waypoints") == json_result.values.end());
 }
+BOOST_AUTO_TEST_CASE(
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints_old_api)
+{
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints(true);
+}
+BOOST_AUTO_TEST_CASE(
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints_new_api)
+{
+    test_roundtrip_response_for_locations_in_small_component_skip_waypoints(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component)
+void test_roundtrip_response_for_locations_in_big_component(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -93,11 +123,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component)
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -123,8 +152,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component)
         BOOST_CHECK(pos >= 0 && pos < waypoints.size());
     }
 }
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_old_api)
+{
+    test_roundtrip_response_for_locations_in_big_component(true);
+}
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_in_big_component_new_api)
+{
+    test_roundtrip_response_for_locations_in_big_component(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components)
+void test_roundtrip_response_for_locations_across_components(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -138,11 +175,10 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components)
     params.coordinates.push_back(small.at(1));
     params.coordinates.push_back(big.at(1));
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -170,8 +206,16 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components)
         BOOST_CHECK(pos >= 0 && pos < waypoints.size());
     }
 }
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_old_api)
+{
+    test_roundtrip_response_for_locations_across_components(true);
+}
+BOOST_AUTO_TEST_CASE(test_roundtrip_response_for_locations_across_components_new_api)
+{
+    test_roundtrip_response_for_locations_across_components(false);
+}
 
-BOOST_AUTO_TEST_CASE(test_tfse_1)
+void test_tfse_1(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -187,11 +231,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_1)
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = false;
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -217,8 +260,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_1)
         BOOST_CHECK(pos >= 0 && pos < waypoints.size());
     }
 }
+BOOST_AUTO_TEST_CASE(test_tfse_1_old_api) { test_tfse_1(true); }
+BOOST_AUTO_TEST_CASE(test_tfse_1_new_api) { test_tfse_1(false); }
 
-BOOST_AUTO_TEST_CASE(test_tfse_2)
+void test_tfse_2(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -234,11 +279,10 @@ BOOST_AUTO_TEST_CASE(test_tfse_2)
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = false;
 
-    engine::api::ResultT result = json::Object();
-    const auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_CHECK(rc == Status::Ok);
 
-    auto &json_result = result.get<json::Object>();
     const auto code = json_result.values.at("code").get<json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 
@@ -264,6 +308,8 @@ BOOST_AUTO_TEST_CASE(test_tfse_2)
         BOOST_CHECK(pos >= 0 && pos < waypoints.size());
     }
 }
+BOOST_AUTO_TEST_CASE(test_tfse_2_old_api) { test_tfse_2(true); }
+BOOST_AUTO_TEST_CASE(test_tfse_2_new_api) { test_tfse_2(false); }
 
 void ResetParams(const Locations &locations, osrm::TripParameters &params)
 {
@@ -272,29 +318,29 @@ void ResetParams(const Locations &locations, osrm::TripParameters &params)
     params.coordinates.push_back(locations.at(1));
     params.coordinates.push_back(locations.at(2));
 }
-void CheckNotImplemented(const osrm::OSRM &osrm, osrm::TripParameters &params)
+void CheckNotImplemented(const osrm::OSRM &osrm,
+                         osrm::TripParameters &params,
+                         bool use_json_only_api)
 {
     using namespace osrm;
-    engine::api::ResultT result = json::Object();
-    auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == osrm::Status::Error);
-    auto &json_result = result.get<json::Object>();
     auto code = json_result.values.at("code").get<osrm::json::String>().value;
     BOOST_CHECK_EQUAL(code, "NotImplemented");
 }
 
-void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters &params)
+void CheckOk(const osrm::OSRM &osrm, osrm::TripParameters &params, bool use_json_only_api)
 {
     using namespace osrm;
-    engine::api::ResultT result = json::Object();
-    auto rc = osrm.Trip(params, result);
+    json::Object json_result;
+    const auto rc = run_trip_json(osrm, params, json_result, use_json_only_api);
     BOOST_REQUIRE(rc == osrm::Status::Ok);
-    auto &json_result = result.get<json::Object>();
     auto code = json_result.values.at("code").get<osrm::json::String>().value;
     BOOST_CHECK_EQUAL(code, "Ok");
 }
 
-BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters)
+void test_tfse_illegal_parameters(bool use_json_only_api)
 {
     using namespace osrm;
 
@@ -305,47 +351,49 @@ BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters)
     // one parameter set
     ResetParams(locations, params);
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     // two parameter set
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::Any;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::First;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     // three parameters set
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = false;
-    CheckNotImplemented(osrm, params);
+    CheckNotImplemented(osrm, params, use_json_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters_old_api) { test_tfse_illegal_parameters(true); }
+BOOST_AUTO_TEST_CASE(test_tfse_illegal_parameters_new_api) { test_tfse_illegal_parameters(false); }
 
-BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters)
+void test_tfse_legal_parameters(bool use_json_only_api)
 {
     using namespace osrm;
     auto osrm = getOSRM(OSRM_TEST_DATA_DIR "/ch/monaco.osrm");
@@ -355,96 +403,98 @@ BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters)
 
     // no parameter set
     ResetParams(locations, params);
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     // one parameter set
     ResetParams(locations, params);
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::First;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::Any;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Any;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Last;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     // two parameter set
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::First;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Any;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Last;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Last;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::Any;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     ResetParams(locations, params);
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Any;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     // three parameter set
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = false;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::Any;
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Any;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 
     params.source = TripParameters::SourceType::First;
     params.destination = TripParameters::DestinationType::Last;
     params.roundtrip = true;
-    CheckOk(osrm, params);
+    CheckOk(osrm, params, use_json_only_api);
 }
+BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters_old_api) { test_tfse_legal_parameters(true); }
+BOOST_AUTO_TEST_CASE(test_tfse_legal_parameters_new_api) { test_tfse_legal_parameters(false); }
 
 BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization)
 {
@@ -475,7 +525,7 @@ BOOST_AUTO_TEST_CASE(test_roundtrip_response_fb_serialization)
     const auto trips = fb->routes();
     BOOST_CHECK_EQUAL(trips->size(), 1);
 
-    for (const auto &waypoint : *waypoints)
+    for (const auto waypoint : *waypoints)
     {
         const auto longitude = waypoint->location()->longitude();
         const auto latitude = waypoint->location()->latitude();
diff --git a/unit_tests/library/waypoint_check.hpp b/unit_tests/library/waypoint_check.hpp
index 5bd3161fc..76e4524f3 100644
--- a/unit_tests/library/waypoint_check.hpp
+++ b/unit_tests/library/waypoint_check.hpp
@@ -6,10 +6,10 @@
 #include "osrm/json_container.hpp"
 #include "util/exception.hpp"
 
-using namespace osrm;
-
-inline bool waypoint_check(json::Value waypoint)
+inline bool waypoint_check(osrm::json::Value waypoint)
 {
+    using namespace osrm;
+
     if (!waypoint.is<mapbox::util::recursive_wrapper<util::json::Object>>())
     {
         throw util::exception("Must pass in a waypoint object");
@@ -24,6 +24,8 @@ inline bool waypoint_check(json::Value waypoint)
 
 inline bool waypoint_check(const osrm::engine::api::fbresult::Waypoint *const waypoint)
 {
+    using namespace osrm;
+
     util::FloatLongitude lon{waypoint->location()->longitude()};
     util::FloatLatitude lat{waypoint->location()->latitude()};
     util::Coordinate location_coordinate(lon, lat);
diff --git a/unit_tests/mocks/mock_datafacade.hpp b/unit_tests/mocks/mock_datafacade.hpp
index 7b0dc8eff..4edcb9735 100644
--- a/unit_tests/mocks/mock_datafacade.hpp
+++ b/unit_tests/mocks/mock_datafacade.hpp
@@ -328,7 +328,7 @@ class MockDataFacade final : public MockBaseDataFacade, public MockAlgorithmData
 {
 };
 
-} // ns test
-} // ns osrm
+} // namespace test
+} // namespace osrm
 
 #endif // MOCK_DATAFACADE_HPP
diff --git a/unit_tests/mocks/mock_scripting_environment.hpp b/unit_tests/mocks/mock_scripting_environment.hpp
index 8531176ad..a34a03cc0 100644
--- a/unit_tests/mocks/mock_scripting_environment.hpp
+++ b/unit_tests/mocks/mock_scripting_environment.hpp
@@ -42,7 +42,7 @@ class MockScriptingEnvironment : public extractor::ScriptingEnvironment
                          const extractor::ExtractionRelationContainer &,
                          std::vector<std::pair<const osmium::Node &, extractor::ExtractionNode>> &,
                          std::vector<std::pair<const osmium::Way &, extractor::ExtractionWay>> &,
-                         std::vector<extractor::InputConditionalTurnRestriction> &,
+                         std::vector<extractor::InputTurnRestriction> &,
                          std::vector<extractor::InputManeuverOverride> &) override final
     {
     }
diff --git a/unit_tests/partitioner/bisection_graph.cpp b/unit_tests/partitioner/bisection_graph.cpp
index bfecb63c3..7dc664e51 100644
--- a/unit_tests/partitioner/bisection_graph.cpp
+++ b/unit_tests/partitioner/bisection_graph.cpp
@@ -4,6 +4,7 @@
 #include "util/debug.hpp"
 
 #include <algorithm>
+#include <random>
 #include <vector>
 
 #include <boost/test/unit_test.hpp>
@@ -90,8 +91,9 @@ BOOST_AUTO_TEST_CASE(access_edges)
     const auto coordinates = makeGridCoordinates(rows, cols, step_size, 0, 0);
 
     auto grid_edges = makeGridEdges(rows, cols, 0);
-
-    std::random_shuffle(grid_edges.begin(), grid_edges.end());
+    std::random_device rd;
+    std::mt19937 rng(rd());
+    std::shuffle(grid_edges.begin(), grid_edges.end(), rng);
     groupEdgesBySource(grid_edges.begin(), grid_edges.end());
 
     const auto graph = makeBisectionGraph(coordinates, adaptToBisectionEdge(std::move(grid_edges)));
diff --git a/unit_tests/partitioner/bisection_graph_view.cpp b/unit_tests/partitioner/bisection_graph_view.cpp
index dc758a63a..b98ac9fae 100644
--- a/unit_tests/partitioner/bisection_graph_view.cpp
+++ b/unit_tests/partitioner/bisection_graph_view.cpp
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <climits>
+#include <random>
 #include <vector>
 
 #include <boost/test/unit_test.hpp>
@@ -15,6 +16,13 @@ using namespace osrm::util;
 
 BOOST_AUTO_TEST_SUITE(graph_view)
 
+static void shuffle(std::vector<EdgeWithSomeAdditionalData> &grid_edges)
+{
+    std::random_device rd;
+    std::mt19937 rng(rd());
+    std::shuffle(grid_edges.begin(), grid_edges.end(), rng);
+}
+
 BOOST_AUTO_TEST_CASE(separate_top_bottom)
 {
     // 40 entries of left/right edges
@@ -25,7 +33,7 @@ BOOST_AUTO_TEST_CASE(separate_top_bottom)
 
     auto grid_edges = makeGridEdges(rows, cols, 0);
 
-    std::random_shuffle(grid_edges.begin(), grid_edges.end());
+    shuffle(grid_edges);
     groupEdgesBySource(grid_edges.begin(), grid_edges.end());
 
     auto graph = makeBisectionGraph(coordinates, adaptToBisectionEdge(std::move(grid_edges)));
@@ -74,7 +82,7 @@ BOOST_AUTO_TEST_CASE(separate_top_bottom_copy)
 
     auto grid_edges = makeGridEdges(rows, cols, 0);
 
-    std::random_shuffle(grid_edges.begin(), grid_edges.end());
+    shuffle(grid_edges);
     groupEdgesBySource(grid_edges.begin(), grid_edges.end());
 
     auto graph = makeBisectionGraph(coordinates, adaptToBisectionEdge(std::move(grid_edges)));
@@ -125,7 +133,7 @@ BOOST_AUTO_TEST_CASE(separate_left_right)
 
     auto grid_edges = makeGridEdges(rows, cols, 0);
 
-    std::random_shuffle(grid_edges.begin(), grid_edges.end());
+    shuffle(grid_edges);
     groupEdgesBySource(grid_edges.begin(), grid_edges.end());
 
     auto graph = makeBisectionGraph(coordinates, adaptToBisectionEdge(std::move(grid_edges)));
diff --git a/unit_tests/partitioner/bisection_to_partition.cpp b/unit_tests/partitioner/bisection_to_partition.cpp
index 2fadb1f92..cbc5a3261 100644
--- a/unit_tests/partitioner/bisection_to_partition.cpp
+++ b/unit_tests/partitioner/bisection_to_partition.cpp
@@ -3,7 +3,7 @@
 
 #include "partitioner/bisection_to_partition.hpp"
 
-#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL(range.end() - range.begin(), ref)
+#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL((range).end() - (range).begin(), ref)
 #define CHECK_EQUAL_RANGE(range, ref)                                                              \
     do                                                                                             \
     {                                                                                              \
@@ -149,7 +149,18 @@ BOOST_AUTO_TEST_CASE(power_of_two_case)
      0   1   2   3   4   5   6   7   8   9   10   11
     */
     const std::vector<BisectionID> ids_1 = {
-        0b000, 0b000, 0b001, 0b001, 0b010, 0b010, 0b011, 0b011, 0b100, 0b100, 0b101, 0b101,
+        0b000,
+        0b000,
+        0b001,
+        0b001,
+        0b010,
+        0b010,
+        0b011,
+        0b011,
+        0b100,
+        0b100,
+        0b101,
+        0b101,
     };
 
     // If cell sizes are not a factor of two we will see sub-optimal results like below
@@ -276,7 +287,18 @@ BOOST_AUTO_TEST_CASE(non_factor_two_case)
      0   1   2   3   4   5   6   7   8   9   10   11
     */
     const std::vector<BisectionID> ids_1 = {
-        0b000, 0b000, 0b001, 0b001, 0b010, 0b010, 0b011, 0b011, 0b100, 0b100, 0b101, 0b101,
+        0b000,
+        0b000,
+        0b001,
+        0b001,
+        0b010,
+        0b010,
+        0b011,
+        0b011,
+        0b100,
+        0b100,
+        0b101,
+        0b101,
     };
 
     // If cell sizes are not a factor of two we will see sub-optimal results like below
diff --git a/unit_tests/partitioner/cell_storage.cpp b/unit_tests/partitioner/cell_storage.cpp
index 705371ab3..635583d82 100644
--- a/unit_tests/partitioner/cell_storage.cpp
+++ b/unit_tests/partitioner/cell_storage.cpp
@@ -34,7 +34,7 @@ auto makeGraph(const std::vector<MockEdge> &mock_edges)
     std::sort(edges.begin(), edges.end());
     return util::StaticGraph<EdgeData>(max_id + 1, edges);
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(cell_storage_tests)
 
diff --git a/unit_tests/partitioner/graph_generator.hpp b/unit_tests/partitioner/graph_generator.hpp
index 4647d558a..ab55d4779 100644
--- a/unit_tests/partitioner/graph_generator.hpp
+++ b/unit_tests/partitioner/graph_generator.hpp
@@ -7,8 +7,6 @@
 #include <algorithm>
 #include <vector>
 
-using namespace osrm::util;
-
 struct EdgeWithSomeAdditionalData
 {
     NodeID source;
@@ -16,16 +14,17 @@ struct EdgeWithSomeAdditionalData
     unsigned important_data;
 };
 
-inline Coordinate
+inline osrm::util::Coordinate
 makeCoordinate(int x, int y, double step_size, double offset_x = 0, double offset_y = 0)
 {
-    return {FloatLongitude{offset_x + x * step_size}, FloatLatitude{offset_y + y * step_size}};
+    return {osrm::util::FloatLongitude{offset_x + x * step_size},
+            osrm::util::FloatLatitude{offset_y + y * step_size}};
 }
 
-std::vector<Coordinate> inline makeGridCoordinates(
+std::vector<osrm::util::Coordinate> inline makeGridCoordinates(
     int rows, int columns, double step_size, double lon_base, double lat_base)
 {
-    std::vector<Coordinate> result;
+    std::vector<osrm::util::Coordinate> result;
 
     for (int r = 0; r < rows; ++r)
         for (int c = 0; c < columns; ++c)
diff --git a/unit_tests/partitioner/multi_level_graph.cpp b/unit_tests/partitioner/multi_level_graph.cpp
index 2a2562459..05a988440 100644
--- a/unit_tests/partitioner/multi_level_graph.cpp
+++ b/unit_tests/partitioner/multi_level_graph.cpp
@@ -39,7 +39,7 @@ auto makeGraph(const MultiLevelPartition &mlp, const std::vector<MockEdge> &mock
     std::sort(edges.begin(), edges.end());
     return MultiLevelGraph<EdgeData, osrm::storage::Ownership::Container>(mlp, max_id + 1, edges);
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(multi_level_graph)
 
diff --git a/unit_tests/partitioner/multi_level_partition.cpp b/unit_tests/partitioner/multi_level_partition.cpp
index e2807a37f..62fca2772 100644
--- a/unit_tests/partitioner/multi_level_partition.cpp
+++ b/unit_tests/partitioner/multi_level_partition.cpp
@@ -1,9 +1,14 @@
 #include <boost/numeric/conversion/cast.hpp>
 #include <boost/test/unit_test.hpp>
 
+#include "util/exception.hpp"
+#include "util/for_each_indexed.hpp"
+#include <util/integer_range.hpp>
+#include <util/msb.hpp>
+
 #include "partitioner/multi_level_partition.hpp"
 
-#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL(range.second - range.first, ref)
+#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL((range).second - (range).first, ref)
 #define CHECK_EQUAL_RANGE(range, ref)                                                              \
     do                                                                                             \
     {                                                                                              \
@@ -175,4 +180,111 @@ BOOST_AUTO_TEST_CASE(mlp_sorted)
     BOOST_CHECK_EQUAL(mlp.EndChildren(4, 0), 2);
 }
 
+BOOST_AUTO_TEST_CASE(large_cell_number)
+{
+    size_t num_nodes = 256;
+    size_t num_levels = 9;
+    std::vector<std::vector<CellID>> levels(num_levels, std::vector<CellID>(num_nodes));
+    std::vector<uint32_t> levels_to_num_cells(num_levels);
+
+    std::iota(levels[0].begin(), levels[0].end(), 0);
+    levels_to_num_cells[0] = num_nodes;
+
+    for (auto l : util::irange<size_t>(1UL, num_levels))
+    {
+        std::transform(levels[l - 1].begin(), levels[l - 1].end(), levels[l].begin(), [](auto val) {
+            return val / 2;
+        });
+        levels_to_num_cells[l] = levels_to_num_cells[l - 1] / 2;
+    }
+
+    // level 1:             0  1  2  3 ... 252 253 254 255
+    // level 2:             0  0  1  1 ... 126 126 127 127
+    // level 3:             0  0  0  0 ... 63  63  63  63
+    // ...
+    // level 9:             0  0  0  0 ... 0   0   0   0
+    MultiLevelPartition mlp{levels, levels_to_num_cells};
+
+    for (const auto l : util::irange<size_t>(1UL, num_levels + 1))
+    {
+        BOOST_REQUIRE_EQUAL(mlp.GetNumberOfCells(l), num_nodes >> (l - 1));
+        for (const auto n : util::irange<size_t>(0UL, num_nodes))
+        {
+            BOOST_REQUIRE_EQUAL(mlp.GetCell(l, n), levels[l - 1][n]);
+        }
+    }
+
+    for (const auto m : util::irange<size_t>(0UL, num_nodes))
+    {
+        for (const auto n : util::irange(m + 1, num_nodes))
+        {
+            BOOST_REQUIRE_EQUAL(mlp.GetHighestDifferentLevel(m, n), 1 + util::msb(m ^ n));
+        }
+    }
+
+    for (const auto l : util::irange<size_t>(2UL, num_levels + 1))
+    {
+        for (const auto c : util::irange<size_t>(0UL, levels_to_num_cells[l - 1]))
+        {
+            BOOST_REQUIRE_EQUAL(mlp.BeginChildren(l, c), 2 * c);
+            BOOST_REQUIRE_EQUAL(mlp.EndChildren(l, c), 2 * (c + 1));
+        }
+    }
+}
+
+BOOST_AUTO_TEST_CASE(cell_64_bits)
+{
+    // bits = ceil(log2(2458529 + 1)) + ceil(log2(258451 + 1)) +  ceil(log2(16310 + 1)) +
+    // ceil(log2(534 + 1))
+    //      = 22 + 18 + 14 + 10
+    //      = 64
+    const size_t NUM_PARTITIONS = 2458529;
+    const std::vector<size_t> level_cells = {NUM_PARTITIONS, 258451, 16310, 534};
+    std::vector<std::vector<CellID>> levels(level_cells.size(),
+                                            std::vector<CellID>(level_cells[0]));
+    std::vector<uint32_t> levels_to_num_cells(level_cells.size());
+
+    const auto set_level_cells = [&](size_t level, auto const num_cells) {
+        for (auto val : util::irange<size_t>(0ULL, NUM_PARTITIONS))
+        {
+            levels[level][val] = std::min(val, num_cells - 1);
+        }
+        levels_to_num_cells[level] = num_cells;
+    };
+    util::for_each_indexed(level_cells, set_level_cells);
+
+    MultiLevelPartition mlp{levels, levels_to_num_cells};
+
+    BOOST_REQUIRE_EQUAL(mlp.GetNumberOfCells(1), level_cells[0]);
+    BOOST_REQUIRE_EQUAL(mlp.GetNumberOfCells(2), level_cells[1]);
+    BOOST_REQUIRE_EQUAL(mlp.GetNumberOfCells(3), level_cells[2]);
+    BOOST_REQUIRE_EQUAL(mlp.GetNumberOfCells(4), level_cells[3]);
+}
+
+BOOST_AUTO_TEST_CASE(cell_overflow_bits)
+{
+    // bits = ceil(log2(4194304 + 1)) + ceil(log2(262144 + 1)) +  ceil(log2(16384 + 1)) +
+    // ceil(log2(1024 + 1))
+    //      = 23 + 19 + 15 + 11
+    //      = 68
+    const size_t NUM_PARTITIONS = 4194304;
+    const std::vector<size_t> level_cells = {NUM_PARTITIONS, 262144, 16384, 1024};
+    std::vector<std::vector<CellID>> levels(level_cells.size(),
+                                            std::vector<CellID>(level_cells[0]));
+    std::vector<uint32_t> levels_to_num_cells(level_cells.size());
+
+    const auto set_level_cells = [&](size_t level, auto const num_cells) {
+        for (auto val : util::irange<size_t>(0ULL, NUM_PARTITIONS))
+        {
+            levels[level][val] = std::min(val, num_cells - 1);
+        }
+        levels_to_num_cells[level] = num_cells;
+    };
+    util::for_each_indexed(level_cells, set_level_cells);
+
+    BOOST_REQUIRE_EXCEPTION(MultiLevelPartition(levels, levels_to_num_cells),
+                            util::exception,
+                            [](auto) { return true; });
+}
+
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/partitioner/recursive_bisection.cpp b/unit_tests/partitioner/recursive_bisection.cpp
index 64c692678..2e040a2bf 100644
--- a/unit_tests/partitioner/recursive_bisection.cpp
+++ b/unit_tests/partitioner/recursive_bisection.cpp
@@ -72,7 +72,7 @@ BOOST_AUTO_TEST_CASE(dividing_four_grid_cells)
 
     RecursiveBisection bisection(graph, 120, 1.1, 0.25, 10, 1);
 
-    const auto result = bisection.BisectionIDs();
+    const auto &result = bisection.BisectionIDs();
     // all same IDs withing a group
     for (int i = 0; i < 4; ++i)
         for (int j = 0; j < rows * cols; ++j)
diff --git a/unit_tests/partitioner/remove_unconnected.cpp b/unit_tests/partitioner/remove_unconnected.cpp
index 62687c199..11d89b19a 100644
--- a/unit_tests/partitioner/remove_unconnected.cpp
+++ b/unit_tests/partitioner/remove_unconnected.cpp
@@ -5,7 +5,7 @@
 
 #include "util/static_graph.hpp"
 
-#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL(range.end() - range.begin(), ref)
+#define CHECK_SIZE_RANGE(range, ref) BOOST_CHECK_EQUAL((range).end() - (range).begin(), ref)
 #define CHECK_EQUAL_RANGE(range, ref)                                                              \
     do                                                                                             \
     {                                                                                              \
@@ -44,7 +44,7 @@ auto makeGraph(const std::vector<MockEdge> &mock_edges)
     std::sort(edges.begin(), edges.end());
     return util::StaticGraph<EdgeData>(max_id + 1, edges);
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(remove_unconnected_tests)
 
diff --git a/unit_tests/partitioner/renumber.cpp b/unit_tests/partitioner/renumber.cpp
index 391220eae..6fa2898b1 100644
--- a/unit_tests/partitioner/renumber.cpp
+++ b/unit_tests/partitioner/renumber.cpp
@@ -39,7 +39,7 @@ auto makeGraph(const std::vector<MockEdge> &mock_edges)
     std::sort(edges.begin(), edges.end());
     return DynamicEdgeBasedGraph(max_id + 1, edges);
 }
-}
+} // namespace
 
 BOOST_AUTO_TEST_SUITE(renumber_tests)
 
diff --git a/unit_tests/server/parameters_io.hpp b/unit_tests/server/parameters_io.hpp
index 527614876..e7930aa2a 100644
--- a/unit_tests/server/parameters_io.hpp
+++ b/unit_tests/server/parameters_io.hpp
@@ -47,7 +47,7 @@ inline std::ostream &operator<<(std::ostream &out, api::RouteParameters::Overvie
     }
     return out;
 }
-}
+} // namespace api
 
 inline std::ostream &operator<<(std::ostream &out, Bearing bearing)
 {
@@ -60,7 +60,7 @@ inline std::ostream &operator<<(std::ostream &out, Approach approach)
     out << static_cast<int>(approach);
     return out;
 }
-}
-}
+} // namespace engine
+} // namespace osrm
 
 #endif
diff --git a/unit_tests/server/parameters_parser.cpp b/unit_tests/server/parameters_parser.cpp
index 42a4284b2..42b5a60b9 100644
--- a/unit_tests/server/parameters_parser.cpp
+++ b/unit_tests/server/parameters_parser.cpp
@@ -17,7 +17,7 @@
 #include <boost/test/unit_test.hpp>
 
 #define CHECK_EQUAL_RANGE(R1, R2)                                                                  \
-    BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
+    BOOST_CHECK_EQUAL_COLLECTIONS((R1).begin(), (R1).end(), (R2).begin(), (R2).end());
 
 BOOST_AUTO_TEST_SUITE(api_parameters_parser)
 
@@ -108,6 +108,13 @@ BOOST_AUTO_TEST_CASE(invalid_table_urls)
     BOOST_CHECK_EQUAL(
         testInvalidOptions<TableParameters>("1,2;3,4?annotations=durations&fallback_speed=-1"),
         28UL);
+    // TODO(danpat): this is only testing invalid grammar which isn't capable of checking
+    //               for values that need to reference other things currently.  These
+    //               requests are gramatically correct, but semantically incorrect.
+    //               The table service properly fails these, as it checks IsValid() after
+    //               parsing, which fails when sources/destinations are too large
+    // BOOST_CHECK_EQUAL(testInvalidOptions<TableParameters>("1,2;3,4?sources=2"), 7UL);
+    // BOOST_CHECK_EQUAL(testInvalidOptions<TableParameters>("1,2;3,4?destinations=2"), 7UL);
 }
 
 BOOST_AUTO_TEST_CASE(valid_route_hint)
@@ -222,7 +229,9 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     CHECK_EQUAL_RANGE(reference_4.hints, result_4->hints);
 
     std::vector<boost::optional<engine::Bearing>> bearings_4 = {
-        boost::none, engine::Bearing{200, 10}, engine::Bearing{100, 5},
+        boost::none,
+        engine::Bearing{200, 10},
+        engine::Bearing{100, 5},
     };
     RouteParameters reference_5{false,
                                 false,
@@ -323,9 +332,9 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
                                  hints_10,
                                  std::vector<boost::optional<double>>{},
                                  std::vector<boost::optional<engine::Bearing>>{}};
-    auto result_10 = parseParameters<RouteParameters>("1,2;3,4;5,6;7,8?steps=false&hints=" +
-                                                      hints_10[0]->ToBase64() + ";;" +
-                                                      hints_10[2]->ToBase64() + ";");
+    auto result_10 = parseParameters<RouteParameters>(
+        "1,2;3,4;5,6;7,8?steps=false&hints=" + hints_10[0]->ToBase64() + ";;" +
+        hints_10[2]->ToBase64() + ";");
     BOOST_CHECK(result_10);
     BOOST_CHECK_EQUAL(reference_10.steps, result_10->steps);
     BOOST_CHECK_EQUAL(reference_10.alternatives, result_10->alternatives);
@@ -420,7 +429,10 @@ BOOST_AUTO_TEST_CASE(valid_route_urls)
     BOOST_CHECK_EQUAL(result_17->annotations, true);
 
     std::vector<boost::optional<engine::Approach>> approaches_18 = {
-        boost::none, engine::Approach::CURB, engine::Approach::UNRESTRICTED, engine::Approach::CURB,
+        boost::none,
+        engine::Approach::CURB,
+        engine::Approach::UNRESTRICTED,
+        engine::Approach::CURB,
     };
     RouteParameters reference_18{false,
                                  false,
diff --git a/unit_tests/server/url_parser.cpp b/unit_tests/server/url_parser.cpp
index 2c3fa0f8d..0796cbe7b 100644
--- a/unit_tests/server/url_parser.cpp
+++ b/unit_tests/server/url_parser.cpp
@@ -15,15 +15,15 @@ std::ostream &operator<<(std::ostream &out, const osrm::server::api::ParsedURL &
 
     return out;
 }
-}
-}
-}
+} // namespace api
+} // namespace server
+} // namespace osrm
 
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 
 #define CHECK_EQUAL_RANGE(R1, R2)                                                                  \
-    BOOST_CHECK_EQUAL_COLLECTIONS(R1.begin(), R1.end(), R2.begin(), R2.end());
+    BOOST_CHECK_EQUAL_COLLECTIONS((R1).begin(), (R1).end(), (R2).begin(), (R2).end());
 
 BOOST_AUTO_TEST_SUITE(api_url_parser)
 
@@ -44,7 +44,7 @@ BOOST_AUTO_TEST_CASE(invalid_urls)
     BOOST_CHECK_EQUAL(testInvalidURL("/route/"), 7UL);
     BOOST_CHECK_EQUAL(testInvalidURL("/route/bla"), 7UL);
     BOOST_CHECK_EQUAL(testInvalidURL("/route/1/1,2;3;4"), 7UL);
-    BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/pro_file/1,2;3,4"), 13UL);
+    BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/pro[]file/1,2;3,4"), 13UL);
     BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/profile"), 17UL);
     BOOST_CHECK_EQUAL(testInvalidURL("/route/v1/profile/"), 18UL);
 }
@@ -124,6 +124,18 @@ BOOST_AUTO_TEST_CASE(valid_urls)
     BOOST_CHECK_EQUAL(reference_8.profile, result_8->profile);
     CHECK_EQUAL_RANGE(reference_8.query, result_8->query);
     BOOST_CHECK_EQUAL(reference_8.prefix_length, result_8->prefix_length);
+
+    // profile with special characters
+    api::ParsedURL reference_9{
+        "route", 1, "foo-bar_baz.profile", "0,1;2,3;4,5?options=value&foo=bar", 30UL};
+    auto result_9 =
+        api::parseURL("/route/v1/foo-bar_baz.profile/0,1;2,3;4,5?options=value&foo=bar");
+    BOOST_CHECK(result_9);
+    BOOST_CHECK_EQUAL(reference_9.service, result_9->service);
+    BOOST_CHECK_EQUAL(reference_9.version, result_9->version);
+    BOOST_CHECK_EQUAL(reference_9.profile, result_9->profile);
+    CHECK_EQUAL_RANGE(reference_9.query, result_9->query);
+    BOOST_CHECK_EQUAL(reference_9.prefix_length, result_9->prefix_length);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/storage/serialization.cpp b/unit_tests/storage/serialization.cpp
index 760f1faea..4b38e43d1 100644
--- a/unit_tests/storage/serialization.cpp
+++ b/unit_tests/storage/serialization.cpp
@@ -150,7 +150,11 @@ BOOST_AUTO_TEST_CASE(tar_serialize_deallocting_vector)
 BOOST_AUTO_TEST_CASE(buffer_serialize_map)
 {
     std::map<std::string, std::int32_t> map = {
-        {"foo", 1}, {"barrrr", 2}, {"bal", 3}, {"bazbar", 4}, {"foofofofo", 5},
+        {"foo", 1},
+        {"barrrr", 2},
+        {"bal", 3},
+        {"bazbar", 4},
+        {"foofofofo", 5},
     };
 
     std::string buffer;
diff --git a/unit_tests/updater/timezoner.cpp b/unit_tests/updater/timezoner.cpp
index 543c14312..9f4a3744a 100644
--- a/unit_tests/updater/timezoner.cpp
+++ b/unit_tests/updater/timezoner.cpp
@@ -53,5 +53,19 @@ BOOST_AUTO_TEST_CASE(timezoner_test)
         "48.88277], [8.57757, 49.07206], [8.28369, "
         "49.07206], [8.28369, 48.88277]]] }} ]}";
     BOOST_CHECK_THROW(Timezoner tz(missing_featc, now), util::exception);
+
+    char missing_tzid[] = "{ \"type\" : \"Feature\","
+                          "\"properties\" : { }, \"geometry\" : { \"type\": \"polygon\", "
+                          "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                          "48.88277], [8.57757, 49.07206], [8.28369, "
+                          "49.07206], [8.28369, 48.88277]]] }}";
+    BOOST_CHECK_THROW(Timezoner tz(missing_tzid, now), util::exception);
+
+    char tzid_err[] = "{ \"type\" : \"Feature\","
+                      "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\", "
+                      "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
+                      "48.88277], [8.57757, 49.07206], [8.28369, "
+                      "49.07206], [8.28369, 48.88277]]] }}";
+    BOOST_CHECK_THROW(Timezoner tz(tzid_err, now), util::exception);
 }
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/unit_tests/updater/validation.cpp b/unit_tests/updater/validation.cpp
index b68c34528..177dc52d5 100644
--- a/unit_tests/updater/validation.cpp
+++ b/unit_tests/updater/validation.cpp
@@ -65,22 +65,6 @@ BOOST_AUTO_TEST_CASE(timezone_validation_test)
     doc.Parse(nonobj_props);
     BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
 
-    char missing_tzid[] = "{ \"type\" : \"Feature\","
-                          "\"properties\" : { }, \"geometry\" : { \"type\": \"polygon\", "
-                          "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                          "48.88277], [8.57757, 49.07206], [8.28369, "
-                          "49.07206], [8.28369, 48.88277]]] }}";
-    doc.Parse(missing_tzid);
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
-
-    char tzid_err[] = "{ \"type\" : \"Feature\","
-                      "\"properties\" : { \"TZID\" : []}, \"geometry\" : { \"type\": \"polygon\", "
-                      "\"coordinates\": [[[8.28369,48.88277], [8.57757, "
-                      "48.88277], [8.57757, 49.07206], [8.28369, "
-                      "49.07206], [8.28369, 48.88277]]] }}";
-    doc.Parse(tzid_err);
-    BOOST_CHECK_THROW(util::validateFeature(doc), util::exception);
-
     char missing_geom[] = "{ \"type\" : \"Feature\","
                           "\"properties\" : { \"TZID\" : \"Europe/Berlin\"}, \"geometries\" : { "
                           "\"type\": \"polygon\", "
diff --git a/unit_tests/util/coordinate_calculation.cpp b/unit_tests/util/coordinate_calculation.cpp
index 4037e18b7..9ea47a307 100644
--- a/unit_tests/util/coordinate_calculation.cpp
+++ b/unit_tests/util/coordinate_calculation.cpp
@@ -420,7 +420,7 @@ BOOST_AUTO_TEST_CASE(computeArea)
                                            {FloatLongitude{.01}, FloatLatitude{-.01}},
                                            {FloatLongitude{.00}, FloatLatitude{.00}}};
 
-    BOOST_CHECK_CLOSE(2 * 1112.263 * 1112.263, computeArea(rhombus), 1e-3);
+    BOOST_CHECK_CLOSE(2 * 1109.462 * 1109.462, computeArea(rhombus), 1e-3);
 
     // edge cases
     auto self_intersection = std::vector<Coordinate>{{FloatLongitude{.00}, FloatLatitude{.00}},
diff --git a/unit_tests/util/group_by.cpp b/unit_tests/util/group_by.cpp
index 0b5da8d66..68f421a6a 100644
--- a/unit_tests/util/group_by.cpp
+++ b/unit_tests/util/group_by.cpp
@@ -34,7 +34,7 @@ struct SubRangeCounter
     template <typename Range> void operator()(Range &&) { count += 1; }
     std::size_t count = 0;
 };
-}
+} // namespace
 
 BOOST_AUTO_TEST_CASE(grouped_empty_test)
 {
diff --git a/unit_tests/util/indexed_data.cpp b/unit_tests/util/indexed_data.cpp
index a9001fcb7..6d9eecbe9 100644
--- a/unit_tests/util/indexed_data.cpp
+++ b/unit_tests/util/indexed_data.cpp
@@ -38,8 +38,8 @@ void test_rw(const Offsets &offsets, const Data &data)
 
     for (std::size_t index = 0; index < offsets.size() - 1; ++index)
     {
-        typename IndexedData::ResultType expected_result(&data[offsets[index]],
-                                                         &data[offsets[index + 1]]);
+        typename IndexedData::ResultType expected_result(data.begin() + offsets[index],
+                                                         data.begin() + offsets[index + 1]);
         BOOST_CHECK_EQUAL(expected_result, indexed_data.at(index));
     }
 }
diff --git a/unit_tests/util/range_table.cpp b/unit_tests/util/range_table.cpp
index 4d2053538..d9eacc910 100644
--- a/unit_tests/util/range_table.cpp
+++ b/unit_tests/util/range_table.cpp
@@ -14,7 +14,7 @@ using namespace osrm::util;
 constexpr unsigned BLOCK_SIZE = 16;
 typedef RangeTable<BLOCK_SIZE, osrm::storage::Ownership::Container> TestRangeTable;
 
-void ConstructionTest(std::vector<unsigned> lengths, std::vector<unsigned> offsets)
+void ConstructionTest(const std::vector<unsigned> &lengths, const std::vector<unsigned> &offsets)
 {
     BOOST_CHECK_EQUAL(lengths.size(), offsets.size() - 1);
 
diff --git a/unit_tests/util/serialization.cpp b/unit_tests/util/serialization.cpp
index d0c5e2c1c..dffb0ea03 100644
--- a/unit_tests/util/serialization.cpp
+++ b/unit_tests/util/serialization.cpp
@@ -88,7 +88,9 @@ BOOST_AUTO_TEST_CASE(tar_serialize_variable_indexed_data)
             {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17},
             {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}};
         std::vector<std::string> char_data = {
-            "HalloFoo", "ABCDEFGHIJKLMNOPQR", "ABCDEFGHIJKLMNOP",
+            "HalloFoo",
+            "ABCDEFGHIJKLMNOPQR",
+            "ABCDEFGHIJKLMNOP",
         };
 
         for (const auto i : util::irange<std::size_t>(0, offset_data.size()))